feat: 默认开启部门负责人视角

- 确认撤回时先预存占位记录（原消息在列表时被去重压制不显示），消息移除的同一次重算中占位原地顶上，消除 WS 推送与接口响应竞争导致的先删后加闪动
- 撤回失败且消息仍在列表时才清除预存记录，兼容"接口报错但服务端实际已撤回"的情况
- 点"重新编辑"不再删除占位，保留至 5 分钟过期，期间可反复回填（对齐微信行为），同步更新 ai-kb 文档

.claude/hooks/php-stan-check.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# Claude Code PostToolUse hook:Edit/Write 改动 app/ 下的 PHP 文件后,自动在 PHP 容器内
+# 对该文件跑 phpstan 单文件分析。失败时 exit 2,把错误回灌给 Claude 修复。
+# 任何环境不满足(无 python3 / 容器未运行 / 未装 phpstan)都静默放行,绝不阻塞编辑。
+set -u
+
+INPUT=$(cat)
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+
+command -v python3 >/dev/null 2>&1 || exit 0
+command -v docker >/dev/null 2>&1 || exit 0
+
+FILE_PATH=$(printf '%s' "$INPUT" | python3 -c "import sys,json;print(json.load(sys.stdin).get('tool_input',{}).get('file_path',''))" 2>/dev/null) || exit 0
+[ -n "$FILE_PATH" ] || exit 0
+
+case "$FILE_PATH" in
+    *.php) ;;
+    *) exit 0 ;;
+esac
+
+REL_PATH="${FILE_PATH#"$PROJECT_DIR"/}"
+case "$REL_PATH" in
+    app/*) ;;
+    *) exit 0 ;;
+esac
+[ -f "$PROJECT_DIR/$REL_PATH" ] || exit 0
+
+# 定位挂载本项目的 PHP 容器:
+# ① 环境变量 DOOTASK_PHP_CONTAINER;② .env 的 APP_ID;③ 扫描 /var/www 挂载源为本项目的容器
+CONTAINER="${DOOTASK_PHP_CONTAINER:-}"
+if [ -z "$CONTAINER" ] && [ -f "$PROJECT_DIR/.env" ]; then
+    APP_ID=$(grep -E '^APP_ID=' "$PROJECT_DIR/.env" 2>/dev/null | head -1 | cut -d= -f2 | tr -d '"' | tr -d "'")
+    if [ -n "$APP_ID" ] && docker ps --format '{{.Names}}' 2>/dev/null | grep -qx "dootask-php-$APP_ID"; then
+        CONTAINER="dootask-php-$APP_ID"
+    fi
+fi
+if [ -z "$CONTAINER" ]; then
+    RUNNING=$(docker ps -q 2>/dev/null)
+    [ -n "$RUNNING" ] && CONTAINER=$(docker inspect --format '{{.Name}}|{{range .Mounts}}{{if eq .Destination "/var/www"}}{{.Source}}{{end}}{{end}}' $RUNNING 2>/dev/null \
+        | awk -F'|' -v dir="$PROJECT_DIR" '$2 == dir {gsub(/^\//, "", $1); print $1; exit}')
+fi
+[ -n "$CONTAINER" ] || exit 0
+docker exec "$CONTAINER" test -f /var/www/vendor/bin/phpstan 2>/dev/null || exit 0
+
+OUTPUT=$(docker exec "$CONTAINER" sh -c "cd /var/www && php vendor/bin/phpstan analyse --no-progress --error-format=raw --memory-limit=-1 '$REL_PATH'" 2>&1)
+if [ $? -ne 0 ]; then
+    {
+        echo "phpstan 检查未通过($REL_PATH),请修复以下问题:"
+        printf '%s\n' "$OUTPUT" | grep -v '^Note:' | tail -30
+    } >&2
+    exit 2
+fi
+exit 0

.claude/settings.json

@@ -0,0 +1,16 @@
+{
+    "hooks": {
+        "PostToolUse": [
+            {
+                "matcher": "Edit|Write",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/php-stan-check.sh",
+                        "timeout": 120
+                    }
+                ]
+            }
+        ]
+    }
+}

.claude/skills/dootask-release/SKILL.md

@@ -44,6 +44,8 @@ description: 从 `pro` 分支发布 DooTask 前端新版本：翻译 → 版本
 
 多语言数据流：`language/original-{web,api}.txt`（原文/简体中文）→ 经翻译写入 `language/translate.json`（含 9 种语言）→ 生成 `public/language/{web,api}/*`。
 
+上下文翻译键用于保持短文案的界面宽度，同时区分不同语义，格式固定为 `[lower_snake_case].原文`，例如 `[weekday].一`、`[task_unit].个`。上下文前缀只参与翻译查找，不参与显示；运行时完整键缺失时会回退普通原文键。普通 key 的 `zh` 留空，上下文 key 的 `zh` 必须填写去掉前缀后的原文。
+
 **1.1 检测差异**
 
 ```shell
@@ -51,14 +53,15 @@ php .claude/skills/dootask-release/scripts/language.php diff
 ```
 
 输出 JSON：
+- `formatErrorCount > 0`：translate.json **已有条目**含 raw `(*)`/`(**)` key、字段结构错误、非法/不连续的参数编号或规范化重复 → **停止**，报告 `formatErrors`，交用户修复
 - `regexErrorCount > 0`：translate.json **已有条目**的占位符与某语言值不一致 → **停止**，报告 `regexErrors`，交用户修复（这是历史数据问题，不要自行猜测修改）
 - `redundantCount > 0`：translate.json 里有、但原文已删除的条目 → 仅作提示（apply 时会自动剔除，不致命）
 - `needsCount == 0`：无新文案 → **跳到 1.4 直接生成**
-- `needsCount > 0`：`needs` 数组即待翻译清单，每项 `key` 已转成占位符形式（如 `(%T1)`）→ 进入 1.2
+- `needsCount > 0`：`needs` 数组即待翻译清单，每项 `key` 已转成占位符形式（如 `(%T1)`）；上下文 key 还会带自动填充的 `zh` → 进入 1.2
 
 **1.2 翻译**
 
-对 `needs` 里的每个 `key`，翻成 8 种语言（`zh` 留空、`key` 原样保留）：`zh-CHT` `en` `ko` `ja` `de` `fr` `id` `ru`。
+对 `needs` 里的每个 `key`，翻成 8 种语言（`key` 原样保留）：`zh-CHT` `en` `ko` `ja` `de` `fr` `id` `ru`。普通 key 的 `zh` 留空；上下文 key 的 `zh` 使用 `needs` 已给出的原文，不得留空或改写。
 
 要求：贴合「项目任务管理系统」语境；占位符 `(%T1)`/`(%M1)` 等原样保留、不可增删改，位置可随目标语言语序调整：
 
@@ -68,7 +71,7 @@ php .claude/skills/dootask-release/scripts/language.php diff
 | (%T1)提交的「(%M2)」待你审批 | '(%M2)' submitted by (%T1) is waiting for your approval |
 
 把结果写成一个 JSON 数组文件（建议放 `/tmp/dootask-release-translated.json`，避免污染工作区），每个元素含全部 10 个字段，顺序为：
-`key, zh, zh-CHT, en, ko, ja, de, fr, id, ru`（`zh` 写 `""`）。
+`key, zh, zh-CHT, en, ko, ja, de, fr, id, ru`。
 
 ```json
 [
@@ -76,13 +79,21 @@ php .claude/skills/dootask-release/scripts/language.php diff
 ]
 ```
 
+上下文短词示例：
+
+```json
+[
+  {"key":"[task_unit].个","zh":"个","zh-CHT":"個","en":"tasks","ko":"개 작업","ja":"タスク","de":"Aufgaben","fr":"tâches","id":"tugas","ru":"задач"}
+]
+```
+
 **1.3 合并进 translate.json**
 
 ```shell
 php .claude/skills/dootask-release/scripts/language.php apply /tmp/dootask-release-translated.json
 ```
 
-脚本会校验字段完整性与占位符完整性、追加新条目、剔除冗余项，并按项目原生格式写回 `translate.json`。任一条不合格会报错停止，按提示修正翻译后重试。
+脚本会校验字段完整性、占位符完整性与上下文键格式，追加新条目、剔除冗余项，并按项目原生格式写回 `translate.json`。参数化 key 必须使用 `(%T1)`/`(%M1)` 形式，禁止输入 raw `(*)`/`(**)`；编号须按出现顺序从 1 连续递增，各语言值可调整占位符顺序，但占位符的类型、编号和数量必须与 key 完全一致。上下文 key 必须使用 `[lower_snake_case].原文`，且 `zh` 必须与原文部分完全一致。输入 JSON 内相同或规范化后相同的 key 会被拒绝；已存在于 `translate.json` 的非待补项也会被拒绝，避免覆盖歧义。任一条不合格会明确报错并停止，按提示修正翻译后重试。
 
 **1.4 生成前端/后端语言文件**
 
@@ -90,7 +101,7 @@ php .claude/skills/dootask-release/scripts/language.php apply /tmp/dootask-relea
 php .claude/skills/dootask-release/scripts/language.php generate
 ```
 
-由 `translate.json` 字节级重新生成 `public/language/web/*.js` 与 `public/language/api/*.json`（排序/转义与项目原生工具完全一致，正常情况下 diff 只包含本次新增条目）。
+由 `translate.json` 字节级重新生成 `public/language/web/*.js` 与 `public/language/api/*.json`（排序/转义与项目原生工具完全一致，正常情况下 diff 只包含本次新增条目）。生成前会再次执行格式与占位符校验；存在 raw `(*)`/`(**)` key 或占位符错误时不会写入生成文件。
 
 **1.5 报告**：用 `git status --short language public/language` 汇总本步改动，向用户报告新增了多少条翻译。
 

.claude/skills/dootask-release/scripts/language.php

@@ -6,7 +6,8 @@
 //
 // 子命令：
 //   language.php diff
-//       —— 输出 JSON：needs(待翻译，key 已转成 (%T1)/(%M1) 形式) / redundants(冗余,提示) / regexErrors(占位符错乱,致命)
+//       —— 输出 JSON：needs(待翻译，key 已转成 (%T1)/(%M1) 形式) / redundants(冗余,提示)
+//          / formatErrors(raw 占位符、字段或编号错误,致命) / regexErrors(各语言占位符错乱,致命)
 //   language.php apply <translated.json>
 //       —— 把新翻译合并进 translate.json（追加 + 剔除冗余），不生成 public 文件
 //   language.php generate
@@ -41,43 +42,169 @@ function read_generateds(): array
     return [$originals, $generateds];
 }
 
-// ---- 公共：构建 translations 映射（normalizedKey -> obj），并收集冗余/占位符错乱 ----
+// ---- 公共：占位符与条目结构校验 ----
+function parameter_tokens(string $value): array
+{
+    preg_match_all('/\(%[TM]\d+\)/', $value, $matches);
+    return $matches[0];
+}
+
+function normalize_key(string $key): string
+{
+    return preg_replace(["/\(%T\d+\)/", "/\(%M\d+\)/"], ["(*)", "(**)"], $key);
+}
+
+function context_source_key(string $key): ?string
+{
+    if (preg_match('/^\[([a-z][a-z0-9_]*)]\.([\s\S]+)$/', $key, $matches)) {
+        return $matches[2];
+    }
+    return null;
+}
+
+function validate_original_contexts(array $originals): array
+{
+    $errors = [];
+    foreach ($originals as $index => $key) {
+        if (preg_match('/^\[[^\]]+]\./', $key) && context_source_key($key) === null) {
+            $errors[] = [
+                'location' => "originals[index $index]",
+                'message' => "上下文翻译键格式错误：$key",
+            ];
+        }
+    }
+    return $errors;
+}
+
+function validate_entry(array $obj, string $location, bool $requireTranslations): array
+{
+    $formatErrors = [];
+    $regexErrors = [];
+    foreach ($GLOBALS['LANG_FIELDS'] as $field) {
+        if (!array_key_exists($field, $obj)) {
+            $formatErrors[] = ['location' => "$location.$field", 'message' => "缺少字段 $field"];
+        } elseif (!is_string($obj[$field])) {
+            $formatErrors[] = ['location' => "$location.$field", 'message' => "字段 $field 必须是字符串"];
+        } elseif ($requireTranslations && $field !== 'key' && $field !== 'zh' && $obj[$field] === '') {
+            $formatErrors[] = ['location' => "$location.$field", 'message' => "字段 $field 不得为空"];
+        }
+    }
+    if (!isset($obj['key']) || !is_string($obj['key'])) {
+        return [$formatErrors, $regexErrors];
+    }
+
+    $key = $obj['key'];
+    if (preg_match('/^\[[^\]]+]\./', $key)) {
+        $sourceKey = context_source_key($key);
+        if ($sourceKey === null) {
+            $formatErrors[] = ['location' => "$location.key", 'message' => "上下文翻译键格式错误：$key"];
+        } elseif (($obj['zh'] ?? null) !== $sourceKey) {
+            $formatErrors[] = [
+                'location' => "$location.zh",
+                'message' => "上下文翻译键必须填写原文：$sourceKey",
+            ];
+        }
+    }
+    if (preg_match('/\(\*{1,2}\)/', $key)) {
+        $formatErrors[] = [
+            'location' => "$location.key",
+            'message' => "key 不得包含 raw (*)/(**)，必须使用 (%T1)/(%M1)：$key",
+        ];
+    }
+    $withoutValidParameters = preg_replace('/\(%[TM]\d+\)/', '', $key);
+    if (str_contains($withoutValidParameters, '(%')) {
+        $formatErrors[] = ['location' => "$location.key", 'message' => "存在非法参数占位符：$key"];
+    }
+
+    $keyTokens = parameter_tokens($key);
+    foreach ($keyTokens as $index => $token) {
+        preg_match('/\d+/', $token, $number);
+        if ((int)$number[0] !== $index + 1) {
+            $formatErrors[] = [
+                'location' => "$location.key",
+                'message' => "参数编号必须按出现顺序从 1 连续递增：$key",
+            ];
+            break;
+        }
+    }
+
+    $expected = $keyTokens;
+    sort($expected);
+    foreach ($GLOBALS['LANG_FIELDS'] as $field) {
+        if ($field === 'key' || !isset($obj[$field]) || !is_string($obj[$field]) || $obj[$field] === '') {
+            continue;
+        }
+        $actual = parameter_tokens($obj[$field]);
+        sort($actual);
+        if ($actual !== $expected) {
+            $regexErrors[] = [
+                'location' => "$location.$field",
+                'key' => $key,
+                'field' => $field,
+                'value' => $obj[$field],
+                'expected' => $expected,
+                'actual' => $actual,
+                'message' => "参数占位符缺失、类型或编号不一致",
+            ];
+        }
+    }
+    return [$formatErrors, $regexErrors];
+}
+
+function print_validation_errors(array $formatErrors, array $regexErrors): void
+{
+    foreach ($formatErrors as $error) {
+        fwrite(STDERR, "格式错误 {$error['location']}：{$error['message']}\n");
+    }
+    foreach ($regexErrors as $error) {
+        fwrite(STDERR, "占位符错误 {$error['location']}：{$error['message']}；key={$error['key']}\n");
+    }
+}
+
+// ---- 公共：构建 translations 映射（normalizedKey -> obj），并收集冗余/格式/占位符错乱 ----
 function build_translations(array $originals): array
 {
     $translations = [];
     $redundants = [];
-    $regrror = [];
+    $regexErrors = [];
+    $formatErrors = validate_original_contexts($originals);
     if (!file_exists("translate.json")) {
         fwrite(STDERR, "translate.json not exists\n");
         exit(1);
     }
     $tmps = json_decode(file_get_contents("translate.json"), true);
-    foreach ($tmps as $obj) {
+    if (!is_array($tmps)) {
-        if (!isset($obj['key'])) {
+        $formatErrors[] = ['location' => 'translate.json', 'message' => '根数据必须是 JSON 数组'];
+        return [$translations, $redundants, $regexErrors, $formatErrors];
+    }
+    foreach ($tmps as $index => $obj) {
+        $location = "translate.json[index $index]";
+        if (!is_array($obj)) {
+            $formatErrors[] = ['location' => $location, 'message' => '条目必须是对象'];
+            continue;
+        }
+        [$entryFormatErrors, $entryRegexErrors] = validate_entry($obj, $location, false);
+        $formatErrors = array_merge($formatErrors, $entryFormatErrors);
+        $regexErrors = array_merge($regexErrors, $entryRegexErrors);
+        if (!isset($obj['key']) || !is_string($obj['key'])) {
             continue;
         }
         $currentKey = $obj['key'];
-        $originalKey = preg_replace(["/\(%T\d+\)/", "/\(%M\d+\)/"], ["(*)", "(**)"], $currentKey);
+        $originalKey = normalize_key($currentKey);
         if (!in_array($originalKey, $originals)) {
             $redundants[$originalKey] = $obj;
             continue;
         }
-        $translations[$originalKey] = $obj;
+        if (isset($translations[$originalKey])) {
-        if (preg_match_all('/\(%[TM]\d+\)/', $currentKey, $matches)) {
+            $formatErrors[] = [
-            foreach ($matches[0] as $match) {
+                'location' => $location,
-                foreach ($obj as $k => $v) {
+                'message' => "规范化后 key 重复：$originalKey",
-                    if (empty($v)) {
+            ];
             continue;
         }
-                    if (!str_contains($v, $match)) {
+        $translations[$originalKey] = $obj;
-                        $regrror[$originalKey] = ['key' => $currentKey, 'field' => $k, 'value' => $v, 'match' => $match];
-                        continue 2;
     }
-                }
+    return [$translations, $redundants, $regexErrors, $formatErrors];
-            }
-        }
-    }
-    return [$translations, $redundants, $regrror];
 }
 
 // ---- 公共：由 translate.json + originals 重新生成 public 文件 ----
@@ -127,7 +254,7 @@ function generate(array $generateds, array $translations): void
 
 if ($cmd === 'diff') {
     [$originals, $generateds] = read_generateds();
-    [$translations, $redundants, $regrror] = build_translations($originals);
+    [$translations, $redundants, $regexErrors, $formatErrors] = build_translations($originals);
 
     // 需要翻译的数据（对齐 translate.php 150-169：占位符按单一计数器编号）
     $needs = [];
@@ -147,20 +274,27 @@ if ($cmd === 'diff') {
             $label = strlen($m[1]) > 1 ? "M" : "T";
             return "(%" . $label . $c++ . ")";
         }, $key);
-        $needsOut[] = ['key' => $converted];
+        $need = ['key' => $converted];
+        $contextSource = context_source_key($converted);
+        if ($contextSource !== null) {
+            $need['zh'] = $contextSource;
+        }
+        $needsOut[] = $need;
     }
 
     echo json_encode([
         'needsCount' => count($needsOut),
         'redundantCount' => count($redundants),
-        'regexErrorCount' => count($regrror),
+        'formatErrorCount' => count($formatErrors),
+        'regexErrorCount' => count($regexErrors),
         'needs' => $needsOut,
         'redundants' => array_keys($redundants),
-        'regexErrors' => array_values($regrror),
+        'formatErrors' => array_values($formatErrors),
+        'regexErrors' => array_values($regexErrors),
     ], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) . "\n";
 
-    if (count($regrror) > 0) {
+    if (count($formatErrors) > 0 || count($regexErrors) > 0) {
-        exit(2); // 已有数据占位符错乱，需先修复
+        exit(2); // 已有数据格式或占位符错乱，需先修复
     }
     exit(0);
 }
@@ -172,9 +306,10 @@ if ($cmd === 'apply') {
         exit(1);
     }
     [$originals, $generateds] = read_generateds();
-    [$translations, $redundants, $regrror] = build_translations($originals);
+    [$translations, $redundants, $regexErrors, $formatErrors] = build_translations($originals);
-    if (count($regrror) > 0) {
+    if (count($formatErrors) > 0 || count($regexErrors) > 0) {
-        fwrite(STDERR, "translate.json 已有条目占位符错乱，请先修复再发版。\n");
+        print_validation_errors($formatErrors, $regexErrors);
+        fwrite(STDERR, "translate.json 已有条目格式或占位符错误，请先修复再发版。\n");
         exit(2);
     }
 
@@ -183,45 +318,49 @@ if ($cmd === 'apply') {
         fwrite(STDERR, "translated.json 必须是数组\n");
         exit(1);
     }
-    $added = 0;
+    $originalSet = array_flip($originals);
-    foreach ($incoming as $raw) {
+    $incomingSeen = [];
-        foreach ($GLOBALS['LANG_FIELDS'] as $f) {
+    $itemsToAdd = [];
-            if (!array_key_exists($f, $raw)) {
+    foreach ($incoming as $index => $raw) {
-                fwrite(STDERR, "新翻译缺字段 \"$f\"：" . json_encode($raw, JSON_UNESCAPED_UNICODE) . "\n");
+        if (!is_array($raw)) {
+            fwrite(STDERR, "新翻译 translated.json[index $index] 必须是对象\n");
             exit(1);
         }
-        }
+        [$incomingFormatErrors, $incomingRegexErrors] = validate_entry($raw, "translated.json[index $index]", true);
-        // 占位符完整性：key 里每个 (%T1)/(%M1) 必须出现在每个非空语言值里
+        if (count($incomingFormatErrors) > 0 || count($incomingRegexErrors) > 0) {
-        if (preg_match_all('/\(%[TM]\d+\)/', $raw['key'], $m)) {
+            print_validation_errors($incomingFormatErrors, $incomingRegexErrors);
-            foreach ($m[0] as $match) {
-                foreach ($GLOBALS['LANG_FIELDS'] as $f) {
-                    if ($f === 'key' || $f === 'zh') {
-                        continue;
-                    }
-                    if (empty($raw[$f])) {
-                        continue;
-                    }
-                    if (!str_contains($raw[$f], $match)) {
-                        fwrite(STDERR, "占位符 $match 在字段 \"$f\" 缺失：{$raw['key']}\n");
             exit(1);
         }
-                }
+        // 规范化：固定字段顺序；上下文翻译键保留 zh 作为实际显示原文
-            }
-        }
-        // 规范化：固定字段顺序 + zh 置空
         $item = [];
         foreach ($GLOBALS['LANG_FIELDS'] as $f) {
-            $item[$f] = $f === 'zh' ? '' : $raw[$f];
+            $item[$f] = $f === 'zh' && context_source_key($raw['key']) === null ? '' : $raw[$f];
         }
-        $originalKey = preg_replace(["/\(%T\d+\)/", "/\(%M\d+\)/"], ["(*)", "(**)"], $item['key']);
+        $originalKey = normalize_key($item['key']);
+        if (!isset($originalSet[$originalKey])) {
+            fwrite(STDERR, "新翻译 key 不在 original-web.txt/original-api.txt：{$item['key']}\n");
+            exit(1);
+        }
+        if (isset($incomingSeen[$originalKey])) {
+            fwrite(STDERR, "新翻译输入内部重复：translated.json[index {$incomingSeen[$originalKey]}] 与 translated.json[index $index] 规范化后均为「$originalKey」\n");
+            exit(1);
+        }
+        if (isset($translations[$originalKey])) {
+            fwrite(STDERR, "新翻译 key 已存在于 translate.json，非待补项或存在覆盖歧义：{$item['key']}（规范化：$originalKey）\n");
+            exit(1);
+        }
+        $incomingSeen[$originalKey] = $index;
+        $itemsToAdd[$originalKey] = $item;
+    }
+
+    foreach ($itemsToAdd as $originalKey => $item) {
         $translations[$originalKey] = $item;
-        $added++;
     }
 
     // array_values：现有条目（去冗余）在前，新条目追加在后
     file_put_contents("translate.json", json_encode(array_values($translations), JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT));
     echo json_encode([
-        'added' => $added,
+        'added' => count($itemsToAdd),
         'total' => count($translations),
         'droppedRedundant' => count($redundants),
     ], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) . "\n";
@@ -230,7 +369,12 @@ if ($cmd === 'apply') {
 
 if ($cmd === 'generate') {
     [$originals, $generateds] = read_generateds();
-    [$translations] = build_translations($originals);
+    [$translations, $redundants, $regexErrors, $formatErrors] = build_translations($originals);
+    if (count($formatErrors) > 0 || count($regexErrors) > 0) {
+        print_validation_errors($formatErrors, $regexErrors);
+        fwrite(STDERR, "translate.json 存在格式或占位符错误，已停止生成。\n");
+        exit(2);
+    }
     generate($generateds, $translations);
     exit(0);
 }

.github/workflows/publish.yml

@@ -92,7 +92,7 @@ jobs:
       - name: Setup PHP
         uses: shivammathur/setup-php@v2
         with:
-          php-version: '8.0'
+          php-version: '8.4'
           extensions: mbstring, intl, gd, xml, zip, swoole
           tools: composer:v2
 

.github/workflows/tests.yml

@@ -0,0 +1,79 @@
+name: Tests
+
+on:
+  push:
+    branches: [pro, master, dev]
+  pull_request:
+
+jobs:
+  static-checks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.4'
+          extensions: mbstring, intl, gd, xml, zip, swoole, redis
+          tools: composer:v2
+
+      - name: Install Composer Dependencies
+        run: composer install --prefer-dist --no-interaction
+
+      - name: PHPStan
+        run: composer stan
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install NPM Dependencies
+        run: npm install --no-audit --no-fund
+
+      - name: ESLint
+        run: npm run lint
+
+      - name: Language Check
+        run: npm run check:lang
+
+  phpunit:
+    runs-on: ubuntu-latest
+    services:
+      mariadb:
+        image: mariadb:10.7.3
+        env:
+          MYSQL_ROOT_PASSWORD: test
+          MYSQL_DATABASE: dootask
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h localhost -ptest"
+          --health-interval=10s
+          --health-timeout=5s
+          --health-retries=10
+      redis:
+        image: redis:alpine
+        ports:
+          - 6379:6379
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # 用项目自身的 PHP 镜像跑测试(内含 /usr/lib/doo/doo.so FFI 库,裸 runner 无法运行)
+      - name: Run PHPUnit in DooTask PHP image
+        run: |
+          docker run --rm --network host -v "$GITHUB_WORKSPACE":/var/www -w /var/www \
+            kuaifan/php:swoole-8.4 sh -c '
+              composer install --prefer-dist --no-interaction &&
+              cp .env.example .env &&
+              sed -i "s/^DB_HOST=.*/DB_HOST=127.0.0.1/" .env &&
+              sed -i "s/^DB_DATABASE=.*/DB_DATABASE=dootask/" .env &&
+              sed -i "s/^DB_PASSWORD=.*/DB_PASSWORD=test/" .env &&
+              sed -i "s/^REDIS_HOST=.*/REDIS_HOST=127.0.0.1/" .env &&
+              php artisan key:generate &&
+              php artisan migrate --seed --force &&
+              php vendor/bin/phpunit
+            '

.gitignore

@@ -65,3 +65,4 @@ README_LOCAL.md
 
 # playwright
 .playwright-mcp/
+/.phpunit.cache

.prefetch

@@ -158,11 +158,6 @@ drawio/webapp/js/app.min.js
 drawio/webapp/js/extensions.min.js
 drawio/webapp/js/shapes-14-6-5.min.js
 drawio/webapp/js/stencils.min.js
-drawio/webapp/math/es5/core.js
-drawio/webapp/math/es5/input/asciimath.js
-drawio/webapp/math/es5/input/tex.js
-drawio/webapp/math/es5/output/svg.js
-drawio/webapp/math/es5/output/svg/fonts/tex.js
 drawio/webapp/styles/grapheditor.css
 
 minder/css/chunk-vendors.fe9c56c6.css

CHANGELOG.md

@@ -2,6 +2,88 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.8.89]
+
+### Features
+
+- 管理后台仪表盘新增负责人视角，可按部门查看团队任务；个人视角的待办、逾期、今日和即将到期任务展示也更清晰。
+- 语义搜索升级为更智能的自动向量检索，搜索相关内容更准确，内容更新后会自动保持索引同步。
+- 撤回聊天文字或 Markdown 消息后支持「重新编辑」，可在有效期内恢复原内容继续修改。
+- 微应用加载失败时会显示清晰的错误提示，并提供重试和关闭入口。
+- 「我的文件」现在包含已共享文件，切换板块时优先展示缓存内容，查找文件更顺畅。
+
+### Bug Fixes
+
+- 修复 AI 助手模型隐藏设置未完全生效的问题，正在使用的模型被隐藏时会自动切换到可用模型。
+- 修复仪表盘待完成分组默认展开状态不一致的问题。
+- 修复撤回消息、文件切换及部分网络异常场景下的显示和状态同步问题。
+
+### Performance
+
+- 优化仪表盘移动端布局与任务分组样式，减少页面拥挤，浏览和操作更顺手。
+
+## [1.8.69]
+
+### Features
+
+- 文件页全新分区：拆分「我的文件」与「共享文件」两个板块，共享板块还能进一步筛选「我共享的」和「共享给我的」；上方工具栏合并为一行，查找和切换更清爽。
+- AI 助手支持隐藏模型：可将部分模型对普通用户隐藏，选择列表更简洁；当正在使用的模型被隐藏时，会自动切换到可用模型，避免选择异常。
+
+### Bug Fixes
+
+- 修复自定义应用「全员可见」设置有时不生效、以及再次编辑时可见范围被重置为「仅管理员」的问题。
+- 修复已删除 / 已归档的项目仍会继续生成周期任务的问题；对这些项目下遗留的任务，相关成员现在也能正常打开详情并删除。
+
+## [1.8.64]
+
+### Features
+
+- 大文件上传全面升级：上传单个文件不再受 1G 限制，文件柜、聊天、任务附件、头像与系统图片、编辑器粘贴等场景统一支持；相同文件可「秒传」无需重复上传，上传中断后也能从断点继续，更快更稳。
+- 新增应用菜单角标：插件与微应用可在菜单入口显示数字或红点提醒，应用未打开也能收到，打开后自动清除，手机端底部导航同样支持。
+- 登录支持多授权选择：当账号名下有多个可用授权时，登录时可弹窗选择本次要使用的授权。
+- 授权页面重新排版：正常状态只展示核心信息，出现到期提醒、已过期或设备不匹配时会浮出醒目提示，授权详情可展开查看，状态更清晰。
+- 新增一键安装 / 升级脚本：一行命令即可完成部署或升级，命令行提示同时支持中文与英文。
+- AI 助手选择模型时，将官方「Doo AI」分组排到下拉框最前，选择更方便。
+
+### Bug Fixes
+
+- 修复部分环境下登录验证码图片无法显示的问题。
+- 修复只读成员仍能看到并点击文件「删除」入口的问题，删除权限现与实际权限保持一致。
+- 修复手机端 AI 助手在弹窗模式下显示异常的问题，恢复为居中弹框。
+- 修复安装后网页服务偶尔未自动启动、卸载后残留数据、以管理员身份更新被拦截等部署问题。
+
+### Performance
+
+- 优化应用菜单角标的计算方式，减少重复读取，加载更快。
+
+## [1.8.45]
+
+### Features
+
+- AI 助手全面升级：现在能直接带你跳转页面、协助完成操作；回复可一键复制、查看时间、点赞或点踩反馈；较长的提问支持点击展开查看全部内容；对话浮窗支持手势返回 / ESC 快捷关闭，并完善了手机端适配与流式回复体验。
+- AI 助手接入产品知识库，回答更贴合 DooTask 的实际功能与使用方法。
+- 新增官方 AI 服务「Doo AI」，并支持为不同模型设置思考深度，按需选择更合适的模型。
+- 新增「在线授权」：通过邮箱验证码即可自助开通或申请试用，到期自动续期；在线授权与离线授权可一键切换、互不冲突，授权状态一目了然。
+- 手机端聊天默认显示发送按钮，发送消息更顺手。
+
+### Bug Fixes
+
+- 修复使用中文、日文等输入法打字时，回车或删除键偶尔会误触发送 / 提交的问题。
+- 修复深色主题下部分微应用自定义背景色显示异常的问题。
+- 修复在独立窗口打开的微应用，关闭应用后窗口未一同关闭的问题。
+- 修复个别微应用打开时报错、无法正常加载的问题。
+- 修复部分反向代理 / HTTPS 环境下访问地址协议识别错误的问题。
+- 优化标签输入框，支持多种分隔符录入，输入更顺畅。
+- 优化邮件发送的稳定性，修复发信超时判断不准确的问题。
+
+### Performance
+
+- 全面升级底层运行框架（Laravel 13 + PHP 8.4），整体运行更快、更稳定、更安全。
+
+### Miscellaneous
+
+- 内置审批功能已从主程序移除，改由应用中心的审批应用 / 微应用提供；原有审批能力可通过安装对应应用继续使用。
+
 ## [1.7.90]
 
 ### Features

CLAUDE.md

@@ -1,6 +1,6 @@
 ## 项目概述
 
-Laravel 8 (LaravelS/Swoole) + Vue 2 (Vite) + Electron。开源任务/项目管理系统。
+Laravel 13 (LaravelS/Swoole, PHP 8.4) + Vue 2 (Vite) + Electron。开源任务/项目管理系统。
 
 ## 开发命令
 
@@ -17,11 +17,31 @@ Laravel 8 (LaravelS/Swoole) + Vue 2 (Vite) + Electron。开源任务/项目管
 
 前端代码改动只做 Edit/Write，不要为了"验证"启动 dev server。用户明确说"跑一下 / 出包"时除外。
 
+### 质量门禁（改完代码必须自查，CI 同步在跑，见 .github/workflows/tests.yml）
+
+- `./cmd composer stan` — phpstan（level 1 + baseline，存量已封存，新增错误必须清零）
+- `npm run lint` — ESLint（error 必须为 0；warn 是存量遗留，见 eslint.config.mjs 注释）
+- `npm run check:lang` — 校验前端 `$L()` 字面量是否已登记到 `language/original-web.txt`
+- 改动控制器 public 方法或路由后跑 `./cmd artisan doc:api-map` 重新生成对照表
+
+## 代码检索地图（先查表，再 grep）
+
+- API URL ↔ 控制器方法对照：`routes/api-map.md`（生成式文件，勿手改）
+- 前端事件总线（mitt）收发对照：`docs/events-map.md`（`npm run events:map` 重新生成）
+- `$A` / `$L` 全局工具类型声明：`types/dootask-globals.d.ts`（新增 `$A` 方法须同步此文件）
+
+## 架构增量规则（只约束新增代码，存量"动到哪迁到哪"）
+
+- **巨型文件冻结**：不再往 `ProjectController`、`UsersController`、`DialogController`、`app/Module/Base.php`、`resources/assets/js/store/actions.js` 新增方法/函数；新功能领域开新控制器或新模块文件（动态路由天然支持多控制器）
+- **业务编排归层**：跨模型的业务流程写在 `app/Module/`（或 `app/Services/`），模型只保留数据访问与自身状态变更；Swoole Task 只做投递与调用，不直接编排业务
+- **配置读取**：业务代码禁止直接 `env()`，统一走 `config()`（项目自有配置集中在 `config/dootask.php`）
+
 ## Gotchas
 
 ### LaravelS/Swoole
 
 - **避免在静态属性、单例、全局变量中存储请求级状态**——请求间共享进程，会导致数据串联和内存泄漏
+  - 要存请求级状态，用 `RequestContext::save('key', $value)` / `RequestContext::get('key')`（参考 `User::authInfo()` 的用法，见 `app/Services/RequestContext.php`）
 - 构造函数、服务提供者、`boot()` 方法不会在每个请求重新执行
 - 配置/路由变更需要 `./cmd php restart` 或容器重启才能生效
 - 长生命周期逻辑（WebSocket、定时器）应复用现有模式，避免阻塞协程/事件循环
@@ -48,6 +68,15 @@ Laravel 8 (LaravelS/Swoole) + Vue 2 (Vite) + Electron。开源任务/项目管
 
 - 新增用户可见文本须追加原文（简体中文）到：前端 `language/original-web.txt`，后端 `language/original-api.txt`（去重）
 - 前端翻译用 `$L("文本")`，动态值用 `(*)` 占位：`$L('共(*)条', n)`——禁止拼接翻译
+- 单字或短词因上下文不同可能产生歧义时，使用 `[lower_snake_case].原文` 上下文键，例如 `$L('[weekday].一')`、`$L('[task_unit].个')`；前缀只参与翻译查找，界面仍显示原文。此类键须完整登记到 `original-web.txt`，且 `translate.json` 的 `zh` 必须填写去除前缀后的原文；普通键的 `zh` 仍留空
+
+## ai-kb 同步规则
+
+`resources/ai-kb/` 是产品内 AI 助手 RAG 检索的功能知识库（目录结构、写作规范、索引机制见其 `README.md` 与 `_schema/`）。
+
+- **同步时机**：改动用户可见的功能/菜单/按钮/流程/字段、API 行为（错误码、参数含义、返回结构）、插件/微应用、权限/角色定义时，必须在同一次提交中同步更新 ai-kb，不要把 ai-kb 改动单独拆成一个提交
+- **怎么改**：在 `_meta/feature-map.yaml` 找到对应 feature 的 chunk 清单，按 `_schema/chunk-style.md` 与 `_schema/frontmatter.md` 修改或新建 chunk，并把 frontmatter 的 `last_verified` 更新为当前主程序版本号
+- **改完即止**：无需触发任何索引操作，插件容器启动时会自动对账收敛
 
 ## Playwright 测试
 

README.md

@@ -9,14 +9,6 @@ English | **[中文文档](./README_CN.md)**
 
 - Group Number: `546574618`
 
-## 📍 Migration from 0.x to 1.x
-
-- Please ensure to back up your data before upgrading!
-- If the upgrade fails, try running `./cmd update` multiple times.
-- If you encounter "Container xxx not found" during upgrade, run `./cmd reup` and then execute `./cmd update`.
-- If you see a 502 error after upgrading, run `./cmd reup` to restart the services.
-- If you encounter "Application 'xxx' not installed" after upgrading, log in with the admin account and install the relevant applications from the App Store.
-
 ## Installation Requirements
 
 - Required: `Docker v20.10+` and `Docker Compose v2.0+`
@@ -27,6 +19,16 @@ English | **[中文文档](./README_CN.md)**
 
 ### Deploy Project
 
+**Option 1: One-line script (recommended)**
+
+Run it in an empty directory to clone and install automatically; run it inside an existing installation to check and upgrade:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/kuaifan/dootask/pro/bin/install | bash
+```
+
+**Option 2: Manual deployment**
+
 ```bash
 # 1、Clone the project to your local machine or server
 
@@ -105,11 +107,18 @@ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
 **Note: Please backup your data before upgrading!**
 
+Recommended: use the one-line script (run it inside an existing installation; it pulls the latest code and finishes the upgrade in a single run):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/kuaifan/dootask/pro/bin/install | bash
+```
+
+Or use the local command:
+
 ```bash
 ./cmd update
 ```
 
-* Please retry if upgrade fails across major versions.
 * If you encounter 502 errors after upgrade, run `./cmd reup` to restart services.
 
 ## Project Migration

README_CN.md

@@ -9,14 +9,6 @@
 
 - QQ群号: `546574618`
 
-## 📍 0.x 迁移到 1.x
-
-- 升级时请务必备份好数据！
-- 如果升级失败请尝试执行 `./cmd update` 重试几次。
-- 如果升级中出现 `没有找到 xxx 容器` 的提示，请运行 `./cmd reup` 后再执行 `./cmd update`。
-- 如果升级后出现502错误请运行 `./cmd reup` 重启服务即可。
-- 如果升级后出现 `应用「xxx」未安装` 的提示，请使用管理员账号进入应用商店安装相关应用。
-
 ## 安装程序
 
 - 必须安装：`Docker v20.10+` 和 `Docker Compose v2.0+`
@@ -27,6 +19,16 @@
 
 ### 部署项目
 
+**方式一：一键脚本（推荐）**
+
+在空目录中执行即自动克隆并安装；在已安装目录中执行则自动检查并升级：
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/kuaifan/dootask/pro/bin/install | bash
+```
+
+**方式二：手动部署**
+
 ```bash
 # 1、克隆项目到您的本地或服务器
 
@@ -105,11 +107,18 @@ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
 **注意：在升级之前请备份好你的数据！**
 
+推荐使用一键脚本升级（在已安装目录中执行，自动拉取最新代码并完成升级，无需重复执行）：
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/kuaifan/dootask/pro/bin/install | bash
+```
+
+或使用本地命令：
+
 ```bash
 ./cmd update
 ```
 
-* 跨越大版本升级失败时请重试执行一次。
 * 如果升级后出现502请运行 `./cmd reup` 重启服务即可。
 
 ## 迁移项目

app/Console/Commands/DocApiMap.php

@@ -0,0 +1,143 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Route;
+use ReflectionClass;
+use ReflectionMethod;
+
+class DocApiMap extends Command
+{
+    protected $signature = 'doc:api-map';
+    protected $description = '生成 API 路由对照表（routes/api-map.md）';
+
+    public function handle(): int
+    {
+        $controllers = $this->collectControllers();
+        if (empty($controllers)) {
+            $this->error('未从路由中解析到任何 api 控制器');
+            return 1;
+        }
+
+        $total = 0;
+        $sections = [];
+        foreach ($controllers as $prefix => $class) {
+            $rows = $this->collectMethods($prefix, $class);
+            $total += count($rows);
+            $sections[] = $this->renderSection($prefix, $class, $rows);
+        }
+
+        $path = base_path('routes/api-map.md');
+        file_put_contents($path, $this->renderHeader($total) . implode("\n", $sections));
+
+        $this->info("已生成: routes/api-map.md（控制器 " . count($controllers) . " 个，接口 {$total} 个）");
+        return 0;
+    }
+
+    /**
+     * 从已注册路由中收集 api 前缀与控制器的映射
+     * 匹配 routes/web.php 中的动态路由：api/{prefix}/{method}
+     * @return array [prefix => 控制器类名]
+     */
+    private function collectControllers(): array
+    {
+        $controllers = [];
+        foreach (Route::getRoutes() as $route) {
+            if (!preg_match('/^api\/(\w+)\/\{method}$/', $route->uri())) {
+                continue;
+            }
+            preg_match('/^api\/(\w+)\/\{method}$/', $route->uri(), $match);
+            $class = $route->getAction('controller');
+            if ($class && class_exists($class)) {
+                $controllers[$match[1]] = $class;
+            }
+        }
+        return $controllers;
+    }
+
+    /**
+     * 反射收集控制器的接口方法
+     * @param string $prefix 路由前缀（如 project）
+     * @param string $class 控制器类名
+     * @return array [['url' => ..., 'method' => ..., 'http' => ..., 'title' => ...], ...]
+     */
+    private function collectMethods(string $prefix, string $class): array
+    {
+        $rows = [];
+        $reflection = new ReflectionClass($class);
+        foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+            // 仅保留本类声明的实例方法，排除 __invoke/__before/__construct 等魔术/框架方法
+            if ($method->getDeclaringClass()->getName() !== $class
+                || $method->isStatic()
+                || str_starts_with($method->getName(), '__')) {
+                continue;
+            }
+            [$http, $title] = $this->parseApiDoc($method);
+            $rows[] = [
+                'url' => "api/{$prefix}/" . str_replace('__', '/', $method->getName()),
+                'method' => $method->getName() . '()',
+                'http' => $http,
+                'title' => $title,
+            ];
+        }
+        return $rows;
+    }
+
+    /**
+     * 解析方法 docblock 中的 @api 注释行
+     * 格式如：@api {get} api/project/lists 获取项目列表
+     * @return array [HTTP 方法, 标题]，无 @api 注释时为 ['any', '']
+     */
+    private function parseApiDoc(ReflectionMethod $method): array
+    {
+        $doc = $method->getDocComment();
+        if ($doc && preg_match('/@api\s+\{(\w+)}\s+(\S+)(?:[ \t]+(.+))?/', $doc, $match)) {
+            return [strtolower($match[1]), trim($match[3] ?? '')];
+        }
+        return ['any', ''];
+    }
+
+    /**
+     * 生成文件头说明
+     */
+    private function renderHeader(int $total): string
+    {
+        return <<<MD
+            # API 路由对照表
+
+            > 此文件由 `php artisan doc:api-map` 生成，勿手改。
+
+            接口总数：{$total}
+
+            ## 路由规则
+
+            API 使用动态路由（见 `routes/web.php`），URL 段映射为控制器方法名：
+
+            - `api/{controller}/{method}` → `{method}()`，如 `api/project/lists` → `ProjectController::lists()`
+            - `api/{controller}/{method}/{action}` → `{method}__{action}()`（双下划线连接），如 `api/project/invite/join` → `ProjectController::invite__join()`
+            - 路由最多两段，方法名最多一个双下划线
+
+
+            MD;
+    }
+
+    /**
+     * 生成单个控制器的表格段落
+     */
+    private function renderSection(string $prefix, string $class, array $rows): string
+    {
+        $short = class_basename($class);
+        $lines = [
+            "## {$prefix}（{$short}）",
+            '',
+            '| URL | 方法名 | HTTP | 说明 |',
+            '| --- | --- | --- | --- |',
+        ];
+        foreach ($rows as $row) {
+            $lines[] = "| {$row['url']} | {$row['method']} | {$row['http']} | {$row['title']} |";
+        }
+        $lines[] = '';
+        return implode("\n", $lines);
+    }
+}

app/Console/Commands/GenerateManticoreVectors.php

@@ -1,205 +0,0 @@
-<?php
-
-namespace App\Console\Commands;
-
-use App\Console\Commands\Traits\ManticoreSyncLock;
-use App\Models\File;
-use App\Models\Project;
-use App\Models\ProjectTask;
-use App\Models\User;
-use App\Models\WebSocketDialogMsg;
-use App\Module\Apps;
-use App\Module\Manticore\ManticoreFile;
-use App\Module\Manticore\ManticoreKeyValue;
-use App\Module\Manticore\ManticoreMsg;
-use App\Module\Manticore\ManticoreProject;
-use App\Module\Manticore\ManticoreTask;
-use App\Module\Manticore\ManticoreUser;
-use Illuminate\Console\Command;
-
-/**
- * 异步向量生成命令
- *
- * 用于后台批量生成已索引数据的向量，与全文索引解耦
- * 使用双指针追踪：sync:xxxLastId（全文已同步）和 vector:xxxLastId（向量已生成）
- *
- * 运行模式：
- * - 持续处理直到所有待处理数据完成
- * - 每批处理完成后休眠几秒，避免 API 过载
- * - 定时器只作为兜底触发机制
- */
-class GenerateManticoreVectors extends Command
-{
-    use ManticoreSyncLock;
-
-    protected $signature = 'manticore:generate-vectors
-                            {--type=all : 类型 (msg/file/task/project/user/all)}
-                            {--batch=50 : 每批 embedding 数量}
-                            {--sleep=3 : 每批处理后休眠秒数}
-                            {--reset : 重置向量进度指针}';
-
-    protected $description = '批量生成 Manticore 已索引数据的向量';
-
-    /**
-     * 类型配置
-     */
-    private const TYPE_CONFIG = [
-        'msg' => [
-            'syncKey' => 'sync:manticoreMsgLastId',
-            'vectorKey' => 'vector:manticoreMsgLastId',
-            'class' => ManticoreMsg::class,
-            'model' => WebSocketDialogMsg::class,
-            'idField' => 'id',
-        ],
-        'file' => [
-            'syncKey' => 'sync:manticoreFileLastId',
-            'vectorKey' => 'vector:manticoreFileLastId',
-            'class' => ManticoreFile::class,
-            'model' => File::class,
-            'idField' => 'id',
-        ],
-        'task' => [
-            'syncKey' => 'sync:manticoreTaskLastId',
-            'vectorKey' => 'vector:manticoreTaskLastId',
-            'class' => ManticoreTask::class,
-            'model' => ProjectTask::class,
-            'idField' => 'id',
-        ],
-        'project' => [
-            'syncKey' => 'sync:manticoreProjectLastId',
-            'vectorKey' => 'vector:manticoreProjectLastId',
-            'class' => ManticoreProject::class,
-            'model' => Project::class,
-            'idField' => 'id',
-        ],
-        'user' => [
-            'syncKey' => 'sync:manticoreUserLastId',
-            'vectorKey' => 'vector:manticoreUserLastId',
-            'class' => ManticoreUser::class,
-            'model' => User::class,
-            'idField' => 'userid',
-        ],
-    ];
-
-    public function handle(): int
-    {
-        if (!Apps::isInstalled("search")) {
-            $this->error("应用「Manticore Search」未安装");
-            return 1;
-        }
-
-        if (!Apps::isInstalled("ai")) {
-            $this->error("应用「AI」未安装，无法生成向量");
-            return 1;
-        }
-
-        $this->registerSignalHandlers();
-
-        if (!$this->acquireLock()) {
-            return 1;
-        }
-
-        $type = $this->option('type');
-        $batchSize = intval($this->option('batch'));
-        $sleepSeconds = intval($this->option('sleep'));
-        $reset = $this->option('reset');
-
-        if ($type === 'all') {
-            $types = array_keys(self::TYPE_CONFIG);
-        } else {
-            if (!isset(self::TYPE_CONFIG[$type])) {
-                $this->error("未知类型: {$type}。可用类型: msg, file, task, project, user, all");
-                $this->releaseLock();
-                return 1;
-            }
-            $types = [$type];
-        }
-
-        // 持续处理直到所有类型都没有待处理数据
-        $round = 0;
-        do {
-            $round++;
-            $totalPending = 0;
-
-            foreach ($types as $t) {
-                if ($this->shouldStop) {
-                    break;
-                }
-                $pending = $this->processType($t, $batchSize, $reset && $round === 1);
-                $totalPending += $pending;
-            }
-
-            // 如果还有待处理数据，休眠后继续
-            if ($totalPending > 0 && !$this->shouldStop) {
-                $this->info("\n--- 第 {$round} 轮完成，剩余 {$totalPending} 条待处理，{$sleepSeconds} 秒后继续 ---\n");
-                sleep($sleepSeconds);
-                $this->setLock(); // 刷新锁
-            }
-        } while ($totalPending > 0 && !$this->shouldStop);
-
-        $this->info("\n向量生成完成（共 {$round} 轮）");
-        $this->releaseLock();
-        return 0;
-    }
-
-    /**
-     * 处理单个类型的向量生成（每次处理一批）
-     *
-     * @param string $type 类型
-     * @param int $batchSize 每批数量
-     * @param bool $reset 是否重置进度
-     * @return int 剩余待处理数量
-     */
-    private function processType(string $type, int $batchSize, bool $reset): int
-    {
-        $config = self::TYPE_CONFIG[$type];
-
-        // 获取进度指针
-        $syncLastId = intval(ManticoreKeyValue::get($config['syncKey'], 0));
-        $vectorLastId = $reset ? 0 : intval(ManticoreKeyValue::get($config['vectorKey'], 0));
-
-        if ($reset) {
-            ManticoreKeyValue::set($config['vectorKey'], 0);
-            $this->info("[{$type}] 已重置向量进度指针");
-        }
-
-        // 计算待处理范围
-        $pendingCount = $syncLastId - $vectorLastId;
-        if ($pendingCount <= 0) {
-            return 0;
-        }
-
-        // 获取待处理的 ID 列表（每次处理 batchSize * 5 条，让 generateVectorsBatch 内部再分批调用 API）
-        $modelClass = $config['model'];
-        $idField = $config['idField'];
-        $fetchCount = $batchSize * 5;
-
-        $ids = $modelClass::where($idField, '>', $vectorLastId)
-            ->where($idField, '<=', $syncLastId)
-            ->orderBy($idField)
-            ->limit($fetchCount)
-            ->pluck($idField)
-            ->toArray();
-
-        if (empty($ids)) {
-            return 0;
-        }
-
-        // 批量生成向量
-        $manticoreClass = $config['class'];
-        $successCount = $manticoreClass::generateVectorsBatch($ids, $batchSize);
-
-        $currentLastId = end($ids);
-
-        // 更新向量进度指针
-        ManticoreKeyValue::set($config['vectorKey'], $currentLastId);
-
-        $remaining = $pendingCount - count($ids);
-        $this->info("[{$type}] 处理 " . count($ids) . " 条，成功 {$successCount}，ID: {$vectorLastId} -> {$currentLastId}，剩余 {$remaining}");
-
-        // 刷新锁
-        $this->setLock();
-
-        return max(0, $remaining);
-    }
-}

app/Console/Commands/OnlineLicenseRenew.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Module\OnlineLicense;
+use Illuminate\Console\Command;
+
+/**
+ * 在线授权续期（容器内独立进程按小时调用，无需 LARAVELS_TIMER、不经过 HTTP 转发）。
+ *
+ * 由 php 容器 supervisor 程序 [program:license] 循环调用：
+ *   while true; do php artisan online-license:renew; sleep 3600; done
+ */
+class OnlineLicenseRenew extends Command
+{
+    protected $signature = 'online-license:renew';
+    protected $description = '在线授权：本地状态机推进 + 租约将尽时自动续期';
+
+    public function handle(): int
+    {
+        if (!OnlineLicense::enabled()) {
+            return 0;
+        }
+        OnlineLicense::cron();
+        $status = OnlineLicense::status();
+        $this->info('online-license: ' . ($status['status'] ?? 'offline') . ' lease=' . ($status['lease_expired_at'] ?? '-'));
+        return 0;
+    }
+}

app/Console/Commands/Traits/ManticoreSyncLock.php

@@ -52,9 +52,18 @@ trait ManticoreSyncLock
     }
 
     /**
-     * 信号处理器（SIGINT/SIGTERM）
+     * 信号处理器（SIGINT/SIGTERM），签名须兼容 Symfony Console 的 Command::handleSignal
      */
-    public function handleSignal(int $signal): void
+    public function handleSignal(int $signal, int|false $previousExitCode = 0): int|false
+    {
+        $this->markShouldStop();
+        return false; // 继续执行，由批次循环优雅退出
+    }
+
+    /**
+     * 标记优雅退出（pcntl 回调第二参是 siginfo，不能直接复用 handleSignal）
+     */
+    private function markShouldStop(): void
     {
         $this->info("\n收到信号，将在当前批次完成后退出...");
         $this->shouldStop = true;
@@ -67,8 +76,8 @@ trait ManticoreSyncLock
     {
         if (extension_loaded('pcntl')) {
             pcntl_async_signals(true);
-            pcntl_signal(SIGINT, [$this, 'handleSignal']);
+            pcntl_signal(SIGINT, fn () => $this->markShouldStop());
-            pcntl_signal(SIGTERM, [$this, 'handleSignal']);
+            pcntl_signal(SIGTERM, fn () => $this->markShouldStop());
         }
     }
 

app/Console/Kernel.php

@@ -1,41 +0,0 @@
-<?php
-
-namespace App\Console;
-
-use Illuminate\Console\Scheduling\Schedule;
-use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
-
-class Kernel extends ConsoleKernel
-{
-    /**
-     * The Artisan commands provided by your application.
-     *
-     * @var array
-     */
-    protected $commands = [
-        //
-    ];
-
-    /**
-     * Define the application's command schedule.
-     *
-     * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
-     * @return void
-     */
-    protected function schedule(Schedule $schedule)
-    {
-        // $schedule->command('inspire')->hourly();
-    }
-
-    /**
-     * Register the commands for the application.
-     *
-     * @return void
-     */
-    protected function commands()
-    {
-        $this->load(__DIR__.'/Commands');
-
-        require base_path('routes/console.php');
-    }
-}

app/Exceptions/ImagePathHandler.php

@@ -4,94 +4,18 @@ namespace App\Exceptions;
 
 use App\Module\Base;
 use App\Module\Image;
-use Illuminate\Database\Eloquent\ModelNotFoundException;
-use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
-use Illuminate\Support\Facades\Log;
-use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
-use Throwable;
 
-class Handler extends ExceptionHandler
+/**
+ * 图片路径处理（原 Exceptions\Handler::ImagePathHandler，新结构下由 bootstrap/app.php
+ * 的 withExceptions 在 NotFoundHttpException 时调用）
+ */
+class ImagePathHandler
 {
     /**
-     * A list of the exception types that are not reported.
+     * @param \Illuminate\Http\Request $request
-     *
+     * @return \Symfony\Component\HttpFoundation\BinaryFileResponse|null 命中返回图片响应，未命中返回 null（继续默认 404）
-     * @var array
      */
-    protected $dontReport = [
+    public static function render($request)
-        //
-    ];
-
-    /**
-     * A list of the inputs that are never flashed for validation exceptions.
-     *
-     * @var array
-     */
-    protected $dontFlash = [
-        'current_password',
-        'password',
-        'password_confirmation',
-    ];
-
-    /**
-     * Register the exception handling callbacks for the application.
-     *
-     * @return void
-     */
-    public function register()
-    {
-        $this->reportable(function (Throwable $e) {
-            //
-        });
-    }
-
-    /**
-     * 将异常转换为 HTTP 响应。
-     * @param $request
-     * @param Throwable $e
-     * @return array|\Illuminate\Http\JsonResponse|\Illuminate\Http\Response|\Symfony\Component\HttpFoundation\Response
-     * @throws Throwable
-     */
-    public function render($request, Throwable $e)
-    {
-        if ($e instanceof NotFoundHttpException) {
-            if ($result = $this->ImagePathHandler($request)) {
-                return $result;
-            }
-        }
-        if ($e instanceof ApiException) {
-            return response()->json(Base::retError($e->getMessage(), $e->getData(), $e->getCode()));
-        } elseif ($e instanceof ModelNotFoundException) {
-            return response()->json(Base::retError('Interface error'));
-        }
-        return parent::render($request, $e);
-    }
-
-    /**
-     * 重写report优雅记录
-     * @param Throwable $e
-     * @throws Throwable
-     */
-    public function report(Throwable $e)
-    {
-        if ($e instanceof ApiException) {
-            if ($e->isWriteLog()) {
-                Log::error($e->getMessage(), [
-                    'code' => $e->getCode(),
-                    'data' => $e->getData(),
-                    'exception' => ' at ' . $e->getFile() . ':' . $e->getLine()
-                ]);
-            }
-        } else {
-            parent::report($e);
-        }
-    }
-
-    /**
-     * 图片路径处理
-     * @param $request
-     * @return \Illuminate\Http\JsonResponse|\Symfony\Component\HttpFoundation\BinaryFileResponse|null
-     */
-    private function ImagePathHandler($request)
     {
         $path = $request->path();
 

app/Http/Controllers/Api/AppsController.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Models\User;
+use App\Module\Badge;
+use App\Module\Base;
+use Request;
+
+/**
+ * 插件 / 微应用相关接口。
+ *
+ * 动态路由（routes/web.php）：
+ *   api/apps/badge/set     -> badge__set()    应用密钥鉴权，绝对设置/清除角标
+ *   api/apps/badge/clear   -> badge__clear()  当前用户 token 鉴权，清除自己的角标
+ *   api/apps/badge/list    -> badge__list()   当前用户 token 鉴权，拉取自己全部角标（初始同步）
+ */
+class AppsController extends AbstractController
+{
+    /**
+     * @api {post} api/apps/badge/set 设置角标（应用密钥鉴权）
+     *
+     * @apiDescription 由插件服务端使用 APP_SECRET 调用，对 (appid, 菜单, 每个 userid) 绝对设置角标（幂等覆盖）。
+     * @apiVersion 1.0.0
+     * @apiGroup apps
+     * @apiName badge__set
+     *
+     * @apiParam {String} appid     应用ID
+     * @apiParam {String} secret    应用密钥（APP_SECRET）
+     * @apiParam {Number|Number[]} userid   目标用户ID（单个或数组）
+     * @apiParam {String} [menu_key]    菜单稳定标识；留空表示该应用第一个菜单
+     * @apiParam {Number} [count=0]     角标数字
+     * @apiParam {Boolean} [dot=false]  是否显示红点（count=0 且 dot=false 即清除）
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息
+     * @apiSuccess {Object} data    返回数据
+     */
+    public function badge__set()
+    {
+        return Base::retSuccess('success', Badge::set(
+            trim(Request::input('appid', '')),
+            trim(Request::input('secret', '')),
+            Request::input('userid'),
+            trim(Request::input('menu_key', '')),
+            Request::input('count', 0),
+            Request::input('dot', false)
+        ));
+    }
+
+    /**
+     * @api {post} api/apps/badge/clear 清除角标（当前用户 token 鉴权）
+     *
+     * @apiDescription 供前端在 badge_clear_on_open=true 的菜单打开时调用，清除当前用户在该应用该菜单的角标。
+     * @apiVersion 1.0.0
+     * @apiGroup apps
+     * @apiName badge__clear
+     *
+     * @apiParam {String} appid         应用ID
+     * @apiParam {String} [menu_key]    菜单稳定标识；留空表示该应用第一个菜单
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息
+     * @apiSuccess {Object} data    返回数据
+     */
+    public function badge__clear()
+    {
+        $user = User::auth();
+        return Base::retSuccess('success', Badge::clearForUser(
+            (int)$user->userid,
+            trim(Request::input('appid', '')),
+            trim(Request::input('menu_key', ''))
+        ));
+    }
+
+    /**
+     * @api {get} api/apps/badge/list 拉取自己全部角标
+     *
+     * @apiDescription 供前端初始同步：返回当前用户全部应用（插件 + 自定义微应用）的角标快照。
+     *  数据结构 app_id => menu_key => {count, dot}，与前端 store 的 map 结构一致。
+     * @apiVersion 1.0.0
+     * @apiGroup apps
+     * @apiName badge__list
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息
+     * @apiSuccess {Object} data    返回数据
+     */
+    public function badge__list()
+    {
+        $user = User::auth();
+        return Base::retSuccess('success', Badge::userBadges((int)$user->userid));
+    }
+}

app/Http/Controllers/Api/AssistantController.php

@@ -2,11 +2,17 @@
 
 namespace App\Http\Controllers\Api;
 
+use App\Models\AiAssistantFeedback;
+use App\Models\AiAssistantSearchLog;
 use App\Models\AiAssistantSession;
 use App\Models\User;
+use App\Models\WebSocket;
 use App\Module\AI;
 use App\Module\Apps;
 use App\Module\Base;
+use App\Tasks\PushTask;
+use Cache;
+use Illuminate\Support\Str;
 use Request;
 
 /**
@@ -32,6 +38,8 @@ class AssistantController extends AbstractController
      * @apiParam {String} model_type  模型类型
      * @apiParam {String} model_name  模型名称
      * @apiParam {JSON} context       上下文数组
+     * @apiParam {String} [locale]    ai-kb 检索语种：zh、en（缺省取请求语言 language，包含 zh 视为 zh，否则 en）
+     * @apiParam {String} [session_id] 前端会话ID（透传给 AI 服务作 context_key，用于检索打点关联）
      *
      * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
      * @apiSuccess {String} msg     返回信息（错误描述）
@@ -46,8 +54,21 @@ class AssistantController extends AbstractController
         $modelType = trim(Request::input('model_type', ''));
         $modelName = trim(Request::input('model_name', ''));
         $contextInput = Request::input('context', []);
+        $locale = trim(Request::input('locale', '')) ?: trim(Base::headerOrInput('language'));
+        $locale = str_contains(strtolower($locale), 'zh') ? 'zh' : 'en';
+        $contextKey = mb_substr(trim(Request::input('session_id', '')), 0, 100);
 
-        return AI::createStreamKey($modelType, $modelName, $contextInput);
+        // 当前用户 WebSocket fd：供 AI 经 doo page 操作本人浏览器（页面操作用）。
+        // 复用 operation__dispatch 同款归属校验：在表即在线、归属即本人，否则置 0。
+        $fd = intval(Base::headerOrInput('fd'));
+        if ($fd > 0 && intval(WebSocket::whereFd($fd)->value('userid')) !== intval($user->userid)) {
+            $fd = 0;
+        }
+
+        // 灰度判定（参考 config/ai.php）：总开关 + canary 白名单
+        $ragEnabled = AI::ragEnabledFor((int) $user->userid);
+
+        return AI::createStreamKey($modelType, $modelName, $contextInput, $locale, $ragEnabled, $contextKey, $fd);
     }
 
     /**
@@ -157,6 +178,247 @@ class AssistantController extends AbstractController
         return $dotProduct / $denominator;
     }
 
+    /**
+     * @api {post} api/assistant/log/search 记录帮助知识库检索日志
+     *
+     * @apiDescription 需要token身份（AI 插件透传用户 token 服务端回调）。记录一次 search_help_docs 检索，用于分析检索质量、反哺 ai-kb 内容迭代
+     * @apiVersion 1.0.0
+     * @apiGroup assistant
+     * @apiName log__search
+     *
+     * @apiParam {String} query          检索query
+     * @apiParam {String} [locale]       语种 zh|en
+     * @apiParam {String} [source]       来源 chat|invoke
+     * @apiParam {String} [context_key]  上下文标识
+     * @apiParam {Number} [dialog_id]    对话ID
+     * @apiParam {Array}  [source_ids]   命中source id列表
+     * @apiParam {Number} [top_score]    最高相似度
+     * @apiParam {Number} [result_count] 命中数量
+     * @apiParam {Number} [duration_ms]  检索耗时毫秒
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息（错误描述）
+     */
+    public function log__search()
+    {
+        $user = User::auth();
+
+        $query = mb_substr(trim(Request::input('query', '')), 0, 500);
+        $locale = trim(Request::input('locale', ''));
+        $source = trim(Request::input('source', ''));
+        $contextKey = mb_substr(trim(Request::input('context_key', '')), 0, 191);
+        $dialogId = intval(Request::input('dialog_id', 0));
+        $sourceIds = Request::input('source_ids', []);
+        $topScore = floatval(Request::input('top_score', 0));
+        $resultCount = intval(Request::input('result_count', 0));
+        $durationMs = intval(Request::input('duration_ms', 0));
+
+        if ($query === '') {
+            return Base::retError('参数错误');
+        }
+        if (!in_array($source, ['chat', 'invoke'])) {
+            $source = '';
+        }
+        if (!is_array($sourceIds)) {
+            $sourceIds = [];
+        }
+
+        $log = AiAssistantSearchLog::createInstance([
+            'userid' => $user->userid,
+            'dialog_id' => max(0, $dialogId),
+            'context_key' => $contextKey,
+            'source' => $source,
+            'query' => $query,
+            'locale' => in_array($locale, ['zh', 'en']) ? $locale : '',
+            'source_ids' => Base::array2json(array_slice(array_values($sourceIds), 0, 10)),
+            'top_score' => max(0, min(1, $topScore)),
+            'result_count' => max(0, $resultCount),
+            'duration_ms' => max(0, $durationMs),
+            'empty' => $resultCount > 0 ? 0 : 1,
+        ]);
+        $log->save();
+
+        return Base::retSuccess('success');
+    }
+
+    /**
+     * @api {post} api/assistant/feedback/save 保存回复反馈
+     *
+     * @apiDescription 需要token身份。保存用户对一条 AI 回复的 👍/👎 反馈，同一条回复可改票（覆盖更新）；传空 feedback 表示取消反馈（删除记录）
+     * @apiVersion 1.0.0
+     * @apiGroup assistant
+     * @apiName feedback__save
+     *
+     * @apiParam {String} session_key   场景分类key
+     * @apiParam {String} session_id    前端会话ID
+     * @apiParam {Number} local_id      回复条目localId
+     * @apiParam {String} feedback      like|dislike，空字符串表示取消反馈
+     * @apiParam {String} [prompt]      用户问题
+     * @apiParam {String} [answer]      回复摘录
+     * @apiParam {Array}  [source_ids]  回复引用的kb source id列表
+     * @apiParam {String} [model]       模型名
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息（错误描述）
+     * @apiSuccess {Object} data    返回数据
+     * @apiSuccess {String} data.feedback 已保存的反馈值
+     */
+    public function feedback__save()
+    {
+        $user = User::auth();
+
+        $sessionKey = mb_substr(trim(Request::input('session_key', 'default')), 0, 100);
+        $sessionId = mb_substr(trim(Request::input('session_id', '')), 0, 100);
+        $localId = intval(Request::input('local_id', 0));
+        $feedback = trim(Request::input('feedback', ''));
+        $prompt = mb_substr(trim(Request::input('prompt', '')), 0, 1000);
+        $answer = mb_substr(trim(Request::input('answer', '')), 0, 2000);
+        $sourceIds = Request::input('source_ids', []);
+        $model = mb_substr(trim(Request::input('model', '')), 0, 100);
+
+        if (empty($sessionId) || $localId <= 0) {
+            return Base::retError('参数错误');
+        }
+        if (!in_array($feedback, ['', 'like', 'dislike'])) {
+            return Base::retError('反馈类型错误');
+        }
+        if (!is_array($sourceIds)) {
+            $sourceIds = [];
+        }
+
+        $exist = AiAssistantFeedback::where('userid', $user->userid)
+            ->where('session_key', $sessionKey)
+            ->where('session_id', $sessionId)
+            ->where('local_id', $localId)
+            ->first();
+
+        // 空反馈表示取消：删除已有记录
+        if ($feedback === '') {
+            $exist?->delete();
+            return Base::retSuccess('success', [
+                'feedback' => '',
+            ]);
+        }
+
+        $row = AiAssistantFeedback::createInstance([
+            'userid' => $user->userid,
+            'session_key' => $sessionKey,
+            'session_id' => $sessionId,
+            'local_id' => $localId,
+            'feedback' => $feedback,
+            'prompt' => $prompt,
+            'answer' => $answer,
+            'answer_digest' => md5($answer),
+            'source_ids' => Base::array2json(array_slice(array_values($sourceIds), 0, 10)),
+            'model' => $model,
+        ], $exist?->id);
+        $row->save();
+
+        return Base::retSuccess('success', [
+            'feedback' => $feedback,
+        ]);
+    }
+
+    /**
+     * @api {post} api/assistant/operation/dispatch 派发页面操作
+     *
+     * @apiDescription 需要token身份。通过用户常驻 WebSocket（/ws）向其浏览器派发一次页面操作（获取页面上下文 / 执行动作 / 操作元素），由前端 AI 助手执行后经 operationResult 回传，结果写入缓存供 operation/result 轮询取走。复用主程序 /ws，无需为页面操作另开 WebSocket。
+     * @apiVersion 1.0.0
+     * @apiGroup assistant
+     * @apiName operation__dispatch
+     *
+     * @apiParam {Number} fd        目标会话 fd（须为当前用户在线的 WebSocket 连接）
+     * @apiParam {String} action    操作类型，如 get_page_context|execute_action|execute_element_action
+     * @apiParam {Object} [payload] 操作参数
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息（错误描述）
+     * @apiSuccess {Object} data    返回数据
+     * @apiSuccess {String} data.requestId 本次操作的请求ID，用于轮询 operation/result
+     */
+    public function operation__dispatch()
+    {
+        $user = User::auth();
+
+        $fd = intval(Base::headerOrInput('fd'));
+        $action = trim(Request::input('action', ''));
+        $payload = Request::input('payload', []);
+
+        if ($fd <= 0 || $action === '') {
+            return Base::retError('参数错误');
+        }
+        if (!is_array($payload)) {
+            $payload = [];
+        }
+
+        // fd 归属校验：在表即在线，归属即本人
+        $ownerId = WebSocket::whereFd($fd)->value('userid');
+        if (intval($ownerId) !== intval($user->userid)) {
+            return Base::retError('会话不存在或无权限');
+        }
+
+        $requestId = Str::random(24);
+
+        // 精确推送到该 fd，不补发离线消息
+        PushTask::push([
+            'fd' => $fd,
+            'msg' => [
+                'type' => 'operation',
+                'data' => [
+                    'requestId' => $requestId,
+                    'action' => $action,
+                    'payload' => $payload,
+                ],
+            ],
+        ], false);
+
+        return Base::retSuccess('success', [
+            'requestId' => $requestId,
+        ]);
+    }
+
+    /**
+     * @api {get} api/assistant/operation/result 取页面操作结果
+     *
+     * @apiDescription 需要token身份。轮询取走 operation/dispatch 派发的一次页面操作结果（取走即删）；未回传时返回 status=pending。
+     * @apiVersion 1.0.0
+     * @apiGroup assistant
+     * @apiName operation__result
+     *
+     * @apiParam {String} request_id 操作请求ID
+     *
+     * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
+     * @apiSuccess {String} msg     返回信息（错误描述）
+     * @apiSuccess {Object} data    返回数据
+     * @apiSuccess {String} data.status ready|pending
+     */
+    public function operation__result()
+    {
+        $user = User::auth();
+
+        $requestId = trim(Base::headerOrInput('request_id'));
+        if ($requestId === '') {
+            return Base::retError('参数错误');
+        }
+
+        $row = Cache::get("ai_op_result:{$requestId}");
+        if (!is_array($row)) {
+            return Base::retSuccess('success', ['status' => 'pending']);
+        }
+        // 命中后校验归属再取走，避免越权读取他人结果
+        if (intval($row['userid']) !== intval($user->userid)) {
+            return Base::retError('无权限');
+        }
+        Cache::forget("ai_op_result:{$requestId}");
+
+        return Base::retSuccess('success', [
+            'status' => 'ready',
+            'success' => !empty($row['success']),
+            'result' => $row['result'] ?? null,
+            'error' => $row['error'] ?? null,
+        ]);
+    }
+
     /**
      * 获取会话列表
      */

app/Http/Controllers/Api/DashboardController.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Models\User;
+use App\Module\Base;
+use App\Module\DashboardTeam;
+use Request;
+
+/**
+ * @apiDefine dashboard
+ *
+ * 仪表盘
+ */
+class DashboardController extends AbstractController
+{
+    /**
+     * @api {get} api/dashboard/team/stats 负责人视角统计
+     *
+     * @apiDescription 需要token身份。返回所选管理部门（含下级部门）的团队任务统计。
+     * @apiVersion 1.0.0
+     * @apiGroup dashboard
+     * @apiName team__stats
+     *
+     * @apiParam {String} [department_owner_ids] 所选管理部门ID，逗号分隔；不传表示全部
+     * @apiParam {Number} [refresh] 传 1 时主动刷新当前统计缓存
+     *
+     * @apiSuccess {Number} ret  返回状态码
+     * @apiSuccess {String} msg  返回信息
+     * @apiSuccess {Object} data 团队统计数据
+     */
+    public function team__stats()
+    {
+        $user = User::auth();
+        $context = DashboardTeam::context($user, Request::input('department_owner_ids'));
+        return Base::retSuccess('success', DashboardTeam::stats($context, intval(Request::input('refresh')) === 1));
+    }
+
+    /**
+     * @api {get} api/dashboard/team/tasks 负责人视角任务列表
+     *
+     * @apiDescription 需要token身份。按关注类型、成员或优先级分页返回团队任务。
+     * @apiVersion 1.0.0
+     * @apiGroup dashboard
+     * @apiName team__tasks
+     *
+     * @apiParam {String} [department_owner_ids] 所选管理部门ID，逗号分隔；不传表示全部
+     * @apiParam {String} [type] 任务类型：uncompleted/overdue/soon/hi/noowner
+     * @apiParam {Number} [member_id] 成员ID；传入后优先于 type
+     * @apiParam {Number} [level] 优先级；-1 表示未设置，传入后优先于 type
+     * @apiParam {Number} [page] 当前页
+     * @apiParam {Number} [pagesize] 每页数量，默认20，最大50
+     *
+     * @apiSuccess {Number} ret  返回状态码
+     * @apiSuccess {String} msg  返回信息
+     * @apiSuccess {Object} data 分页任务数据
+     */
+    public function team__tasks()
+    {
+        $user = User::auth();
+        $context = DashboardTeam::context($user, Request::input('department_owner_ids'));
+
+        $memberId = intval(Request::input('member_id'));
+        $levelValue = Request::input('level');
+        $level = $levelValue !== null && $levelValue !== '' ? intval($levelValue) : null;
+        $type = trim((string)Request::input('type'));
+
+        if ($memberId > 0) {
+            if (!in_array($memberId, $context['member_userids'], true)) {
+                return Base::retError('参数错误');
+            }
+        } elseif ($level !== null) {
+            if ($level !== -1 && !in_array($level, DashboardTeam::priorityLevels(), true)) {
+                return Base::retError('参数错误');
+            }
+        } elseif (!in_array($type, ['uncompleted', 'overdue', 'soon', 'hi', 'noowner'], true)) {
+            return Base::retError('参数错误');
+        }
+
+        return Base::retSuccess('success', DashboardTeam::tasks($context, [
+            'type' => $type,
+            'member_id' => $memberId,
+            'level' => $level,
+        ]));
+    }
+}

app/Http/Controllers/Api/DialogController.php

@@ -1257,6 +1257,51 @@ class DialogController extends AbstractController
         return $result;
     }
 
+    /**
+     * @api {post} api/dialog/msg/sendapprove 发送审批通知卡片
+     *
+     * @apiDescription 需要token身份。以「审批助手」机器人身份向指定用户发送审批模板卡片
+     * （由 approve 插件调用，卡片仅展示、不与旧审批系统有数据关联）。
+     * @apiVersion 1.0.0
+     * @apiGroup dialog
+     * @apiName msg__sendapprove
+     *
+     * @apiParam {Number} to_userid     接收用户ID
+     * @apiParam {String} type          卡片类型：approve_reviewer / approve_notifier / approve_submitter / approve_comment_notifier
+     * @apiParam {String} [action]      动作：start / pass / refuse / withdraw（按类型取用）
+     * @apiParam {Number} [is_finished] 是否已结束（0/1）
+     * @apiParam {Object} data          卡片数据
+     * @apiParam {String} [title]       消息标题（会话列表预览用）
+     */
+    public function msg__sendapprove()
+    {
+        $user = User::auth();
+        $toUserid = intval(Request::input('to_userid'));
+        $type = trim(Request::input('type'));
+        $action = trim(Request::input('action'));
+        $isFinished = intval(Request::input('is_finished'));
+        $data = Base::json2array(Request::input('data'));
+        $title = trim(Request::input('title'));
+        //
+        $allow = ['approve_reviewer', 'approve_notifier', 'approve_submitter', 'approve_comment_notifier'];
+        if ($toUserid <= 0 || !in_array($type, $allow)) {
+            return Base::retError('参数错误');
+        }
+        $botUser = User::botGetOrCreate('approval-alert');
+        $dialog = WebSocketDialog::checkUserDialog($botUser, $toUserid);
+        if (empty($dialog)) {
+            return Base::retError('无法创建对话');
+        }
+        $msgData = [
+            'type' => $type,
+            'action' => $action ?: null,
+            'is_finished' => $isFinished,
+            'data' => $data,
+            'title' => $title,
+        ];
+        return WebSocketDialogMsg::sendMsg(null, $dialog->id, 'template', $msgData, $botUser->userid, false, false, true);
+    }
+
     /**
      * @api {post} api/dialog/msg/sendrecord 发送语音
      *
@@ -2125,6 +2170,9 @@ class DialogController extends AbstractController
         $msg_id = intval(Request::input("msg_id"));
         $force = intval(Request::input("force"));
         $language = Base::inputOrHeader('language');
+        if (empty($language)) {
+            return Base::retError("参数错误");
+        }
         $targetLanguage = Doo::getLanguages($language);
         //
         if (empty($targetLanguage)) {
@@ -3042,7 +3090,7 @@ class DialogController extends AbstractController
      */
     public function group__transfer()
     {
-        if (!Base::is_internal_ip(Base::getIp()) || Request::input("key") !== env('APP_KEY')) {
+        if (!Base::is_internal_ip(Base::getIp()) || Request::input("key") !== config('app.key')) {
             $user = User::auth();
         }
         //
@@ -3352,7 +3400,7 @@ class DialogController extends AbstractController
      */
     public function okr__push()
     {
-        if (!Base::is_internal_ip(Base::getIp()) || Request::input("key") !== env('APP_KEY')) {
+        if (!Base::is_internal_ip(Base::getIp()) || Request::input("key") !== config('app.key')) {
             User::auth();
         }
         $text = trim(Request::input('text'));

app/Http/Controllers/Api/FileController.php

@@ -41,6 +41,7 @@ class FileController extends AbstractController
      * @apiName lists
      *
      * @apiParam {Number} [pid]         父级ID
+     * @apiParam {String} [scope]       板块范围（根目录生效）：mine=我的文件、shared=共享文件、all=全部（默认）
      *
      * @apiSuccess {Number} ret     返回状态码（1正确、0错误）
      * @apiSuccess {String} msg     返回信息（错误描述）
@@ -51,8 +52,12 @@ class FileController extends AbstractController
         $user = User::auth();
         //
         $pid = intval(Request::input('pid'));
+        $scope = Request::input('scope', 'all');
+        if (!in_array($scope, ['mine', 'shared', 'all'])) {
+            $scope = 'all';
+        }
         //
-        return Base::retSuccess('success', (new File)->getFileList($user, $pid));
+        return Base::retSuccess('success', (new File)->getFileList($user, $pid, 'all', true, $scope));
     }
 
     /**
@@ -737,7 +742,10 @@ class FileController extends AbstractController
         File::isNeedInstallApp('office');
         //
         $config = Request::input('config');
-        $token = \Firebase\JWT\JWT::encode($config, env('APP_KEY') ,'HS256');
+        if (!is_array($config)) {
+            return Base::retError('参数错误');
+        }
+        $token = \Firebase\JWT\JWT::encode($config, config('app.key') ,'HS256');
         return Base::retSuccess('成功', [
             'token' => $token
         ]);

app/Http/Controllers/Api/LicenseController.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Models\User;
+use App\Module\Base;
+use App\Module\OnlineLicense;
+use Request;
+
+/**
+ * 在线授权客户端（与 SystemController::license 的离线粘贴并存）。
+ *
+ * 动态路由（routes/web.php）：
+ *   api/license/email/send   -> email__send()
+ *   api/license/login        -> login()
+ *   api/license/login/confirm -> login__confirm()
+ *   api/license/trial        -> trial()
+ *   api/license/status       -> status()
+ *   api/license/refresh      -> refresh()
+ *   api/license/logout       -> logout()
+ */
+class LicenseController extends AbstractController
+{
+    /**
+     * 发送邮箱验证码（登录与试用共用）
+     */
+    public function email__send()
+    {
+        User::auth('admin');
+        $email = trim(Request::input('email'));
+        if ($email === '') {
+            return Base::retError('请输入邮箱');
+        }
+        $masked = OnlineLicense::emailSend($email);
+        return Base::retSuccess('验证码已发送', ['email' => $masked]);
+    }
+
+    /**
+     * 邮箱 + 验证码登录并签发在线授权
+     */
+    public function login()
+    {
+        User::auth('admin');
+        $email = trim(Request::input('email'));
+        $code = trim(Request::input('code'));
+        if ($email === '' || $code === '') {
+            return Base::retError('请输入邮箱和验证码');
+        }
+        $data = OnlineLicense::login($email, $code);
+        return Base::retSuccess('授权成功', $data);
+    }
+
+    /**
+     * 多条可用授权时，用户选定后确认签发（复用验证码）
+     */
+    public function login__confirm()
+    {
+        User::auth('admin');
+        $email = trim(Request::input('email'));
+        $code = trim(Request::input('code'));
+        $entitlementId = (int)Request::input('entitlement_id');
+        if ($email === '' || $code === '') {
+            return Base::retError('请输入邮箱和验证码');
+        }
+        if ($entitlementId <= 0) {
+            return Base::retError('请选择要使用的授权');
+        }
+        $data = OnlineLicense::loginConfirm($email, $code, $entitlementId);
+        return Base::retSuccess('授权成功', $data);
+    }
+
+    /**
+     * 邮箱 + 验证码申请试用并签发
+     */
+    public function trial()
+    {
+        User::auth('admin');
+        $email = trim(Request::input('email'));
+        $code = trim(Request::input('code'));
+        if ($email === '' || $code === '') {
+            return Base::retError('请输入邮箱和验证码');
+        }
+        $data = OnlineLicense::trial($email, $code);
+        return Base::retSuccess('试用已开通', $data);
+    }
+
+    /**
+     * 当前在线授权状态
+     */
+    public function status()
+    {
+        User::auth('admin');
+        return Base::retSuccess('success', OnlineLicense::status());
+    }
+
+    /**
+     * 进入授权页时的静默刷新：服务可达则更新授权数据，网络失败则不更新、不提示。
+     */
+    public function refresh()
+    {
+        User::auth('admin');
+        OnlineLicense::refresh();
+        return Base::retSuccess('success', OnlineLicense::status());
+    }
+
+    /**
+     * 退出在线授权（释放座位 + 回落默认）
+     */
+    public function logout()
+    {
+        User::auth('admin');
+        OnlineLicense::logout();
+        return Base::retSuccess('已退出在线授权');
+    }
+}

app/Http/Controllers/Api/ProjectController.php

@@ -5,7 +5,6 @@ namespace App\Http\Controllers\Api;
 use Request;
 use Redirect;
 use Response;
-use Madzipper;
 use Carbon\Carbon;
 use App\Module\Down;
 use App\Module\Doo;
@@ -2003,7 +2002,7 @@ class ProjectController extends AbstractController
                 Base::deleteDirAndFile($zipPath, true);
             }
             try {
-                Madzipper::make($zipPath)->add($xlsPath)->close();
+                Base::zipAddFiles($zipPath, $xlsPath);
             } catch (\Throwable) {
             }
             //
@@ -2171,7 +2170,7 @@ class ProjectController extends AbstractController
                 Base::deleteDirAndFile($zipPath, true);
             }
             try {
-                Madzipper::make($zipPath)->add($xlsPath)->close();
+                Base::zipAddFiles($zipPath, $xlsPath);
             } catch (\Throwable) {
             }
             //
@@ -2272,9 +2271,12 @@ class ProjectController extends AbstractController
         }
         //
         $data = $task->toArray();
-        $data['department_readonly'] = UserDepartment::isDepartmentReadonlyProject($departmentView, intval($task->project_id));
+        $taskProject = Project::withTrashed()->find($task->project_id);
-        $data['project_name'] = $task->project?->name;
+        $data['project_name'] = $taskProject?->name;
+        $data['project_deleted'] = (!$taskProject || $taskProject->trashed()) ? 1 : 0;
+        $data['project_archived'] = $taskProject?->archived_at ? 1 : 0;
         $data['column_name'] = $task->projectColumn?->name;
+        $data['department_readonly'] = UserDepartment::isDepartmentReadonlyProject($departmentView, intval($task->project_id));
         $data['visibility_appointor'] = $task->visibility == 1 ? [0] : ProjectTaskVisibilityUser::whereTaskId($task_id)->pluck('userid');
         return Base::retSuccess('success', $data);
     }
@@ -3206,8 +3208,27 @@ class ProjectController extends AbstractController
         //
         $task = ProjectTask::userTask($task_id, null, $type !== 'recovery');
         //
+        try {
             $project = Project::userProject($task->project_id);
             ProjectPermission::userTaskPermission($project, ProjectPermission::TASK_REMOVE, $task);
+        } catch (\Throwable $e) {
+            if ($type == 'recovery') {
+                throw $e;
+            }
+            // 项目已删除/已归档时放行删除操作（限：管理员、原项目负责人、任务负责人/协助人/创建人）
+            $project = Project::withTrashed()->find($task->project_id);
+            $projectInvalid = !$project || $project->trashed() || $project->archived_at;
+            if (!$projectInvalid) {
+                throw $e;
+            }
+            $isProjectOwner = ProjectUser::whereProjectId($task->project_id)
+                ->whereUserid(Doo::userId())
+                ->whereIn('owner', [ProjectUser::OWNER_PRIMARY, ProjectUser::OWNER_DEPUTY])
+                ->exists();
+            if (!$isProjectOwner && !$task->permission(3)) {
+                throw new ApiException('仅项目负责人或任务相关成员删除');
+            }
+        }
         //
         if ($type == 'recovery') {
             $task->restoreTask();

app/Http/Controllers/Api/SystemController.php

@@ -9,21 +9,22 @@ use App\Module\AI;
 use App\Module\Down;
 use Request;
 use Response;
-use Madzipper;
 use Carbon\Carbon;
 use App\Module\Doo;
 use App\Models\User;
 use App\Module\Base;
+use App\Module\OnlineLicense;
 use App\Module\Timer;
 use App\Models\Setting;
 use LdapRecord\Container;
 use App\Module\BillExport;
-use Guanguans\Notify\Factory;
+use Symfony\Component\Mailer\Mailer;
+use Symfony\Component\Mailer\Transport;
+use Symfony\Component\Mime\Email;
 use App\Models\UserCheckinRecord;
 use App\Module\Apps;
 use App\Module\BillMultipleExport;
 use LdapRecord\LdapRecordException;
-use Guanguans\Notify\Messages\EmailMessage;
 use Swoole\Coroutine;
 
 /**
@@ -54,7 +55,7 @@ class SystemController extends AbstractController
     {
         $type = trim(Request::input('type'));
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             Base::checkClientVersion('0.41.11');
@@ -110,7 +111,7 @@ class SystemController extends AbstractController
                     return Base::retError('自动归档时间不可大于100天！');
                 }
             }
-            if ($all['system_alias'] == env('APP_NAME')) {
+            if ($all['system_alias'] == config('app.name')) {
                 $all['system_alias'] = '';
             }
             if ($all['system_welcome'] == '欢迎您，{username}') {
@@ -153,7 +154,7 @@ class SystemController extends AbstractController
         $setting['unclaimed_task_reminder'] = $setting['unclaimed_task_reminder'] ?: 'close';
         $setting['unclaimed_task_reminder_time'] = $setting['unclaimed_task_reminder_time'] ?: '';
         $setting['task_ai_auto_analyze'] = $setting['task_ai_auto_analyze'] ?: 'open';
-        $setting['department_owner_project_view'] = $setting['department_owner_project_view'] ?: 'close';
+        $setting['department_owner_project_view'] = $setting['department_owner_project_view'] ?: 'open';
         $setting['server_timezone'] = config('app.timezone');
         $setting['server_version'] = Base::getVersion();
         // 指定人员名单仅管理员可见
@@ -184,7 +185,7 @@ class SystemController extends AbstractController
         //
         $type = trim(Request::input('type'));
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             $user->identity('admin');
@@ -254,7 +255,7 @@ class SystemController extends AbstractController
         //
         $type = trim(Request::input('type'));
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             $all = Request::input();
@@ -278,7 +279,7 @@ class SystemController extends AbstractController
         }
         //
         $setting['open'] = $setting['open'] ?: 'close';
-        if (env("SYSTEM_SETTING") == 'disabled') {
+        if (config('dootask.system_setting') == 'disabled') {
             $setting['appid'] = substr($setting['appid'], 0, 4) . str_repeat('*', strlen($setting['appid']) - 8) . substr($setting['appid'], -4);
             $setting['app_certificate'] = substr($setting['app_certificate'], 0, 4) . str_repeat('*', strlen($setting['app_certificate']) - 8) . substr($setting['app_certificate'], -4);
             $setting['api_key'] = substr($setting['api_key'], 0, 4) . str_repeat('*', strlen($setting['api_key']) - 8) . substr($setting['api_key'], -4);
@@ -324,7 +325,7 @@ class SystemController extends AbstractController
         $filter = trim(Request::input('filter'));
         $setting = Base::setting('aibotSetting');
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             Base::checkClientVersion('0.41.11');
@@ -342,11 +343,15 @@ class SystemController extends AbstractController
             }, ARRAY_FILTER_USE_BOTH);
         }
         //
-        if (env("SYSTEM_SETTING") == 'disabled') {
+        if (config('dootask.system_setting') == 'disabled') {
             foreach ($setting as $key => $item) {
                 if (empty($item)) {
                     continue;
                 }
+                // dooai_key 是官方网关 token，需原样返回供鉴权
+                if ($key === 'dooai_key') {
+                    continue;
+                }
                 if (str_ends_with($key, '_key') || str_ends_with($key, '_secret')) {
                     $setting[$key] = substr($item, 0, 4) . str_repeat('*', strlen($item) - 8) . substr($item, -4);
                 }
@@ -396,7 +401,7 @@ class SystemController extends AbstractController
         //
         $type = trim(Request::input('type'));
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             $all = Request::input();
@@ -545,7 +550,7 @@ class SystemController extends AbstractController
         //
         $type = trim(Request::input('type'));
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             $all = Request::input();
@@ -610,7 +615,7 @@ class SystemController extends AbstractController
                 return Base::retError($e->getMessage() ?: "验证失败：未知错误", config("ldap.connections.default"));
             }
         } elseif ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             $all = Base::newTrim(Request::input());
@@ -662,7 +667,7 @@ class SystemController extends AbstractController
         //
         $type = trim(Request::input('type'));
         if ($type == 'save') {
-            if (env("SYSTEM_SETTING") == 'disabled') {
+            if (config('dootask.system_setting') == 'disabled') {
                 return Base::retError('当前环境禁止修改');
             }
             $all = Base::newTrim(Request::input());
@@ -695,8 +700,8 @@ class SystemController extends AbstractController
      */
     public function demo()
     {
-        $demo_account = env('DEMO_ACCOUNT');
+        $demo_account = config('dootask.demo_account');
-        $demo_password = env('DEMO_PASSWORD');
+        $demo_password = config('dootask.demo_password');
         if (empty($demo_account) || empty($demo_password)) {
             return Base::retError('No demo account');
         }
@@ -773,14 +778,14 @@ class SystemController extends AbstractController
             }
             $apps = Setting::normalizeCustomMicroApps($list);
             $setting = Base::setting('microapp_menu', $apps);
-            $setting = Setting::formatCustomMicroAppsForResponse($setting);
+            $setting = Setting::formatCustomMicroAppsForResponse($setting, true);
         } else {
             $setting = Base::setting('microapp_menu');
             if (!is_array($setting)) {
                 $setting = [];
             }
             $setting = Setting::filterCustomMicroAppsForUser($setting, $user);
-            $setting = Setting::formatCustomMicroAppsForResponse($setting);
+            $setting = Setting::formatCustomMicroAppsForResponse($setting, $user && $user->isAdmin());
         }
         return Base::retSuccess($type == 'save' ? '保存成功' : 'success', $setting);
     }
@@ -856,7 +861,17 @@ class SystemController extends AbstractController
         $type = trim(Request::input('type'));
         if ($type == 'save') {
             $license = Request::input('license');
+            // 解密失败（sn 为空）视为无效 license
+            $decoded = Doo::licenseDecode($license);
+            if ((string)($decoded['sn'] ?? '') === '') {
+                return Base::retError('LICENSE 格式错误');
+            }
+            if ($err = Doo::licenseBindingError($decoded)) {
+                return Base::retError($err);
+            }
             Doo::licenseSave($license);
+            // 离线/在线互斥：保存离线 license 即退出在线模式（尽力释放座位+清在线标志，不删除刚写入的文件）
+            OnlineLicense::switchToOffline();
         }
         //
         $data = [
@@ -868,8 +883,8 @@ class SystemController extends AbstractController
             'user_count' => User::whereBot(0)->whereNull('disable_at')->count(),
             'error' => []
         ];
-        if ($data['info']['people'] > 3) {
+        if ($data['info']['people'] == 0 || $data['info']['people'] > 3) {
-            // 小于3人的License不检查
+            // 付费档才检查 SN/MAC
             if ($data['info']['sn'] != $data['doo_sn']) {
                 $data['error'][] = '终端SN与License不匹配';
             }
@@ -892,6 +907,11 @@ class SystemController extends AbstractController
         if ($data['info']['expired_at'] && strtotime($data['info']['expired_at']) <= Timer::time()) {
             $data['error'][] = '终端License已过期';
         }
+        // 在线授权：把状态机提醒并入 error[]（dashboard 警告条与本页错误展示自动复用），并附在线状态
+        foreach (OnlineLicense::stageMessages() as $msg) {
+            $data['error'][] = $msg;
+        }
+        $data['online'] = OnlineLicense::status();
         //
         if ($type === 'error') {
             $data = [
@@ -917,7 +937,7 @@ class SystemController extends AbstractController
      */
     public function get__info()
     {
-        if (Request::input("key") !== env('APP_KEY')) {
+        if (Request::input("key") !== config('app.key')) {
             return [];
         }
         return Base::retSuccess('success', [
@@ -1233,21 +1253,19 @@ class SystemController extends AbstractController
         }
         try {
             Setting::validateAddr($all['to'], function($to) use ($all) {
-                Factory::mailer()
+                $mailer = new Mailer(Transport::fromDsn("smtp://{$all['account']}:{$all['password']}@{$all['smtp_server']}:{$all['port']}?verify_peer=0"));
-                    ->setDsn("smtp://{$all['account']}:{$all['password']}@{$all['smtp_server']}:{$all['port']}?verify_peer=0")
+                $mailer->send((new Email())
-                    ->setMessage(EmailMessage::create()
                     ->from(Base::settingFind('system', 'system_alias', 'Task') . " <{$all['account']}>")
                     ->to($to)
                     ->subject('Mail sending test')
-                        ->html('<p>' . Doo::translate('收到此电子邮件意味着您的邮箱配置正确。') . '</p>'))
+                    ->html('<p>' . Doo::translate('收到此电子邮件意味着您的邮箱配置正确。') . '</p>'));
-                    ->send();
             }, function () {
                 throw new \Exception("收件人地址错误或已被忽略");
             });
             return Base::retSuccess('成功发送');
         } catch (\Throwable $e) {
             // 一般是请求超时
-            if (str_contains($e->getMessage(), "Timed Out")) {
+            if (stripos($e->getMessage(), "timed out") !== false) {
                 return Base::retError("邮件发送超时，请检查邮箱配置是否正确");
             } elseif ($e->getCode() === 550) {
                 return Base::retError('邮件内容被拒绝，请检查邮箱是否开启接收功能');
@@ -1445,7 +1463,7 @@ class SystemController extends AbstractController
                 Base::deleteDirAndFile($zipPath, true);
             }
             try {
-                Madzipper::make($zipPath)->add($xlsPath)->close();
+                Base::zipAddFiles($zipPath, $xlsPath);
             } catch (\Throwable) {
             }
             //

app/Http/Controllers/Api/UploadController.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Models\User;
+use App\Module\Base;
+use App\Module\ChunkUpload;
+use Request;
+
+/**
+ * 分片上传统一入口。
+ *
+ * 动态路由（routes/web.php）：
+ *   api/upload/init     -> init()    启动一个上传会话（含秒传 / 续传命中）
+ *   api/upload/chunk    -> chunk()   接收一个分片
+ *   api/upload/merge    -> merge()   合并分片并按 scene 入库
+ *
+ * 小文件（<10MB）不走此接口，前端直接调用各 scene 的老接口（透明降级）。
+ */
+class UploadController extends AbstractController
+{
+    /**
+     * @api {post} api/upload/init 启动上传会话
+     *
+     * @apiDescription 提交文件 hash/size/name/scene/scene_params，返回 upload_id 与已收分片列表；
+     *  若同用户曾上传过同 hash 文件，直接返回 done=true（秒传）。
+     * @apiGroup upload
+     * @apiName init
+     *
+     * @apiParam {String} hash               文件 md5（小写 32 字符）
+     * @apiParam {Number} size               文件大小（字节）
+     * @apiParam {String} name               原始文件名（含扩展名）
+     * @apiParam {String} scene              场景：file_cabinet | dialog_file | image | generic_file
+     * @apiParam {Object} [scene_params]     场景参数（如 file_cabinet 需 pid/cover/webkit_relative_path）
+     *
+     * @apiSuccess {Number} ret
+     * @apiSuccess {Object} data 含 done / upload_id / chunk_size / chunk_count / received 或秒传 file
+     */
+    public function init()
+    {
+        $user = User::auth();
+        $result = ChunkUpload::start($user, [
+            'hash' => Request::input('hash', ''),
+            'size' => Request::input('size', 0),
+            'name' => Request::input('name', ''),
+            'scene' => Request::input('scene', ''),
+            'scene_params' => Request::input('scene_params', []),
+        ]);
+        return $result;
+    }
+
+    /**
+     * @api {post} api/upload/chunk 上传一个分片
+     *
+     * @apiDescription multipart 请求，blob 字段为分片数据。
+     * @apiGroup upload
+     * @apiName chunk
+     *
+     * @apiParam {String} upload_id    init 返回的 upload_id
+     * @apiParam {Number} index        分片序号（0-based）
+     * @apiParam {File}   blob         分片数据
+     *
+     * @apiSuccess {Number} ret
+     * @apiSuccess {Object} data 含 upload_id 与最新 received[]
+     */
+    public function chunk()
+    {
+        $user = User::auth();
+        $uploadId = trim(Request::input('upload_id', ''));
+        $index = intval(Request::input('index', -1));
+        $blob = Request::file('blob');
+        if ($uploadId === '') {
+            return Base::retError('upload_id 不能为空');
+        }
+        return ChunkUpload::receive($user, $uploadId, $index, $blob);
+    }
+
+    /**
+     * @api {post} api/upload/merge 合并分片并入库
+     *
+     * @apiDescription 全部分片到齐后调用；后端按 scene 路由到对应入库逻辑，返回与该 scene 老接口对齐的数据。
+     * @apiGroup upload
+     * @apiName merge
+     *
+     * @apiParam {String} upload_id    init 返回的 upload_id
+     *
+     * @apiSuccess {Number} ret
+     * @apiSuccess {Object} data       scene 入库返回数据
+     */
+    public function merge()
+    {
+        $user = User::auth();
+        $uploadId = trim(Request::input('upload_id', ''));
+        if ($uploadId === '') {
+            return Base::retError('upload_id 不能为空');
+        }
+        try {
+            return ChunkUpload::merge($user, $uploadId);
+        } catch (\Exception $e) {
+            if (str_contains($e->getMessage(), 'Failed to acquire lock')) {
+                return Base::retError('合并繁忙，请稍后再试');
+            }
+            return Base::retError($e->getMessage());
+        }
+    }
+
+    /**
+     * @api {post} api/upload/cancel 取消上传会话
+     *
+     * @apiDescription 调用方主动放弃一次分片上传时调用：删除 Redis meta/chunks/hash 索引并清掉分片目录。
+     *  会话已过期或归属其他用户时静默成功，避免给前端取消按钮回写"取消失败"。
+     * @apiGroup upload
+     * @apiName cancel
+     *
+     * @apiParam {String} upload_id    init 返回的 upload_id
+     *
+     * @apiSuccess {Number} ret
+     */
+    public function cancel()
+    {
+        $user = User::auth();
+        $uploadId = trim(Request::input('upload_id', ''));
+        if ($uploadId === '') {
+            return Base::retError('upload_id 不能为空');
+        }
+        ChunkUpload::cancelByUser($user, $uploadId);
+        return Base::retSuccess('已取消');
+    }
+}

app/Http/Controllers/Api/UsersController.php

@@ -276,6 +276,7 @@ class UsersController extends AbstractController
     public function login__codejson()
     {
         $captcha = Captcha::create('default', true);
+        $captcha['img'] = (string)$captcha['img'];
         return Base::retSuccess('请求成功', $captcha);
     }
 
@@ -322,7 +323,7 @@ class UsersController extends AbstractController
         $expiredAtCarbon = $expiredAt ? Carbon::parse($expiredAt) : null;
         $data = [
             'expired_at' => $expiredAtCarbon?->toDateTimeString(),
-            'remaining_seconds' => $expiredAtCarbon ? Carbon::now()->diffInSeconds($expiredAtCarbon, false) : null,
+            'remaining_seconds' => $expiredAtCarbon ? (int)Carbon::now()->diffInSeconds($expiredAtCarbon, false) : null,
             'expired' => $expired,
             'server_time' => Carbon::now()->toDateTimeString(),
         ];
@@ -417,7 +418,7 @@ class UsersController extends AbstractController
     public function info__managed_departments()
     {
         $user = User::auth();
-        if (Base::settingFind('system', 'department_owner_project_view', 'close') !== 'open') {
+        if (Base::settingFind('system', 'department_owner_project_view', 'open') !== 'open') {
             return Base::retSuccess('success', []);
         }
         return Base::retSuccess('success', UserDepartment::getManagedDepartments($user->userid));
@@ -1635,7 +1636,7 @@ class UsersController extends AbstractController
         } elseif ($type === 'create') {
             $meetingid = strtoupper(Base::generatePassword(11, 1));
             $name = $name ?: Doo::translate("{$user?->nickname} 发起的会议");
-            $channel = "DooTask:" . substr(md5($meetingid . env("APP_KEY")), 16);
+            $channel = "DooTask:" . substr(md5($meetingid . config('app.key')), 16);
             $meeting = Meeting::createInstance([
                 'meetingid' => $meetingid,
                 'name' => $name,

app/Http/Controllers/IndexController.php

@@ -26,7 +26,7 @@ use App\Tasks\UnclaimedTaskRemindTask;
 use App\Tasks\TodoRemindTask;
 use App\Tasks\AiTaskLoopTask;
 use Hhxsv5\LaravelS\Swoole\Task\Task;
-use Laravolt\Avatar\Avatar;
+use App\Module\PatchedAvatar as Avatar;
 
 
 /**
@@ -221,11 +221,13 @@ class IndexController extends InvokeController
                 'radius' => 0,
             ],
         ]);
-        return response($avatar->create($name)->save($file))
+        $avatar->create($name)->save($file);
-            ->header('Pragma', 'public')
+        return response()->file($file, [
-            ->header('Cache-Control', 'max-age=1814400')
+            'Pragma' => 'public',
-            ->header('Content-type', 'image/png')
+            'Cache-Control' => 'max-age=1814400',
-            ->header('Expires', gmdate('D, d M Y H:i:s \G\M\T', time() + 1814400));
+            'Content-type' => 'image/png',
+            'Expires' => gmdate('D, d M Y H:i:s \G\M\T', time() + 1814400),
+        ]);
     }
 
     /**
@@ -299,7 +301,7 @@ class IndexController extends InvokeController
         if (preg_match("/^\d+\.\d+\.\d+$/", $publishVersion)) {
             // 判断密钥
             $publishKey = Request::header('publish-key');
-            if ($publishKey !== env('APP_KEY')) {
+            if ($publishKey !== config('app.key')) {
                 return Base::retError("key error");
             }
             // 判断版本

app/Http/Controllers/InvokeController.php

@@ -24,8 +24,8 @@ class InvokeController extends BaseController
         if ($action) {
             $app .= "__" . $action;
         }
-        // 接口不存在
+        // 接口不存在（仅 public 方法可作为端点，protected/private 为内部方法，不暴露为路由）
-        if (!method_exists($this, $app)) {
+        if (!method_exists($this, $app) || !(new \ReflectionMethod($this, $app))->isPublic()) {
             $msg = "404 not found (" . str_replace("__", "/", $app) . ").";
             return Base::ajaxError($msg);
         }

app/Http/Kernel.php

@@ -1,68 +0,0 @@
-<?php
-
-namespace App\Http;
-
-use Illuminate\Foundation\Http\Kernel as HttpKernel;
-
-class Kernel extends HttpKernel
-{
-    /**
-     * The application's global HTTP middleware stack.
-     *
-     * These middleware are run during every request to your application.
-     *
-     * @var array
-     */
-    protected $middleware = [
-        // \App\Http\Middleware\TrustHosts::class,
-        \App\Http\Middleware\TrustProxies::class,
-        \Fruitcake\Cors\HandleCors::class,
-        \App\Http\Middleware\PreventRequestsDuringMaintenance::class,
-        \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
-        \App\Http\Middleware\TrimStrings::class,
-        \Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
-    ];
-
-    /**
-     * The application's route middleware groups.
-     *
-     * @var array
-     */
-    protected $middlewareGroups = [
-        'web' => [
-            \App\Http\Middleware\EncryptCookies::class,
-            \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
-            \Illuminate\Session\Middleware\StartSession::class,
-            // \Illuminate\Session\Middleware\AuthenticateSession::class,
-            \Illuminate\View\Middleware\ShareErrorsFromSession::class,
-            \App\Http\Middleware\VerifyCsrfToken::class,
-            \Illuminate\Routing\Middleware\SubstituteBindings::class,
-        ],
-
-        'api' => [
-            'throttle:api',
-            \Illuminate\Routing\Middleware\SubstituteBindings::class,
-        ],
-    ];
-
-    /**
-     * The application's route middleware.
-     *
-     * These middleware may be assigned to groups or used individually.
-     *
-     * @var array
-     */
-    protected $routeMiddleware = [
-        'auth' => \App\Http\Middleware\Authenticate::class,
-        'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
-        'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
-        'can' => \Illuminate\Auth\Middleware\Authorize::class,
-        'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
-        'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
-        'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
-        'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
-        'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
-
-        'webapi' => \App\Http\Middleware\WebApi::class,
-    ];
-}

app/Http/Middleware/Authenticate.php

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Illuminate\Auth\Middleware\Authenticate as Middleware;
-
-class Authenticate extends Middleware
-{
-    /**
-     * Get the path the user should be redirected to when they are not authenticated.
-     *
-     * @param  \Illuminate\Http\Request  $request
-     * @return string|null
-     */
-    protected function redirectTo($request)
-    {
-        if (! $request->expectsJson()) {
-            return route('login');
-        }
-    }
-}

app/Http/Middleware/EncryptCookies.php

@@ -1,17 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Illuminate\Cookie\Middleware\EncryptCookies as Middleware;
-
-class EncryptCookies extends Middleware
-{
-    /**
-     * The names of the cookies that should not be encrypted.
-     *
-     * @var array
-     */
-    protected $except = [
-        //
-    ];
-}

app/Http/Middleware/PreventRequestsDuringMaintenance.php

@@ -1,17 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Illuminate\Foundation\Http\Middleware\PreventRequestsDuringMaintenance as Middleware;
-
-class PreventRequestsDuringMaintenance extends Middleware
-{
-    /**
-     * The URIs that should be reachable while maintenance mode is enabled.
-     *
-     * @var array
-     */
-    protected $except = [
-        //
-    ];
-}

app/Http/Middleware/RedirectIfAuthenticated.php

@@ -1,32 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use App\Providers\RouteServiceProvider;
-use Closure;
-use Illuminate\Http\Request;
-use Illuminate\Support\Facades\Auth;
-
-class RedirectIfAuthenticated
-{
-    /**
-     * Handle an incoming request.
-     *
-     * @param  \Illuminate\Http\Request  $request
-     * @param  \Closure  $next
-     * @param  string|null  ...$guards
-     * @return mixed
-     */
-    public function handle(Request $request, Closure $next, ...$guards)
-    {
-        $guards = empty($guards) ? [null] : $guards;
-
-        foreach ($guards as $guard) {
-            if (Auth::guard($guard)->check()) {
-                return redirect(RouteServiceProvider::HOME);
-            }
-        }
-
-        return $next($request);
-    }
-}

app/Http/Middleware/TrimStrings.php

@@ -1,19 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Illuminate\Foundation\Http\Middleware\TrimStrings as Middleware;
-
-class TrimStrings extends Middleware
-{
-    /**
-     * The names of the attributes that should not be trimmed.
-     *
-     * @var array
-     */
-    protected $except = [
-        'current_password',
-        'password',
-        'password_confirmation',
-    ];
-}

app/Http/Middleware/TrustHosts.php

@@ -1,20 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Illuminate\Http\Middleware\TrustHosts as Middleware;
-
-class TrustHosts extends Middleware
-{
-    /**
-     * Get the host patterns that should be trusted.
-     *
-     * @return array
-     */
-    public function hosts()
-    {
-        return [
-            $this->allSubdomainsOfApplicationUrl(),
-        ];
-    }
-}

app/Http/Middleware/TrustProxies.php

@@ -1,23 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Fideloper\Proxy\TrustProxies as Middleware;
-use Illuminate\Http\Request;
-
-class TrustProxies extends Middleware
-{
-    /**
-     * The trusted proxies for this application.
-     *
-     * @var array|string|null
-     */
-    protected $proxies;
-
-    /**
-     * The headers that should be used to detect proxies.
-     *
-     * @var int
-     */
-    protected $headers = Request::HEADER_X_FORWARDED_FOR | Request::HEADER_X_FORWARDED_HOST | Request::HEADER_X_FORWARDED_PORT | Request::HEADER_X_FORWARDED_PROTO | Request::HEADER_X_FORWARDED_AWS_ELB;
-}

app/Http/Middleware/VerifyCsrfToken.php

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Http\Middleware;
-
-use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;
-
-class VerifyCsrfToken extends Middleware
-{
-    /**
-     * The URIs that should be excluded from CSRF verification.
-     *
-     * @var array
-     */
-    protected $except = [
-        // 接口部分
-        'api/*',
-
-        // 发布桌面端
-        'desktop/publish/',
-    ];
-}

app/Http/Middleware/WebApi.php

@@ -25,14 +25,6 @@ class WebApi
         RequestContext::set('start_time', microtime(true));
         RequestContext::set('header_language', $request->header('language'));
 
-        // 强制 https
-        $APP_SCHEME = env('APP_SCHEME', 'auto');
-        if (in_array(strtolower($APP_SCHEME), ['https', 'on', 'ssl', '1', 'true', 'yes'], true)) {
-            $request->server->set('HTTPS', 'on');
-            $request->headers->set('X-Forwarded-Proto', 'https');
-            $request->setTrustedProxies([$request->getClientIp()], $request::HEADER_X_FORWARDED_PROTO);
-        }
-
         // 更新请求的基本URL
         RequestContext::updateBaseUrl($request);
 

app/Ldap/LdapUser.php

@@ -15,10 +15,8 @@ class LdapUser extends Model
 {
     /**
      * The object classes of the LDAP model.
-     *
-     * @var array
      */
-    public static $objectClasses = [
+    public static array $objectClasses = [
         'person',
         'top',
     ];

app/Models/AbstractModel.php

@@ -5,6 +5,7 @@ namespace App\Models;
 use App\Exceptions\ApiException;
 use App\Module\Base;
 use DateTimeInterface;
+use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\DB;
@@ -31,7 +32,10 @@ class AbstractModel extends Model
 
     const ID = 'id';
 
-    protected $dates = [
+    /**
+     * 全局日期字段（Laravel 10 移除 $dates 属性后改经 getCasts 合并，子模型 $casts 同名键优先）
+     */
+    protected $defaultDatetimeCasts = [
         'top_at',
         'last_at',
 
@@ -59,6 +63,15 @@ class AbstractModel extends Model
         'deleted_at',
     ];
 
+    public function getCasts(): array
+    {
+        $casts = parent::getCasts();
+        foreach ($this->defaultDatetimeCasts as $field) {
+            $casts[$field] ??= 'datetime';
+        }
+        return $casts;
+    }
+
     protected $appendattrs = [];
 
     /**
@@ -189,6 +202,66 @@ class AbstractModel extends Model
         return $instance;
     }
 
+    /**
+     * 覆写框架 saveOrIgnore 的底层插入逻辑。
+     *
+     * 框架默认走 insertOrIgnoreReturning（INSERT ... ON CONFLICT ... RETURNING），
+     * MySQL/MariaDB 的 grammar 不支持该变体，会抛
+     * "This database engine does not support insert or ignore with returning."。
+     * 这里改用 MySQL 支持的 INSERT IGNORE，并在成功插入时手动回填自增ID，
+     * 保持与框架一致的返回语义（冲突被忽略时返回 false）。
+     *
+     * @param  \Illuminate\Database\Eloquent\Builder  $query
+     * @param  array|string|null  $uniqueBy
+     * @return bool
+     */
+    protected function performInsertOrIgnore(Builder $query, array|string|null $uniqueBy)
+    {
+        // MySQL INSERT IGNORE 无法按指定列限制冲突范围，所有 unique 冲突一并吞掉。
+        // 若调用方传了 $uniqueBy 期望精确 scope，这里直接抛错，避免与框架语义偷偷不一致。
+        if ($uniqueBy !== null) {
+            throw new \InvalidArgumentException('saveOrIgnore $uniqueBy is not supported on MySQL driver; pass null.');
+        }
+
+        if ($this->usesUniqueIds()) {
+            $this->setUniqueIds();
+        }
+
+        if ($this->fireModelEvent('creating') === false) {
+            return false;
+        }
+
+        if ($this->usesTimestamps()) {
+            $this->updateTimestamps();
+        }
+
+        $attributes = $this->getAttributesForInsert();
+
+        if (empty($attributes)) {
+            return true;
+        }
+
+        if ($query->toBase()->insertOrIgnore($attributes) === 0) {
+            return false;
+        }
+
+        if ($this->getIncrementing()) {
+            $lastId = $query->getConnection()->getPdo()->lastInsertId();
+            // 无 auto_increment 列的表上 INSERT IGNORE 即使插入成功 lastInsertId 也返回 "0"，
+            // 别用它去覆盖业务设置的主键。
+            if ($lastId > 0) {
+                $this->setAttribute($this->getKeyName(), $lastId);
+            }
+        }
+
+        $this->exists = true;
+        $this->wasRecentlyCreated = true;
+
+        $this->fireModelEvent('created', false);
+
+        return true;
+    }
+
     /**
      * 更新数据校验
      * @param array $param

app/Models/AiAssistantFeedback.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Models;
+
+/**
+ * AI 助手回复反馈（👍/👎）
+ *
+ * @property int $id
+ * @property int $userid
+ * @property string $session_key
+ * @property string $session_id
+ * @property int $local_id
+ * @property string $feedback
+ * @property string|null $prompt
+ * @property string $answer_digest
+ * @property string|null $answer
+ * @property string|null $source_ids
+ * @property string $model
+ * @property \Carbon\Carbon $created_at
+ * @property \Carbon\Carbon $updated_at
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback cancelAppend()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback cancelHidden()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback change($array)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback getKeyValue()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback newModelQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback newQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback query()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback remove()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback saveOrIgnore()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereAnswer($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereAnswerDigest($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereCreatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereFeedback($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereLocalId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereModel($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback wherePrompt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereSessionId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereSessionKey($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereSourceIds($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereUpdatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantFeedback whereUserid($value)
+ * @mixin \Eloquent
+ */
+class AiAssistantFeedback extends AbstractModel
+{
+    protected $table = 'ai_assistant_feedbacks';
+}

app/Models/AiAssistantSearchLog.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Models;
+
+/**
+ * AI 助手帮助知识库检索日志
+ *
+ * @property int $id
+ * @property int $userid
+ * @property int $dialog_id
+ * @property string $context_key
+ * @property string $source
+ * @property string $query
+ * @property string $locale
+ * @property string|null $source_ids
+ * @property float $top_score
+ * @property int $result_count
+ * @property int $duration_ms
+ * @property int $empty
+ * @property \Carbon\Carbon $created_at
+ * @property \Carbon\Carbon $updated_at
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog cancelAppend()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog cancelHidden()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog change($array)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog getKeyValue()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog newModelQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog newQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog query()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog remove()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog saveOrIgnore()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereContextKey($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereCreatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereDialogId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereDurationMs($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereEmpty($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereLocale($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereQuery($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereResultCount($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereSource($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereSourceIds($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereTopScore($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereUpdatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSearchLog whereUserid($value)
+ * @mixin \Eloquent
+ */
+class AiAssistantSearchLog extends AbstractModel
+{
+    protected $table = 'ai_assistant_search_logs';
+}

app/Models/AiAssistantSession.php

@@ -15,6 +15,26 @@ namespace App\Models;
  * @property string|null $images
  * @property \Carbon\Carbon $created_at
  * @property \Carbon\Carbon $updated_at
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession cancelAppend()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession cancelHidden()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession change($array)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession getKeyValue()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession newModelQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession newQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession query()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession remove()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession saveOrIgnore()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereCreatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereData($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereImages($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereSceneKey($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereSessionId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereSessionKey($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereTitle($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereUpdatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|AiAssistantSession whereUserid($value)
+ * @mixin \Eloquent
  */
 class AiAssistantSession extends AbstractModel
 {

app/Models/AppBadge.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Models;
+
+/**
+ * App\Models\AppBadge
+ *
+ * 插件/微应用菜单角标（每个 (app_id, menu_key, userid) 一行，仅存非清除态）
+ *
+ * @property int $id
+ * @property string $app_id 应用ID
+ * @property string $menu_key 菜单稳定标识（空串=第一个菜单）
+ * @property int $userid 用户ID
+ * @property int $count 角标数字
+ * @property bool $dot 是否显示红点
+ * @property \Illuminate\Support\Carbon|null $updated_at
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge newModelQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge newQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge query()
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereAppId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereCount($value)
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereDot($value)
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereMenuKey($value)
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereUpdatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder|AppBadge whereUserid($value)
+ * @mixin \Eloquent
+ */
+class AppBadge extends AbstractModel
+{
+    protected $table = 'app_badges';
+
+    const CREATED_AT = null;
+
+    protected $fillable = [
+        'app_id',
+        'menu_key',
+        'userid',
+        'count',
+        'dot',
+    ];
+
+    protected $casts = [
+        'userid' => 'integer',
+        'count' => 'integer',
+        'dot' => 'boolean',
+    ];
+}

app/Models/ApproveProcInstHistory.php

@@ -1,99 +0,0 @@
-<?php
-
-namespace App\Models;
-
-use Cache;
-use Carbon\Carbon;
-use DB;
-
-/**
- * App\Models\ApproveProcInstHistory
- *
- * @property int $id
- * @property int $proc_def_id 流程定义ID
- * @property string|null $proc_def_name 流程定义名
- * @property string|null $title 标题
- * @property int|null $department_id 用户部门ID
- * @property string|null $department 用户部门
- * @property string|null $company 用户公司
- * @property string|null $node_id 当前节点
- * @property string|null $candidate 审批人
- * @property int|null $task_id 当前任务
- * @property string|null $start_time 开始时间
- * @property string|null $end_time 结束时间
- * @property int|null $duration 持续时间
- * @property string|null $start_user_id 开始用户ID
- * @property string|null $start_user_name 开始用户名
- * @property int|null $is_finished 是否完成
- * @property string|null $var
- * @property int $state 当前状态: 0待审批，1审批中，2通过，3拒绝，4撤回
- * @property string|null $latest_comment
- * @property string|null $global_comment
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel cancelAppend()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel cancelHidden()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel change($array)
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel getKeyValue()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory newModelQuery()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory newQuery()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory query()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel remove()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel saveOrIgnore()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereCandidate($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereCompany($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereDepartment($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereDepartmentId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereDuration($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereEndTime($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereGlobalComment($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereIsFinished($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereLatestComment($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereNodeId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereProcDefId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereProcDefName($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereStartTime($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereStartUserId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereStartUserName($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereState($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereTaskId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereTitle($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcInstHistory whereVar($value)
- * @mixin \Eloquent
- */
-class ApproveProcInstHistory extends AbstractModel
-{
-    protected $table = 'approve_proc_inst_history';
-
-    /**
-     * 获取用户审批状态（请假、外出）
-     * @param $userid
-     * @return mixed|null
-     */
-    public static function getUserApprovalStatus($userid)
-    {
-        if (empty($userid)) {
-            return null;
-        }
-        return Cache::remember('user_is_leave_' . $userid, Carbon::now()->addMinute(), function () use ($userid) {
-            return self::where([
-                ['start_user_id', '=', $userid],
-                [DB::raw("JSON_UNQUOTE(JSON_EXTRACT(var, '$.startTime'))"), '<=', Carbon::now()->toDateTimeString()],
-                [DB::raw("JSON_UNQUOTE(JSON_EXTRACT(var, '$.endTime'))"), '>=', Carbon::now()->toDateTimeString()],
-                ['state', '=', 2]
-            ])->where(function ($query) {
-                $query->where('proc_def_name', 'like', '%请假%')
-                    ->orWhere('proc_def_name', 'like', '%外出%');
-            })->orderByDesc('id')->value('proc_def_name');
-        });
-    }
-
-    /**
-     * 判断用户是否请假（包含：请假、外出）
-     * @param $userid
-     * @return bool
-     */
-    public static function userIsLeave($userid)
-    {
-        return (bool)self::getUserApprovalStatus($userid);
-    }
-}

app/Models/ApproveProcMsg.php

@@ -1,34 +0,0 @@
-<?php
-
-namespace App\Models;
-
-/**
- * App\Models\ApproveProcMsg
- *
- * @property int $id
- * @property int|null $proc_inst_id 流程实例ID
- * @property int|null $userid 会员ID
- * @property int|null $msg_id 消息ID
- * @property \Illuminate\Support\Carbon|null $created_at
- * @property \Illuminate\Support\Carbon|null $updated_at
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel cancelAppend()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel cancelHidden()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel change($array)
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel getKeyValue()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg newModelQuery()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg newQuery()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg query()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel remove()
- * @method static \Illuminate\Database\Eloquent\Builder|AbstractModel saveOrIgnore()
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg whereCreatedAt($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg whereId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg whereMsgId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg whereProcInstId($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg whereUpdatedAt($value)
- * @method static \Illuminate\Database\Eloquent\Builder|ApproveProcMsg whereUserid($value)
- * @mixin \Eloquent
- */
-class ApproveProcMsg extends AbstractModel
-{
-
-}

app/Models/File.php

@@ -178,28 +178,26 @@ class File extends AbstractModel
      * @param int $pid
      * @param string $type
      * @param bool $isGetparent
+     * @param string $scope 板块范围（根目录生效）：mine=仅我的私有文件；shared=共享文件（别人共享给我的+我共享出去的）；all=全部（默认，兼容旧调用）
      * @return array
      */
-    public function getFileList($user, int $pid, $type = "all", $isGetparent = true)
+    public function getFileList($user, int $pid, $type = "all", $isGetparent = true, $scope = "all")
     {
         $permission = 1000;
         $userids = $user->isTemp() ? [$user->userid] : [0, $user->userid];
-        $builder = File::wherePid($pid)
+        //
+        if ($pid > 0) {
+            // 目录内：按权限返回子级（不区分板块）
+            File::permissionFind($pid, $userids, 0, $permission);
+            $array = File::wherePid($pid)
                 ->when($type == 'dir', function ($q) {
                     $q->whereType('folder');
-            });
+                })
-        if ($pid > 0) {
+                ->take(500)->get()->toArray();
-            File::permissionFind($pid, $userids, 0, $permission);
-        } else {
-            $builder->whereUserid($user->userid);
-        }
-        //
-        $array = $builder->take(500)->get()->toArray();
             foreach ($array as &$item) {
                 $item['permission'] = $permission;
             }
-        //
+            unset($item);
-        if ($pid > 0) {
             // 遍历获取父级
             if ($isGetparent) {
                 while ($pid > 0) {
@@ -230,7 +228,25 @@ class File extends AbstractModel
                 $array = array_values($array);
             }
         } else {
-            // 获取共享相关
+            // 根目录：按板块拆分
+            $array = [];
+            // 我的文件：我拥有的全部（含已共享出去的），mine 与 all 一致
+            if ($scope === 'mine' || $scope === 'all') {
+                $mine = File::wherePid(0)
+                    ->whereUserid($user->userid)
+                    ->when($type == 'dir', function ($q) {
+                        $q->whereType('folder');
+                    })
+                    ->take(500)->get()->toArray();
+                foreach ($mine as &$item) {
+                    $item['permission'] = $permission;
+                }
+                unset($item);
+                $array = array_merge($array, $mine);
+            }
+            // 共享文件
+            if ($scope === 'shared' || $scope === 'all') {
+                // 别人共享给我的
                 DB::statement("SET SQL_MODE=''");
                 $pre = DB::connection()->getTablePrefix();
                 $list = File::select(["files.*", DB::raw("MAX({$pre}file_users.permission) as permission")])
@@ -250,6 +266,22 @@ class File extends AbstractModel
                         $array[] = $temp;
                     }
                 }
+                // 我共享出去的（仅 shared 板块补充；all 板块已包含在“我的文件”里）
+                if ($scope === 'shared') {
+                    $mineShared = File::wherePid(0)
+                        ->whereUserid($user->userid)
+                        ->where('share', 1)
+                        ->when($type == 'dir', function ($q) {
+                            $q->whereType('folder');
+                        })
+                        ->take(500)->get()->toArray();
+                    foreach ($mineShared as &$item) {
+                        $item['permission'] = $permission;
+                    }
+                    unset($item);
+                    $array = array_merge($array, $mineShared);
+                }
+            }
         }
         // 图片直接返回预览地址
         foreach ($array as &$item) {
@@ -267,20 +299,74 @@ class File extends AbstractModel
      * @return array
      */
     public function contentUpload($user, int $pid, $webkitRelativePath, $overwrite = false)
+    {
+        [$pid, $userid, $addItem] = $this->contentUploadPrep($user, $pid, $webkitRelativePath);
+        $data = Base::upload([
+            "file" => Request::file('files'),
+            "type" => 'more',
+            "autoThumb" => false,
+            "path" => 'uploads/tmp/file/' . date("Ym") . '/',
+            "quality" => true,
+        ]);
+        if (Base::isError($data)) {
+            throw new ApiException($data['msg']);
+        }
+        return $this->contentUploadCommit($user, $userid, $pid, $data['data'], $addItem, $webkitRelativePath, null, $overwrite);
+    }
+
+    /**
+     * 与 contentUpload 同一入库链路，但接收已落盘的本地文件而非 Request 上传文件。
+     * 供分片上传 merge 阶段调用。
+     *
+     * @param user $user
+     * @param int $pid
+     * @param string $localPath 合并后的完整文件绝对路径
+     * @param string $originalName 原始文件名（含扩展名）
+     * @param string $webkitRelativePath
+     * @param string|null $hash 文件 md5，用于秒传索引
+     * @param bool $overwrite
+     * @return array
+     */
+    public function contentUploadFromPath($user, int $pid, string $localPath, string $originalName, $webkitRelativePath, $hash = null, $overwrite = false)
+    {
+        [$pid, $userid, $addItem] = $this->contentUploadPrep($user, $pid, $webkitRelativePath);
+        $data = Base::uploadFromPath([
+            "path_local" => $localPath,
+            "name" => $originalName,
+            "type" => 'more',
+            "autoThumb" => false,
+            "path" => 'uploads/tmp/file/' . date("Ym") . '/',
+            "quality" => true,
+        ]);
+        if (Base::isError($data)) {
+            throw new ApiException($data['msg']);
+        }
+        return $this->contentUploadCommit($user, $userid, $pid, $data['data'], $addItem, $webkitRelativePath, $hash, $overwrite);
+    }
+
+    /**
+     * 上传前置：权限/计数校验 + webkitRelativePath 拆出来的中间文件夹创建。
+     * 失败抛 ApiException；成功返回 [最终 pid, 拥有者 userid, 已创建的中间文件夹列表]。
+     *
+     * @param user   $user
+     * @param int    $pid
+     * @param string $webkitRelativePath
+     * @return array{0:int, 1:int, 2:array}
+     */
+    public function contentUploadPrep($user, int $pid, $webkitRelativePath): array
     {
         $userid = $user->userid;
         if ($pid > 0) {
             if (File::wherePid($pid)->count() >= 300) {
-                return Base::retError('每个文件夹里最多只能创建300个文件或文件夹');
+                throw new ApiException('每个文件夹里最多只能创建300个文件或文件夹');
             }
             $row = File::permissionFind($pid, $user, 1);
             $userid = $row->userid;
         } else {
             if (File::whereUserid($user->userid)->wherePid(0)->count() >= 300) {
-                return Base::retError('每个文件夹里最多只能创建300个文件或文件夹');
+                throw new ApiException('每个文件夹里最多只能创建300个文件或文件夹');
             }
         }
-        //
         $dirs = explode("/", $webkitRelativePath);
         $addItem = [];
         while (count($dirs) > 1) {
@@ -297,13 +383,11 @@ class File extends AbstractModel
                             'created_id' => $user->userid,
                         ]);
                         $dirRow->handleDuplicateName();
-                        if ($dirRow->saveBeforePP()) {
+                        if (!$dirRow->saveBeforePP()) {
-                            $addItem[] = File::find($dirRow->id);
-                        }
-                    }
-                    if (empty($dirRow)) {
                             throw new ApiException('创建文件夹失败');
                         }
+                        $addItem[] = File::find($dirRow->id);
+                    }
                     $pid = $dirRow->id;
                 });
                 foreach ($addItem as $tmpRow) {
@@ -311,20 +395,24 @@ class File extends AbstractModel
                 }
             }
         }
-        //
+        return [$pid, $userid, $addItem];
-        $path = 'uploads/tmp/file/' . date("Ym") . '/';
-        $data = Base::upload([
-            "file" => Request::file('files'),
-            "type" => 'more',
-            "autoThumb" => false,
-            "path" => $path,
-            "quality" => true
-        ]);
-        if (Base::isError($data)) {
-            throw new ApiException($data['msg']);
     }
-        $data = $data['data'];
+
-        //
+    /**
+     * 上传后置：ext → type 映射 + File 记录创建 + uploadMove + FileContent 入库。
+     *
+     * @param user   $user
+     * @param int    $userid             目标文件拥有者
+     * @param int    $pid
+     * @param array  $data               Base::upload/uploadFromPath 返回的 data 部分
+     * @param array  $addItem            prep 阶段累积的中间文件夹
+     * @param string $webkitRelativePath
+     * @param string|null $hash          可选，写入 files.hash（秒传索引）
+     * @param bool   $overwrite
+     * @return array{data: array, addItem: array}
+     */
+    private function contentUploadCommit($user, int $userid, int $pid, array $data, array $addItem, $webkitRelativePath, $hash, bool $overwrite): array
+    {
         $type = match ($data['ext']) {
             'text', 'md', 'markdown' => 'document',
             'drawio' => 'drawio',
@@ -356,7 +444,6 @@ class File extends AbstractModel
         if ($data['ext'] == 'markdown') {
             $data['ext'] = 'md';
         }
-        $file = null;
         $params = [
             'pid' => $pid,
             'name' => Base::rightDelete($data['name'], '.' . $data['ext']),
@@ -365,6 +452,7 @@ class File extends AbstractModel
             'userid' => $userid,
             'created_id' => $user->userid,
         ];
+        $file = null;
         if ($overwrite) {
             $file = self::wherePid($params['pid'])->whereExt($params['ext'])->whereName($params['name'])->first();
         }
@@ -373,11 +461,12 @@ class File extends AbstractModel
             $file = File::createInstance($params);
             $file->handleDuplicateName();
         }
-        // 开始创建
+        return AbstractModel::transaction(function () use ($overwrite, $addItem, $webkitRelativePath, $type, $user, $data, $file, $hash) {
-        return AbstractModel::transaction(function () use ($overwrite, $addItem, $webkitRelativePath, $type, $user, $data, $file) {
             $file->size = $data['size'] * 1024;
+            if ($hash) {
+                $file->hash = $hash;
+            }
             $file->saveBeforePP();
-            //
             $data = Base::uploadMove($data, "uploads/file/" . $file->type . "/" . date("Ym") . "/" . $file->id . "/");
             $content = [
                 'from' => '',
@@ -389,25 +478,20 @@ class File extends AbstractModel
                 $content['width'] = $data['width'];
                 $content['height'] = $data['height'];
             }
-            $content = FileContent::createInstance([
+            FileContent::createInstance([
                 'fid' => $file->id,
                 'content' => $content,
                 'text' => '',
                 'size' => $file->size,
                 'userid' => $user->userid,
-            ]);
+            ])->save();
-            $content->save();
-            //
             $tmpRow = File::find($file->id);
             $tmpRow->pushMsg('add', $tmpRow);
-            //
+            $row = File::handleImageUrl($tmpRow->toArray());
-            $data = File::handleImageUrl($tmpRow->toArray());
+            $row['full_name'] = $webkitRelativePath ?: ($row['name'] . '.' . $row['ext']);
-            $data['full_name'] = $webkitRelativePath ?: ($data['name'] . '.' . $data['ext']);
+            $row['overwrite'] = $overwrite ? 1 : 0;
-            $data['overwrite'] = $overwrite ? 1 : 0;
+            $addItem[] = $row;
-            //
+            return ['data' => $row, 'addItem' => $addItem];
-            $addItem[] = $data;
-
-            return ['data' => $data, 'addItem' => $addItem];
         });
     }
 

app/Models/ManticoreSyncFailure.php

@@ -14,6 +14,25 @@ namespace App\Models;
  * @property \Carbon\Carbon|null $last_retry_at 最后重试时间
  * @property \Carbon\Carbon $created_at
  * @property \Carbon\Carbon $updated_at
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure cancelAppend()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure cancelHidden()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure change($array)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure getKeyValue()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure newModelQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure newQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure query()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure remove()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure saveOrIgnore()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereAction($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereCreatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereDataId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereDataType($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereErrorMessage($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereLastRetryAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereRetryCount($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ManticoreSyncFailure whereUpdatedAt($value)
+ * @mixin \Eloquent
  */
 class ManticoreSyncFailure extends AbstractModel
 {
@@ -28,10 +47,8 @@ class ManticoreSyncFailure extends AbstractModel
         'last_retry_at',
     ];
 
-    protected $dates = [
+    protected $casts = [
-        'last_retry_at',
+        'last_retry_at' => 'datetime',
-        'created_at',
-        'updated_at',
     ];
 
     /**
@@ -73,6 +90,24 @@ class ManticoreSyncFailure extends AbstractModel
             ->delete();
     }
 
+    /**
+     * 批量清除同步成功记录（供批量写入路径使用，避免逐条删除）
+     *
+     * @param string $dataType 数据类型
+     * @param array $dataIds 数据ID列表
+     * @param string $action 操作类型
+     */
+    public static function removeSuccessBatch(string $dataType, array $dataIds, string $action): void
+    {
+        if (empty($dataIds)) {
+            return;
+        }
+        self::where('data_type', $dataType)
+            ->whereIn('data_id', $dataIds)
+            ->where('action', $action)
+            ->delete();
+    }
+
     /**
      * 获取待重试的记录
      * 根据重试次数决定间隔：1次=1分钟，2次=5分钟，3次=15分钟，4次+=30分钟

app/Models/Project.php

@@ -68,6 +68,10 @@ use Request;
  * @method static \Illuminate\Database\Eloquent\Builder|Project whereUserid($value)
  * @method static \Illuminate\Database\Eloquent\Builder|Project withTrashed()
  * @method static \Illuminate\Database\Eloquent\Builder|Project withoutTrashed()
+ * @property-read array $deputy_userids
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|Project whereAiAutoAnalyze($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|Project whereDepartmentOwnerView($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|Project whereTaskTemplateShare($value)
  * @mixin \Eloquent
  */
 class Project extends AbstractModel

app/Models/ProjectTask.php

@@ -482,7 +482,7 @@ class ProjectTask extends AbstractModel
         if ($parent_id == 0) {
             $priorityList = Setting::normalizeTaskPriorityList(Base::setting('priority'));
             if ($p_level > 0) {
-                $matched = reset(array_filter($priorityList, fn($item) => intval($item['priority']) === $p_level)) ?: null;
+                $matched = collect($priorityList)->first(fn($item) => intval($item['priority']) === $p_level);
             } else {
                 $matched = Setting::getDefaultTaskPriorityItem($priorityList);
             }
@@ -937,7 +937,7 @@ class ProjectTask extends AbstractModel
                         'cache' => [
                             'task_at' => $oldStringAt,
                             'change_at' => $newStringAt,
-                            'over_sec' => $effectiveEndTime->diffInSeconds($oldAt[1]),
+                            'over_sec' => (int)$effectiveEndTime->diffInSeconds($oldAt[1], true),
                             'owners' => $this->taskUser->where('owner', 1)->pluck('userid')->toArray(),
                             'assists' => $this->taskUser->where('owner', 0)->pluck('userid')->toArray(),
                         ]
@@ -1633,7 +1633,7 @@ class ProjectTask extends AbstractModel
                     $this->addLog("{任务}超期未完成", [
                         'cache' => [
                             'task_at' => $this->start_at . '~' . $this->end_at,
-                            'over_sec' => Carbon::now()->diffInSeconds($this->end_at),
+                            'over_sec' => (int)Carbon::now()->diffInSeconds($this->end_at, true),
                             'owners' => $this->taskUser->where('owner', 1)->pluck('userid')->toArray(),
                             'assists' => $this->taskUser->where('owner', 0)->pluck('userid')->toArray(),
                         ]
@@ -2246,7 +2246,7 @@ class ProjectTask extends AbstractModel
             $project = Project::userProject($task->project_id);
         } catch (\Throwable $e) {
             if ($task->owner !== null || $task->permission(4)) {
-                $project = Project::find($task->project_id);
+                $project = Project::withTrashed()->find($task->project_id);
                 if (empty($project)) {
                     throw new ApiException('项目不存在或已被删除', [ 'task_id' => $task_id ], -4002);
                 }

app/Models/ProjectTaskAiEvent.php

@@ -18,6 +18,28 @@ use Illuminate\Database\Eloquent\Relations\BelongsTo;
  * @property \Illuminate\Support\Carbon|null $executed_at
  * @property \Illuminate\Support\Carbon|null $created_at
  * @property \Illuminate\Support\Carbon|null $updated_at
+ * @property-read \App\Models\ProjectTask|null $task
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent cancelAppend()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent cancelHidden()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent change($array)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent getKeyValue()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent newModelQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent newQuery()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent query()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent remove()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent saveOrIgnore()
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereCreatedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereError($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereEventType($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereExecutedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereMsgId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereResult($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereRetryCount($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereStatus($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereTaskId($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskAiEvent whereUpdatedAt($value)
+ * @mixin \Eloquent
  */
 class ProjectTaskAiEvent extends AbstractModel
 {

app/Models/ProjectTaskTemplate.php

@@ -38,6 +38,8 @@ namespace App\Models;
  * @method static \Illuminate\Database\Eloquent\Builder|ProjectTaskTemplate whereTitle($value)
  * @method static \Illuminate\Database\Eloquent\Builder|ProjectTaskTemplate whereUpdatedAt($value)
  * @method static \Illuminate\Database\Eloquent\Builder|ProjectTaskTemplate whereUserid($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskTemplate whereLastUsedAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|ProjectTaskTemplate whereUseCount($value)
  * @mixin \Eloquent
  */
 class ProjectTaskTemplate extends AbstractModel

app/Models/Report.php

@@ -156,7 +156,7 @@ class Report extends AbstractModel
      * @param User|null $user
      * @return Builder|Model|\Illuminate\Database\Query\Builder|object
      */
-    public static function getLastOne(User $user = null)
+    public static function getLastOne(?User $user = null)
     {
         $user === null && $user = User::auth();
         $one = self::whereUserid($user->userid)->orderByDesc("created_at")->first();

app/Models/Setting.php

@@ -51,12 +51,12 @@ class Setting extends AbstractModel
         switch ($this->name) {
             // 系统设置
             case 'system':
-                $value['system_alias'] = $value['system_alias'] ?: env('APP_NAME');
+                $value['system_alias'] = ($value['system_alias'] ?? null) ?: config('app.name');
-                $value['image_compress'] = $value['image_compress'] ?: 'open';
+                $value['image_compress'] = ($value['image_compress'] ?? null) ?: 'open';
-                $value['image_quality'] = min(100, max(0, intval($value['image_quality']) ?: 90));
+                $value['image_quality'] = min(100, max(0, intval($value['image_quality'] ?? 0) ?: 90));
-                $value['image_save_local'] = $value['image_save_local'] ?: 'open';
+                $value['image_save_local'] = ($value['image_save_local'] ?? null) ?: 'open';
-                $value['task_user_limit'] = min(2000, max(1, intval($value['task_user_limit']) ?: 500));
+                $value['task_user_limit'] = min(2000, max(1, intval($value['task_user_limit'] ?? 0) ?: 500));
-                if (!is_array($value['task_default_time']) || count($value['task_default_time']) != 2 || !Timer::isTime($value['task_default_time'][0]) || !Timer::isTime($value['task_default_time'][1])) {
+                if (!is_array($value['task_default_time'] ?? null) || count($value['task_default_time']) != 2 || !Timer::isTime($value['task_default_time'][0]) || !Timer::isTime($value['task_default_time'][1])) {
                     $value['task_default_time'] = ['09:00', '18:00'];
                 }
                 // 项目创建权限：范围（all/departmentOwner/appoint，默认 all）+ 指定人员
@@ -71,8 +71,8 @@ class Setting extends AbstractModel
 
             // 文件设置
             case 'fileSetting':
-                $value['permission_pack_type'] = $value['permission_pack_type'] ?: 'all';
+                $value['permission_pack_type'] = ($value['permission_pack_type'] ?? null) ?: 'all';
-                $value['permission_pack_userids'] = is_array($value['permission_pack_userids']) ? $value['permission_pack_userids'] : [];
+                $value['permission_pack_userids'] = is_array($value['permission_pack_userids'] ?? null) ? $value['permission_pack_userids'] : [];
                 break;
 
             // AI 机器人设置
@@ -81,7 +81,7 @@ class Setting extends AbstractModel
                     $value['claude_key'] = $value['claude_token'];
                 }
                 $array = [];
-                $aiList = ['openai', 'claude', 'deepseek', 'gemini', 'grok', 'ollama', 'zhipu', 'qianwen', 'wenxin'];
+                $aiList = ['openai', 'claude', 'deepseek', 'gemini', 'grok', 'ollama', 'zhipu', 'qianwen', 'wenxin', 'dooai'];
                 $fieldList = ['key', 'secret', 'models', 'model', 'base_url', 'agency', 'temperature', 'system'];
                 foreach ($aiList as $aiName) {
                     foreach ($fieldList as $fieldName) {
@@ -89,11 +89,13 @@ class Setting extends AbstractModel
                         $content = !empty($value[$key]) ? trim($value[$key]) : '';
                         switch ($fieldName) {
                             case 'models':
-                                if ($content) {
+                                // 新 JSON 数组格式原样保留；仅旧的换行格式按行清洗
+                                if ($content && !str_starts_with($content, '[')) {
                                     $content = explode("\n", $content);
                                     $content = array_filter($content);
+                                    $content = implode("\n", $content);
                                 }
-                                $content = is_array($content) ? implode("\n", $content) : '';
+                                $content = is_string($content) ? $content : '';
                                 break;
                             case 'model':
                                 $models = Setting::AIBotModels2Array($array[$key . 's'], true);
@@ -214,28 +216,87 @@ class Setting extends AbstractModel
     /**
      * AI 机器人模型转数组
      * @param $models
-     * @param bool $retValue
+     * @param bool $retValue 仅返回模型 value 列表
+     * @param bool $visibleOnly 仅返回可见模型（跳过标记 hidden 的项，供展示给终端用户的场景）
      * @return array
      */
-    public static function AIBotModels2Array($models, $retValue = false)
+    public static function AIBotModels2Array($models, $retValue = false, $visibleOnly = false)
     {
-        $list = is_array($models) ? $models : explode("\n", $models);
+        $list = null;
+        if (is_array($models)) {
+            $list = $models;
+        } else {
+            $text = trim((string)$models);
+            if ($text !== '' && str_starts_with($text, '[')) {
+                $decoded = json_decode($text, true);
+                if (is_array($decoded)) {
+                    $list = $decoded;
+                }
+            }
+            if ($list === null) {
+                $list = explode("\n", (string)$models);
+            }
+        }
         $array = [];
         foreach ($list as $item) {
+            if (is_array($item)) {
+                // 新 JSON 记录格式：{id,name,thinking}（兼容 {value,label}）
+                $value = trim((string)($item['id'] ?? $item['value'] ?? ''));
+                if ($value === '') {
+                    continue;
+                }
+                // 隐藏模型：仍保存在设置中，但展示给终端用户时跳过（$visibleOnly）
+                if ($visibleOnly && !empty($item['hidden'])) {
+                    continue;
+                }
+                $label = trim((string)($item['name'] ?? $item['label'] ?? ''));
+                $thinking = strtolower(trim((string)($item['thinking'] ?? 'off')));
+                if (!in_array($thinking, ['off', 'low', 'medium', 'high'], true)) {
+                    $thinking = 'off';
+                }
+                $array[] = [
+                    'value' => $value,
+                    'label' => $label !== '' ? $label : $value,
+                    'thinking' => $thinking,
+                ];
+            } else {
+                // 兼容旧字符串格式 "id|name"
                 $arr = Base::newTrim(explode('|', $item . '|'));
                 if ($arr[0]) {
                     $array[] = [
                         'value' => $arr[0],
-                    'label' => $arr[1] ?: $arr[0]
+                        'label' => $arr[1] ?: $arr[0],
+                        'thinking' => 'off',
                     ];
                 }
             }
+        }
         if ($retValue) {
             return array_column($array, 'value');
         }
         return $array;
     }
 
+    /**
+     * 获取指定模型的思考档位（off|low|medium|high），未配置返回 off
+     * @param string|array $models 模型列表设置（JSON 字符串或旧格式）
+     * @param string $modelName 模型 ID
+     * @return string
+     */
+    public static function AIBotModelThinking($models, $modelName)
+    {
+        $modelName = trim((string)$modelName);
+        if ($modelName === '') {
+            return 'off';
+        }
+        foreach (self::AIBotModels2Array($models) as $item) {
+            if ($item['value'] === $modelName) {
+                return $item['thinking'] ?? 'off';
+            }
+        }
+        return 'off';
+    }
+
     /**
      * 规范自定义微应用配置
      * @param array $list
@@ -297,18 +358,25 @@ class Setting extends AbstractModel
     /**
      * 将存储结构转换成 appstore 接口同款格式
      * @param array $apps
+     * @param bool $keepVisible 是否保留可见范围（仅管理员编辑场景需要，用于回填）
      * @return array
      */
-    public static function formatCustomMicroAppsForResponse(array $apps)
+    public static function formatCustomMicroAppsForResponse(array $apps, bool $keepVisible = false)
     {
-        return array_values(array_map(function ($app) {
+        return array_values(array_map(function ($app) use ($keepVisible) {
+            if ($keepVisible) {
+                $app['visible_to'] = self::normalizeCustomMicroVisible($app['visible_to'] ?? ['admin']);
+            } else {
                 unset($app['visible_to']);
+            }
             if (!empty($app['menu_items']) && is_array($app['menu_items'])) {
                 $app['menu_items'] = array_values(array_map(function ($menu) {
                     $menu['keep_alive'] = isset($menu['keep_alive']) ? (bool)$menu['keep_alive'] : true;
                     $menu['disable_scope_css'] = (bool)($menu['disable_scope_css'] ?? false);
                     $menu['auto_dark_theme'] = isset($menu['auto_dark_theme']) ? (bool)$menu['auto_dark_theme'] : true;
                     $menu['transparent'] = (bool)($menu['transparent'] ?? false);
+                    $menu['key'] = isset($menu['key']) ? (string)$menu['key'] : '';
+                    $menu['badge_clear_on_open'] = (bool)($menu['badge_clear_on_open'] ?? false);
                     if (isset($menu['visible_to'])) {
                         unset($menu['visible_to']);
                     }
@@ -398,6 +466,9 @@ class Setting extends AbstractModel
         if (!empty($menu['capsule']) && is_array($menu['capsule'])) {
             $payload['capsule'] = Base::newTrim($menu['capsule']);
         }
+        // 角标：菜单稳定标识 与 打开时是否自动清零
+        $payload['key'] = Base::newTrim($menu['key'] ?? '');
+        $payload['badge_clear_on_open'] = (bool)($menu['badge_clear_on_open'] ?? false);
         return $payload;
     }
 
@@ -406,7 +477,7 @@ class Setting extends AbstractModel
      * @param mixed $value
      * @return array
      */
-    protected static function normalizeCustomMicroVisible($value)
+    public static function normalizeCustomMicroVisible($value)
     {
         if (is_array($value)) {
             $list = array_filter(array_map('trim', $value));
@@ -429,7 +500,7 @@ class Setting extends AbstractModel
      * @param int $userId
      * @return bool
      */
-    protected static function isCustomMicroVisibleTo(array $visible, bool $isAdmin, int $userId)
+    public static function isCustomMicroVisibleTo(array $visible, bool $isAdmin, int $userId)
     {
         if (in_array('all', $visible)) {
             return true;

app/Models/User.php

@@ -305,12 +305,12 @@ class User extends AbstractModel
         if ($onlyUserid && $onlyUserid != $this->userid) {
             return;
         }
-        if (env("PASSWORD_ADMIN") == 'disabled') {
+        if (config('dootask.password_admin') == 'disabled') {
             if ($this->userid == 1) {
                 throw new ApiException('当前环境禁止此操作');
             }
         }
-        if (env("PASSWORD_OWNER") == 'disabled') {
+        if (config('dootask.password_owner') == 'disabled') {
             throw new ApiException('当前环境禁止此操作');
         }
     }
@@ -394,6 +394,10 @@ class User extends AbstractModel
         }
         // 密码
         self::passwordPolicy($password);
+        // license
+        if ($err = Doo::licenseBindingError(Doo::license())) {
+            throw new ApiException($err);
+        }
         // 开始注册
         $user = Doo::userCreate($email, $password);
         if ($other) {
@@ -961,6 +965,8 @@ class User extends AbstractModel
                 return url("images/avatar/default_ollama.png");
             case 'ai-zhipu@bot.system':
                 return url("images/avatar/default_zhipu.png");
+            case 'ai-dooai@bot.system':
+                return url("images/avatar/default_dooai.png");
             case 'bot-manager@bot.system':
                 return url("images/avatar/default_bot.png");
             case 'meeting-alert@bot.system':

app/Models/UserBot.php

@@ -164,6 +164,7 @@ class UserBot extends AbstractModel
             'ai-zhipu' => '智谱清言',
             'ai-qianwen' => '通义千问',
             'ai-wenxin' => '文心一言',
+            'ai-dooai' => 'Doo AI',
             'bot-manager' => '机器人管理',
             'meeting-alert' => '会议通知',
             'okr-alert' => 'OKR提醒',
@@ -272,8 +273,11 @@ class UserBot extends AbstractModel
                     if ($match[1] === "ai-") {
                         $aibotSetting = Base::setting('aibotSetting');
                         $aibotModel = $aibotSetting[$match[2] . '_model'];
-                        $aibotModels = Setting::AIBotModels2Array($aibotSetting[$match[2] . '_models']);
+                        $aibotModels = Setting::AIBotModels2Array($aibotSetting[$match[2] . '_models'], false, true);
                         if ($aibotModels) {
+                            if (!in_array($aibotModel, array_column($aibotModels, 'value'), true)) {
+                                $aibotModel = $aibotModels[0]['value'];
+                            }
                             $menus = array_merge(
                                 [
                                     [

app/Models/UserDepartment.php

@@ -33,6 +33,7 @@ use Request;
  * @method static \Illuminate\Database\Eloquent\Builder|UserDepartment whereOwnerUserid($value)
  * @method static \Illuminate\Database\Eloquent\Builder|UserDepartment whereParentId($value)
  * @method static \Illuminate\Database\Eloquent\Builder|UserDepartment whereUpdatedAt($value)
+ * @property-read array $deputy_userids
  * @mixin \Eloquent
  */
 class UserDepartment extends AbstractModel
@@ -560,7 +561,7 @@ class UserDepartment extends AbstractModel
             'own_project_ids' => [],
             'own_project_id_map' => [],
         ];
-        if ($ids === null || $ids === '' || Base::settingFind('system', 'department_owner_project_view', 'close') !== 'open') {
+        if ($ids === null || $ids === '' || Base::settingFind('system', 'department_owner_project_view', 'open') !== 'open') {
             return $empty;
         }
         $memberUserids = self::getManagedMemberUserids($user->userid, $ids);
@@ -652,7 +653,7 @@ class UserDepartment extends AbstractModel
             return $result;
         }
         // 部门负责人只读视角
-        if (Base::settingFind('system', 'department_owner_project_view', 'close') !== 'open') {
+        if (Base::settingFind('system', 'department_owner_project_view', 'open') !== 'open') {
             return $result;
         }
         $memberUserids = self::getManagedMemberUserids($viewer->userid, 'all');

app/Models/UserEmailVerification.php

@@ -7,8 +7,9 @@ use App\Module\Base;
 use App\Module\Doo;
 use App\Module\Timer;
 use Carbon\Carbon;
-use Guanguans\Notify\Factory;
+use Symfony\Component\Mailer\Mailer;
-use Guanguans\Notify\Messages\EmailMessage;
+use Symfony\Component\Mailer\Transport;
+use Symfony\Component\Mime\Email;
 
 /**
  * App\Models\UserEmailVerification
@@ -97,16 +98,14 @@ class UserEmailVerification extends AbstractModel
                     );
                     break;
             }
-            Factory::mailer()
+            $mailer = new Mailer(Transport::fromDsn("smtp://{$setting['account']}:{$setting['password']}@{$setting['smtp_server']}:{$setting['port']}?verify_peer=0"));
-                ->setDsn("smtp://{$setting['account']}:{$setting['password']}@{$setting['smtp_server']}:{$setting['port']}?verify_peer=0")
+            $mailer->send((new Email())
-                ->setMessage(EmailMessage::create()
                 ->from($alias . " <{$setting['account']}>")
                 ->to($email)
                 ->subject($subject)
-                    ->html($content))
+                ->html($content));
-                ->send();
         } catch (\Throwable $e) {
-            if (str_contains($e->getMessage(), "Timed Out")) {
+            if (stripos($e->getMessage(), "timed out") !== false) {
                 throw new ApiException("邮件发送超时，请检查邮箱配置是否正确");
             } elseif ($e->getCode() === 550) {
                 throw new ApiException('邮件内容被拒绝，请检查邮箱是否开启接收功能');

app/Models/UserRecentItem.php

@@ -57,8 +57,8 @@ class UserRecentItem extends AbstractModel
         'browsed_at',
     ];
 
-    protected $dates = [
+    protected $casts = [
-        'browsed_at',
+        'browsed_at' => 'datetime',
     ];
 
     public static function record(int $userid, string $targetType, int $targetId, string $sourceType = '', int $sourceId = 0): self

app/Models/UserTaskBrowse.php

@@ -40,8 +40,8 @@ class UserTaskBrowse extends AbstractModel
         'browsed_at',
     ];
 
-    protected $dates = [
+    protected $casts = [
-        'browsed_at',
+        'browsed_at' => 'datetime',
     ];
 
     /**

app/Models/UserTransfer.php

@@ -5,8 +5,6 @@ namespace App\Models;
 use App\Exceptions\ApiException;
 use App\Module\Base;
 use Carbon\Carbon;
-use Guanguans\Notify\Factory;
-use Guanguans\Notify\Messages\EmailMessage;
 
 /**
  * App\Models\UserTransfer

app/Models/WebSocketDialog.php

@@ -56,6 +56,7 @@ use Illuminate\Support\Facades\DB;
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialog whereUpdatedAt($value)
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialog withTrashed()
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialog withoutTrashed()
+ * @property-read array $deputy_ids
  * @mixin \Eloquent
  */
 class WebSocketDialog extends AbstractModel
@@ -1099,6 +1100,46 @@ class WebSocketDialog extends AbstractModel
         });
     }
 
+    /**
+     * 与 sendMsgFiles 同链路，但接收已落盘的本地文件（分片合并产物），跳过 Base::upload。
+     *
+     * @param User       $user
+     * @param int[]      $dialogIds
+     * @param string     $localPath     已落盘绝对路径
+     * @param string     $originalName  原始文件名
+     * @param int        $replyId
+     * @param bool       $imageAttachment 任务群组中图片是否也作为附件保存
+     * @return array
+     */
+    public static function sendMsgFilesFromPath($user, $dialogIds, string $localPath, string $originalName, int $replyId = 0, bool $imageAttachment = false)
+    {
+        $first = null;
+        $fileName = $originalName;
+        $resolve = function ($path) use (&$first, &$fileName, $localPath, $originalName) {
+            if ($first !== null) {
+                return self::copyFileDataTo($first, $path);
+            }
+            $setting = Base::setting("system");
+            $data = Base::uploadFromPath([
+                "path_local" => $localPath,
+                "name" => $originalName,
+                "type" => 'more',
+                "path" => $path,
+                "fileName" => $fileName,
+                "quality" => true,
+                "convertVideo" => $setting['convert_video'] === 'open',
+                "compressVideo" => $setting['compress_video'] === 'open',
+            ]);
+            if (Base::isError($data)) {
+                throw new ApiException($data['msg']);
+            }
+            $first = $data['data'];
+            $fileName = $first['name'];
+            return $first;
+        };
+        return self::dispatchFileMessages($user, $dialogIds, $replyId, $imageAttachment, $resolve);
+    }
+
     /**
      * 发送消息文件
      *
@@ -1113,24 +1154,18 @@ class WebSocketDialog extends AbstractModel
      */
     public static function sendMsgFiles($user, $dialogIds, $files, $image64, $fileName, $replyId, $imageAttachment)
     {
-        $filePath = '';
+        $first = null;
-        $result = [];
+        $resolve = function ($path) use (&$first, &$fileName, $files, $image64) {
-        $data = [];
+            if ($first !== null) {
-        foreach ($dialogIds as $dialog_id) {
+                return self::copyFileDataTo($first, $path);
-            $dialog = WebSocketDialog::checkDialog($dialog_id);
+            }
-
-            $action = $replyId > 0 ? "reply-$replyId" : "";
-            $path = "uploads/chat/" . date("Ym") . "/" . $dialog_id . "/";
             if ($image64) {
                 $data = Base::image64save([
                     "image64" => $image64,
                     "path" => $path,
                     "fileName" => $fileName,
-                    "quality" => true
+                    "quality" => true,
                 ]);
-            } else if ($filePath) {
-                Base::makeDir(public_path($path));
-                copy($filePath, public_path($path) . basename($filePath));
             } else {
                 $setting = Base::setting("system");
                 $data = Base::upload([
@@ -1146,19 +1181,41 @@ class WebSocketDialog extends AbstractModel
             if (Base::isError($data)) {
                 throw new ApiException($data['msg']);
             }
-            $fileData = $data['data'];
+            $first = $data['data'];
-            $filePath = $fileData['file'];
+            $fileName = $first['name'];
-            $fileName = $fileData['name'];
+            return $first;
-            $fileData['thumb'] = Base::unFillUrl($fileData['thumb']);
+        };
-            $fileData['size'] *= 1024;
+        return self::dispatchFileMessages($user, $dialogIds, $replyId, $imageAttachment, $resolve);
+    }
 
-            // 任务群组保存文件
+    /**
+     * 遍历多个 dialog 发送文件消息：每个 dialog 取一份 fileData → 任务群组建附件 → sendMsg。
+     * 取 fileData 的策略由 $resolve(path) 决定（首次 upload，后续 copy）。
+     *
+     * @param User     $user
+     * @param int[]    $dialogIds
+     * @param int      $replyId
+     * @param bool     $imageAttachment
+     * @param callable $resolve fn(string $path): array  返回该 dialog 的 fileData
+     * @return array sendMsg 的最终返回（最后一个 dialog 的结果）
+     */
+    private static function dispatchFileMessages($user, array $dialogIds, int $replyId, bool $imageAttachment, callable $resolve): array
+    {
+        $result = [];
+        foreach ($dialogIds as $dialog_id) {
+            $dialog = WebSocketDialog::checkDialog($dialog_id);
+            $action = $replyId > 0 ? "reply-$replyId" : "";
+            $path = "uploads/chat/" . date("Ym") . "/" . $dialog_id . "/";
+            $fileData = $resolve($path);
+            $fileData['thumb'] = Base::unFillUrl($fileData['thumb'] ?? '');
+            $fileData['size'] *= 1024;
+            $task = null;
             if ($dialog->group_type === 'task') {
-                // 如果是图片不保存
+                // 图片消息默认不作为任务附件存档，除非显式 $imageAttachment
                 if ($imageAttachment || !in_array($fileData['ext'], File::imageExt)) {
                     $task = ProjectTask::whereDialogId($dialog->id)->first();
                     if ($task) {
-                        $file = ProjectTaskFile::createInstance([
+                        ProjectTaskFile::createInstance([
                             'project_id' => $task->project_id,
                             'task_id' => $task->id,
                             'name' => $fileData['name'],
@@ -1167,20 +1224,30 @@ class WebSocketDialog extends AbstractModel
                             'path' => $fileData['path'],
                             'thumb' => $fileData['thumb'],
                             'userid' => $user->userid,
-                        ]);
+                        ])->save();
-                        $file->save();
                     }
                 }
             }
-
-            // 发送消息
             $result = WebSocketDialogMsg::sendMsg($action, $dialog_id, 'file', $fileData, $user->userid);
-            if (Base::isSuccess($result)) {
+            if (Base::isSuccess($result) && $task) {
-                if (isset($task)) {
                 $result['data']['task_id'] = $task->id;
             }
         }
-        }
         return $result;
     }
+
+    /**
+     * 把首个 dialog 上传得到的物理文件 copy 到后续 dialog 的目录，返回更新后的 fileData。
+     */
+    private static function copyFileDataTo(array $first, string $path): array
+    {
+        Base::makeDir(public_path($path));
+        $target = public_path($path) . basename($first['file']);
+        copy($first['file'], $target);
+        $copy = $first;
+        $copy['file'] = $target;
+        $copy['path'] = $path . basename($first['file']);
+        $copy['url'] = Base::fillUrl($copy['path']);
+        return $copy;
+    }
 }

app/Models/WebSocketDialogMsgTodo.php

@@ -27,6 +27,10 @@ use Carbon\Carbon;
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialogMsgTodo whereId($value)
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialogMsgTodo whereMsgId($value)
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialogMsgTodo whereUserid($value)
+ * @property \Illuminate\Support\Carbon|null $remind_at 提醒时间
+ * @property \Illuminate\Support\Carbon|null $reminded_at 已提醒时间
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|WebSocketDialogMsgTodo whereRemindAt($value)
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|WebSocketDialogMsgTodo whereRemindedAt($value)
  * @mixin \Eloquent
  */
 class WebSocketDialogMsgTodo extends AbstractModel

app/Models/WebSocketDialogUser.php

@@ -43,6 +43,8 @@ namespace App\Models;
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialogUser whereTopAt($value)
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialogUser whereUpdatedAt($value)
  * @method static \Illuminate\Database\Eloquent\Builder|WebSocketDialogUser whereUserid($value)
+ * @property int $role 0=普通成员 1=群主 2=群管理员
+ * @method static \Illuminate\Database\Eloquent\Builder<static>|WebSocketDialogUser whereRole($value)
  * @mixin \Eloquent
  */
 class WebSocketDialogUser extends AbstractModel

app/Module/AI.php

@@ -21,7 +21,8 @@ class AI
         'ollama',
         'zhipu',
         'qianwen',
-        'wenxin'
+        'wenxin',
+        'dooai'
     ];
     protected const OPENAI_DEFAULT_MODEL = 'gpt-5.1-mini';
 
@@ -140,7 +141,31 @@ class AI
      * @param mixed $contextInput
      * @return array
      */
-    public static function createStreamKey($modelType, $modelName, $contextInput = [])
+    /**
+     * 判定当前用户是否启用 ai-kb RAG（灰度判定）
+     *
+     * 规则（参考 config/ai.php）：
+     *   - 总开关 rag_enabled=false → 关闭所有（kill switch）
+     *   - rag_canary_userids 为空 → 全员启用
+     *   - 否则仅白名单 userid 启用
+     */
+    public static function ragEnabledFor(int $userid): bool
+    {
+        if (!config('ai.rag_enabled', true)) {
+            return false;
+        }
+        $raw = trim((string) config('ai.rag_canary_userids', ''));
+        if ($raw === '') {
+            return true;
+        }
+        $allow = array_filter(array_map(
+            fn($v) => (int) trim($v),
+            explode(',', $raw)
+        ), fn($v) => $v > 0);
+        return in_array($userid, $allow, true);
+    }
+
+    public static function createStreamKey($modelType, $modelName, $contextInput = [], $locale = 'zh', $ragEnabled = true, $contextKey = '', $fd = 0)
     {
         $modelType = trim((string)$modelType);
         $modelName = trim((string)$modelName);
@@ -221,6 +246,14 @@ class AI
             'model_type' => $remoteModelType,
             'model_name' => $modelName,
             'context' => $contextJson,
+            'locale' => $locale,
+            // ai-kb 灰度透传：1 启用 RAG（hint + search_help_docs tool），0 关闭
+            'rag_enabled' => $ragEnabled ? '1' : '0',
+            // 前端会话ID，AI 服务存为 context_key 用于检索打点关联
+            'context_key' => mb_substr(trim((string)$contextKey), 0, 100),
+            // AI 助手路径启用 doo 执行工具；fd 为用户当前 WebSocket 连接（页面操作用，0 表示无）
+            'doo_enabled' => '1',
+            'fd' => intval($fd),
         ];
 
         $baseUrl = trim((string)($setting[$modelType . '_base_url'] ?? ''));
@@ -867,7 +900,84 @@ class AI
     }
 
     /**
-     * 通过 OpenAI 兼容接口获取文本的 Embedding 向量
+     * 调用 ai 插件的 /embeddings 端点批量向量化（免费向量模型，零配置）。
+     *
+     * 走主程序 ↔ ai 插件的内网调用，共享主程序 APP_KEY 鉴权；
+     * 向量维度由 ai 插件的模型决定，主程序不再传 dimensions。
+     *
+     * @param array $texts 文本数组
+     * @return array retSuccess(data=向量数组的数组，与输入同序，缺失位置为 []) / retError
+     */
+    protected static function requestPluginEmbeddings(array $texts)
+    {
+        $texts = array_values($texts);
+        $count = count($texts);
+        if ($count === 0) {
+            return Base::retSuccess("success", []);
+        }
+
+        $post = json_encode(["input" => $texts]);
+        $headers = [
+            'Content-Type' => 'application/json',
+            'Authorization' => 'Bearer ' . (string) config('app.key'),
+        ];
+        $timeout = $count > 1 ? 120 : 30;
+
+        $res = Ihttp::ihttp_request(self::embeddingsUrl(), $post, $headers, $timeout);
+        if (Base::isError($res)) {
+            return Base::retError("Embedding 接口请求失败", $res);
+        }
+
+        $resData = Base::json2array($res['data']);
+
+        // 先识别端点的业务错误：Ihttp 对 401/500 等带响应体的状态同样返回成功标志，
+        // 必须按响应里的 code 字段判错，否则鉴权错配等故障只会报"格式错误"难以定位
+        $resCode = intval($resData['code'] ?? 0);
+        if ($resCode !== 0 && $resCode !== 200) {
+            return Base::retError("Embedding 接口错误 [{$resCode}]: " . ($resData['error'] ?? 'unknown'), $resData);
+        }
+
+        if (empty($resData['data']) || !is_array($resData['data'])) {
+            return Base::retError("Embedding 接口返回数据格式错误", $resData);
+        }
+
+        // 记录当前实际生效的向量模型（查询缓存键与模型变化检测依赖它）
+        $model = (string) ($resData['model'] ?? '');
+        if ($model !== '' && Cache::get('ai:embedding_model') !== $model) {
+            Cache::forever('ai:embedding_model', $model);
+        }
+
+        // 按 index 回填，保证与输入顺序对齐，缺失位置留 []
+        $vectors = array_fill(0, $count, []);
+        foreach ($resData['data'] as $item) {
+            $idx = $item['index'] ?? null;
+            if ($idx === null || !isset($vectors[$idx])) {
+                continue;
+            }
+            $embedding = $item['embedding'] ?? [];
+            if (is_array($embedding) && !empty($embedding)) {
+                $vectors[$idx] = $embedding;
+            }
+        }
+
+        return Base::retSuccess("success", $vectors);
+    }
+
+    /**
+     * ai 插件 /embeddings 端点地址
+     *
+     * 查询侧（本类）与 Manticore 表定义（ManticoreBase::vectorColumnDDL）共用的唯一来源，
+     * 两侧必须指向同一端点，否则查询向量与存量向量来自不同模型导致语义搜索错乱。
+     */
+    public static function embeddingsUrl(): string
+    {
+        $host = config('dootask.ai_host', 'ai');
+        $port = (int) config('dootask.ai_port', 5001);
+        return "http://{$host}:{$port}/embeddings";
+    }
+
+    /**
+     * 通过 ai 插件的免费向量模型获取文本的 Embedding 向量
      *
      * @param string $text 需要转换的文本
      * @param bool $noCache 是否禁用缓存
@@ -883,50 +993,24 @@ class AI
             return Base::retError('文本内容不能为空');
         }
 
-        // 截断过长的文本（OpenAI 限制 8191 tokens，约 32K 字符）
+        // 截断过长的文本（约 32K 字符）
         $text = mb_substr($text, 0, 30000);
 
-        $cacheKey = "openAIEmbedding::" . md5($text);
+        // 缓存键带上当前生效的模型标识：切换向量模型后旧查询缓存自动失效，
+        // 避免最长 7 天内用旧模型向量去搜新模型索引（模型未知时为空串）
+        $model = (string) Cache::get('ai:embedding_model', '');
+        $cacheKey = "embeddingV2::" . md5($model . '|' . $text);
         if ($noCache) {
             Cache::forget($cacheKey);
         }
 
-        $provider = self::resolveEmbeddingProvider();
+        $result = Cache::remember($cacheKey, Carbon::now()->addDays(7), function () use ($text) {
-        if (!$provider) {
+            $res = self::requestPluginEmbeddings([$text]);
-            return Base::retError("请先在「AI 助手」设置中配置支持 Embedding 的 AI 服务");
-        }
-
-        $result = Cache::remember($cacheKey, Carbon::now()->addDays(7), function () use ($text, $provider) {
-            $payload = [
-                "model" => $provider['model'],
-                "input" => $text,
-            ];
-
-            // 统一向量维度为 1536（与 Manticore 配置一致）
-            // OpenAI、智谱等支持 dimensions 参数的厂商需要显式指定
-            $supportsDimensions = in_array($provider['vendor'], ['openai', 'zhipu']);
-            if ($supportsDimensions) {
-                $payload['dimensions'] = 1536;
-            }
-
-            $post = json_encode($payload);
-
-            $ai = new self($post);
-            $ai->setProvider($provider);
-            $ai->setUrlPath('/embeddings');
-            $ai->setTimeout(30);
-
-            $res = $ai->request(true);
             if (Base::isError($res)) {
-                return Base::retError("Embedding 请求失败", $res);
+                return $res;
             }
 
-            $resData = Base::json2array($res['data']);
+            $embedding = $res['data'][0] ?? [];
-            if (empty($resData['data'][0]['embedding'])) {
-                return Base::retError("Embedding 接口返回数据格式错误", $resData);
-            }
-
-            $embedding = $resData['data'][0]['embedding'];
             if (!is_array($embedding) || empty($embedding)) {
                 return Base::retError("Embedding 向量为空");
             }
@@ -940,193 +1024,4 @@ class AI
 
         return $result;
     }
-
-    /**
-     * 批量获取文本的 Embedding 向量
-     * OpenAI API 原生支持批量输入，一次请求处理多个文本
-     *
-     * @param array $texts 文本数组（最多 100 条）
-     * @param bool $noCache 是否禁用缓存
-     * @return array 返回结果，成功时 data 为向量数组的数组（与输入顺序对应）
-     */
-    public static function getBatchEmbeddings(array $texts, $noCache = false)
-    {
-        if (!Apps::isInstalled('ai')) {
-            return Base::retError('应用「AI Assistant」未安装');
-        }
-
-        if (empty($texts)) {
-            return Base::retSuccess("success", []);
-        }
-
-        // 限制批量大小
-        // OpenAI 限制：最多 2048 条，单次请求合计最多 300,000 tokens
-        // 这里限制 500 条，假设平均每条 500 tokens，合计 250,000 tokens
-        $texts = array_slice($texts, 0, 500);
-
-        // 准备结果数组，并检查缓存
-        $results = [];
-        $uncachedTexts = [];
-        $uncachedIndices = [];
-
-        foreach ($texts as $index => $text) {
-            if (empty($text)) {
-                $results[$index] = [];
-                continue;
-            }
-
-            // 截断过长的文本
-            $text = mb_substr($text, 0, 30000);
-            $texts[$index] = $text; // 更新截断后的文本
-
-            $cacheKey = "openAIEmbedding::" . md5($text);
-
-            if ($noCache) {
-                Cache::forget($cacheKey);
-            }
-
-            // 检查缓存
-            if (!$noCache && Cache::has($cacheKey)) {
-                $cached = Cache::get($cacheKey);
-                if (Base::isSuccess($cached)) {
-                    $results[$index] = $cached['data'];
-                    continue;
-                }
-            }
-
-            // 未命中缓存，加入待请求列表
-            $uncachedTexts[] = $text;
-            $uncachedIndices[] = $index;
-        }
-
-        // 如果所有文本都在缓存中
-        if (empty($uncachedTexts)) {
-            // 按原始顺序返回
-            ksort($results);
-            return Base::retSuccess("success", array_values($results));
-        }
-
-        // 获取 provider
-        $provider = self::resolveEmbeddingProvider();
-        if (!$provider) {
-            return Base::retError("请先在「AI 助手」设置中配置支持 Embedding 的 AI 服务");
-        }
-
-        // 构建批量请求
-        $payload = [
-            "model" => $provider['model'],
-            "input" => $uncachedTexts,
-        ];
-
-        $supportsDimensions = in_array($provider['vendor'], ['openai', 'zhipu']);
-        if ($supportsDimensions) {
-            $payload['dimensions'] = 1536;
-        }
-
-        $post = json_encode($payload);
-
-        $ai = new self($post);
-        $ai->setProvider($provider);
-        $ai->setUrlPath('/embeddings');
-        $ai->setTimeout(120); // 批量请求需要更长超时
-
-        $res = $ai->request(true);
-        if (Base::isError($res)) {
-            return Base::retError("批量 Embedding 请求失败", $res);
-        }
-
-        $resData = Base::json2array($res['data']);
-        if (empty($resData['data'])) {
-            return Base::retError("Embedding 接口返回数据格式错误", $resData);
-        }
-
-        // 处理返回的向量并写入缓存
-        foreach ($resData['data'] as $item) {
-            $itemIndex = $item['index'] ?? null;
-            if ($itemIndex === null || !isset($uncachedIndices[$itemIndex])) {
-                continue;
-            }
-
-            $originalIndex = $uncachedIndices[$itemIndex];
-            $embedding = $item['embedding'] ?? [];
-
-            if (!empty($embedding) && is_array($embedding)) {
-                $results[$originalIndex] = $embedding;
-            } else {
-                $results[$originalIndex] = [];
-            }
-        }
-
-        // 填充未获取到向量的位置
-        foreach ($uncachedIndices as $originalIndex) {
-            if (!isset($results[$originalIndex])) {
-                $results[$originalIndex] = [];
-            }
-        }
-
-        // 按原始顺序返回
-        ksort($results);
-        return Base::retSuccess("success", array_values($results));
-    }
-
-    /**
-     * 获取 Embedding 模型配置
-     *
-     * @return array|null
-     */
-    protected static function resolveEmbeddingProvider()
-    {
-        $setting = Base::setting('aibotSetting');
-        if (!is_array($setting)) {
-            $setting = [];
-        }
-
-        // 优先使用 OpenAI（支持 embedding 接口）
-        $key = trim((string)($setting['openai_key'] ?? ''));
-        if ($key !== '') {
-            $baseUrl = trim((string)($setting['openai_base_url'] ?? ''));
-            $baseUrl = $baseUrl ?: 'https://api.openai.com/v1';
-            $agency = trim((string)($setting['openai_agency'] ?? ''));
-
-            return [
-                'vendor' => 'openai',
-                'model' => 'text-embedding-3-small',
-                'api_key' => $key,
-                'base_url' => rtrim($baseUrl, '/'),
-                'agency' => $agency,
-            ];
-        }
-
-        $vendorDefaults = [
-            'deepseek' => [
-                'base_url' => 'https://api.deepseek.com',
-                'model' => 'deepseek-embedding',
-            ],
-            'zhipu' => [
-                'base_url' => 'https://open.bigmodel.cn/api/paas/v4',
-                'model' => 'embedding-3',
-            ],
-        ];
-
-        // 尝试其他支持 embedding 的服务（如 deepseek、zhipu、qianwen 等）
-        foreach ($vendorDefaults as $vendor => $defaults) {
-            $key = trim((string)($setting[$vendor . '_key'] ?? ''));
-
-            if ($key !== '') {
-                $baseUrl = trim((string)($setting[$vendor . '_base_url'] ?? ''));
-                $baseUrl = $baseUrl ?: $defaults['base_url'];  // 使用配置或默认值
-                $agency = trim((string)($setting[$vendor . '_agency'] ?? ''));
-
-                return [
-                    'vendor' => $vendor,
-                    'model' => $defaults['model'],
-                    'api_key' => $key,
-                    'base_url' => rtrim($baseUrl, '/'),
-                    'agency' => $agency,
-                ];
-            }
-        }
-
-        return null;
-    }
 }

app/Module/Apps.php

@@ -3,6 +3,7 @@
 namespace App\Module;
 
 use App\Exceptions\ApiException;
+use App\Models\Setting;
 use App\Models\User;
 use App\Models\UserDepartment;
 use App\Services\RequestContext;
@@ -29,14 +30,7 @@ class Apps
             return (bool) RequestContext::get($key, false);
         }
 
-        $configFile = base_path('docker/appstore/config/' . $appId . '/config.yml');
+        return RequestContext::save($key, self::loadInstalledConfig($appId) !== null);
-        $installed = false;
-        if (file_exists($configFile)) {
-            $configData = Yaml::parseFile($configFile);
-            $installed = $configData['status'] === 'installed';
-        }
-
-        return RequestContext::save($key, $installed);
     }
 
     /**
@@ -62,6 +56,180 @@ class Apps
         }
     }
 
+    /**
+     * appstore 目录下的绝对路径（统一 docker/appstore 前缀）。
+     *
+     * @param string $relative 相对 docker/appstore 的路径
+     * @return string
+     */
+    private static function appstorePath(string $relative): string
+    {
+        return base_path('docker/appstore/' . ltrim($relative, '/'));
+    }
+
+    /**
+     * 读取并校验某应用的 appstore config.yml；仅当文件存在且 status=installed 时返回解析后的配置数组。
+     *
+     * @param string $appId
+     * @return array|null
+     */
+    private static function loadInstalledConfig(string $appId): ?array
+    {
+        $appId = trim($appId);
+        if ($appId === '' || $appId === 'appstore') {
+            return null;
+        }
+        $configFile = self::appstorePath("config/{$appId}/config.yml");
+        if (!file_exists($configFile)) {
+            return null;
+        }
+        $config = Yaml::parseFile($configFile);
+        if (!is_array($config) || ($config['status'] ?? '') !== 'installed') {
+            return null;
+        }
+        return $config;
+    }
+
+    /**
+     * 将单个 menu_items 项映射为角标用的菜单配置。
+     *
+     * @param array $menu
+     * @param mixed $visibleDefault 应用级默认可见范围
+     * @return array ['key'=>string,'visible'=>array,'badge_clear_on_open'=>bool]
+     */
+    private static function mapMenuItem(array $menu, $visibleDefault): array
+    {
+        return [
+            'key' => trim((string)($menu['key'] ?? '')),
+            'visible' => Setting::normalizeCustomMicroVisible($menu['visible_to'] ?? $visibleDefault),
+            'badge_clear_on_open' => (bool)($menu['badge_clear_on_open'] ?? false),
+        ];
+    }
+
+    /**
+     * 获取（必要时生成并持久化）应用的独立密钥 APP_SECRET。
+     *
+     * 与全局 APP_KEY 不同，APP_SECRET 每个已安装应用独立、唯一，持久化在应用自身的
+     * docker/appstore/config/{appid}/config.yml（与其它每应用安装参数同源），
+     * 由 appstore 安装链路按内置 compose 变量 APP_SECRET 注入插件容器。
+     * 此处主程序侧负责生成/持久化与校验；首次需要时若不存在则惰性生成，保证主程序可独立验证。
+     *
+     * @param string $appId 应用ID
+     * @return string 应用密钥；应用未安装或非插件应用时返回空字符串
+     */
+    public static function appSecret(string $appId): string
+    {
+        $appId = trim($appId);
+        $config = self::loadInstalledConfig($appId);
+        if ($config === null) {
+            return '';
+        }
+        $secret = trim((string)($config['app_secret'] ?? ''));
+        if ($secret !== '') {
+            return $secret;
+        }
+        // 首次需要时生成并持久化（按 appid 唯一）
+        $secret = Base::generatePassword(48);
+        $config['app_secret'] = $secret;
+        try {
+            file_put_contents(self::appstorePath("config/{$appId}/config.yml"), Yaml::dump($config, 4, 2));
+        } catch (\Throwable $e) {
+            info('[app_badge] persist app_secret fail', ['appid' => $appId, 'error' => $e->getMessage()]);
+            return '';
+        }
+        return $secret;
+    }
+
+    /**
+     * 解析应用的菜单角标配置（菜单 key 列表与各自的可见范围）。
+     *
+     * 同时覆盖两类应用：
+     *  - 插件应用：读取 docker/appstore/apps/{appid}/{version}/config.yml 的 menu_items
+     *  - 自定义微应用：读取 microapp_menu 设置
+     *
+     * @param string $appId 应用ID
+     * @return array|null ['source'=>'plugin'|'custom', 'menus'=>[['key'=>string,'visible'=>array,'badge_clear_on_open'=>bool], ...]]；应用不存在返回 null
+     */
+    public static function appMenuConfig(string $appId): ?array
+    {
+        $appId = trim($appId);
+        if ($appId === '') {
+            return null;
+        }
+        // 插件应用
+        $config = self::loadInstalledConfig($appId);
+        if ($config !== null) {
+            $version = trim((string)($config['install_version'] ?? ''));
+            return [
+                'source' => 'plugin',
+                'menus' => self::readPluginMenus($appId, $version),
+            ];
+        }
+        // 自定义微应用
+        $apps = Base::setting('microapp_menu');
+        if (is_array($apps)) {
+            foreach ($apps as $app) {
+                if (!is_array($app) || trim((string)($app['id'] ?? '')) !== $appId) {
+                    continue;
+                }
+                $appVisibleDefault = $app['visible_to'] ?? 'admin';
+                $menus = [];
+                foreach (($app['menu_items'] ?? []) as $menu) {
+                    if (!is_array($menu)) {
+                        continue;
+                    }
+                    $menus[] = self::mapMenuItem($menu, $appVisibleDefault);
+                }
+                return ['source' => 'custom', 'menus' => $menus];
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 读取插件包 config.yml 的菜单配置。
+     *
+     * @param string $appId
+     * @param string $version 已安装版本
+     * @return array
+     */
+    private static function readPluginMenus(string $appId, string $version): array
+    {
+        $paths = [];
+        if ($version !== '') {
+            $paths[] = self::appstorePath("apps/{$appId}/{$version}/config.yml");
+        }
+        $paths[] = self::appstorePath("apps/{$appId}/config.yml");
+        $pkg = null;
+        foreach ($paths as $p) {
+            if (file_exists($p) && is_readable($p)) {
+                try {
+                    $pkg = Yaml::parseFile($p);
+                } catch (\Throwable $e) {
+                    $pkg = null;
+                }
+                if (is_array($pkg)) {
+                    break;
+                }
+            }
+        }
+        $menus = [];
+        if (is_array($pkg) && !empty($pkg['menu_items']) && is_array($pkg['menu_items'])) {
+            $appVisibleDefault = $pkg['visible_to'] ?? 'all';
+            foreach ($pkg['menu_items'] as $menu) {
+                if (!is_array($menu)) {
+                    continue;
+                }
+                $menus[] = self::mapMenuItem($menu, $appVisibleDefault);
+            }
+        }
+        if (empty($menus)) {
+            // 读不到包配置（权限/缺失）时退化为单一默认菜单，仍可对第一个菜单设角标
+            $menus[] = ['key' => '', 'visible' => ['all'], 'badge_clear_on_open' => false];
+        }
+        return $menus;
+    }
+
     /**
      * Dispatch user lifecycle hook to appstore (user_onboard/user_offboard/user_update).
      *
@@ -72,7 +240,7 @@ class Apps
      */
     public static function dispatchUserHook(User $user, string $action, string $eventType = '', array $changedFields = []): void
     {
-        $appKey = env('APP_KEY', '');
+        $appKey = config('app.key') ?: '';
         if (empty($appKey)) {
             info('[appstore_hook] APP_KEY is empty, skip dispatchUserHook');
             return;

app/Module/Badge.php

@@ -0,0 +1,329 @@
+<?php
+
+namespace App\Module;
+
+use App\Exceptions\ApiException;
+use App\Models\AppBadge;
+use App\Models\Setting;
+use App\Models\User;
+use App\Tasks\PushTask;
+
+/**
+ * 插件 / 微应用菜单角标业务编排。
+ *
+ * 角标真值归插件（应用密钥写入），主程序仅作为存储与分发：
+ *  - 绝对设置/清除 app_badges 行（仅存非清除态）
+ *  - 通过 WebSocket（PushTask）向在线用户实时推送 appBadge 消息
+ *  - 提供初始同步所需的用户角标快照
+ */
+class Badge
+{
+    /**
+     * 设置角标（应用密钥鉴权场景）：校验密钥/菜单/可见性，绝对设置并实时推送。
+     *
+     * @param string $appId
+     * @param string $secret 请求携带的应用密钥
+     * @param mixed $userid 目标用户ID（单个或数组）
+     * @param string $menuKeyInput 请求中的 menu_key（可空，留空取第一个菜单）
+     * @param mixed $count 角标数字
+     * @param mixed $dot 是否红点
+     * @return array 响应数据
+     * @throws ApiException 参数/密钥/应用/菜单校验失败
+     */
+    public static function set(string $appId, string $secret, $userid, string $menuKeyInput, $count, $dot): array
+    {
+        if ($appId === '') {
+            throw new ApiException('参数错误');
+        }
+        if ($secret === '') {
+            throw new ApiException('密钥无效');
+        }
+        $expect = Apps::appSecret($appId);
+        if ($expect === '' || !hash_equals($expect, $secret)) {
+            throw new ApiException('密钥无效');
+        }
+        $menu = self::resolveAppMenu($appId, $menuKeyInput);
+        $menuKey = (string)($menu['key'] ?? '');
+        $userids = self::normalizeUserids($userid);
+        if (empty($userids)) {
+            throw new ApiException('参数错误');
+        }
+        // 仅保留对该应用菜单有可见权限的用户
+        $userids = self::filterVisibleUserids($menu, $userids);
+        if (empty($userids)) {
+            return ['appid' => $appId, 'menu_key' => $menuKey, 'affected' => 0];
+        }
+        $count = max(0, intval($count));
+        $dot = filter_var($dot, FILTER_VALIDATE_BOOLEAN);
+        self::applySet($appId, $menuKey, $userids, $count, $dot);
+        self::push($appId, $menuKey, $userids, $count, $dot);
+        return [
+            'appid' => $appId,
+            'menu_key' => $menuKey,
+            'count' => $count,
+            'dot' => $dot,
+            'affected' => count($userids),
+        ];
+    }
+
+    /**
+     * 清除指定用户在某应用某菜单的角标（用户 token 鉴权场景），并推送多端一致。
+     *
+     * @param int $userid 当前用户ID
+     * @param string $appId
+     * @param string $menuKeyInput 请求中的 menu_key（可空）
+     * @return array 响应数据
+     * @throws ApiException 参数/应用/菜单校验失败
+     */
+    public static function clearForUser(int $userid, string $appId, string $menuKeyInput): array
+    {
+        if ($userid <= 0) {
+            throw new ApiException('参数错误');
+        }
+        if ($appId === '') {
+            throw new ApiException('参数错误');
+        }
+        $menu = self::resolveAppMenu($appId, $menuKeyInput);
+        $menuKey = (string)($menu['key'] ?? '');
+        AppBadge::whereAppId($appId)->whereMenuKey($menuKey)->whereUserid($userid)->delete();
+        // 推送给该用户的所有在线端，保证多端一致
+        self::push($appId, $menuKey, [$userid], 0, false);
+        return [
+            'appid' => $appId,
+            'menu_key' => $menuKey,
+        ];
+    }
+
+    /**
+     * 解析应用菜单配置并定位目标菜单。
+     *
+     * @param string $appId
+     * @param string $menuKeyInput
+     * @return array 命中的菜单配置
+     * @throws ApiException 应用未安装或菜单不存在
+     */
+    private static function resolveAppMenu(string $appId, string $menuKeyInput): array
+    {
+        $config = Apps::appMenuConfig($appId);
+        if ($config === null) {
+            throw new ApiException('应用未安装');
+        }
+        $menu = self::resolveMenu($config['menus'], $menuKeyInput);
+        if ($menu === null) {
+            throw new ApiException('菜单不存在');
+        }
+        return $menu;
+    }
+
+    /**
+     * 归一化目标用户ID：单值/数组 -> 去重去零的整型数组。
+     *
+     * @param mixed $userid
+     * @return int[]
+     */
+    private static function normalizeUserids($userid): array
+    {
+        if (is_string($userid) || is_numeric($userid)) {
+            $userid = [$userid];
+        }
+        if (!is_array($userid)) {
+            return [];
+        }
+        return self::intIds($userid);
+    }
+
+    /**
+     * 数组 -> 去重去零的整型数组。
+     *
+     * @param array $ids
+     * @return int[]
+     */
+    private static function intIds(array $ids): array
+    {
+        return array_values(array_unique(array_filter(array_map('intval', $ids), fn($v) => $v > 0)));
+    }
+
+    /**
+     * 解析目标菜单：menu_key 为空时取第一个菜单；否则必须命中已声明的菜单 key。
+     *
+     * @param array $menus appMenuConfig 返回的 menus
+     * @param string $menuKey 请求中的 menu_key（可空）
+     * @return array|null 命中的菜单配置；非法 menu_key 返回 null
+     */
+    private static function resolveMenu(array $menus, string $menuKey): ?array
+    {
+        if ($menuKey === '') {
+            return $menus[0] ?? ['key' => '', 'visible' => ['all'], 'badge_clear_on_open' => false];
+        }
+        foreach ($menus as $menu) {
+            if (($menu['key'] ?? '') === $menuKey) {
+                return $menu;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 按菜单可见范围过滤目标用户，仅保留对该应用菜单有权限的用户。
+     *
+     * @param array $menu 命中的菜单配置（含 visible）
+     * @param int[] $userids
+     * @return int[] 允许的用户ID
+     */
+    private static function filterVisibleUserids(array $menu, array $userids): array
+    {
+        if (empty($userids)) {
+            return [];
+        }
+        $visible = $menu['visible'] ?? ['all'];
+        if (in_array('all', $visible)) {
+            return $userids;
+        }
+        $allowed = [];
+        $users = User::whereIn('userid', $userids)->get(['userid', 'identity']);
+        foreach ($users as $user) {
+            if (Setting::isCustomMicroVisibleTo($visible, $user->isAdmin(), (int)$user->userid)) {
+                $allowed[] = (int)$user->userid;
+            }
+        }
+        return $allowed;
+    }
+
+    /**
+     * 绝对设置角标（幂等）。count=0 且 dot=false 即清除（删行）。
+     *
+     * @param string $appId
+     * @param string $menuKey
+     * @param int[] $userids
+     * @param int $count
+     * @param bool $dot
+     * @return void
+     */
+    private static function applySet(string $appId, string $menuKey, array $userids, int $count, bool $dot): void
+    {
+        if (empty($userids)) {
+            return;
+        }
+        // 清除态：一条 whereIn 删除
+        if ($count === 0 && !$dot) {
+            AppBadge::whereAppId($appId)->whereMenuKey($menuKey)->whereIn('userid', $userids)->delete();
+            return;
+        }
+        // 非清除态：依赖唯一键 (app_id,menu_key,userid) 批量 upsert
+        $now = date('Y-m-d H:i:s');
+        $rows = array_map(fn($uid) => [
+            'app_id' => $appId,
+            'menu_key' => $menuKey,
+            'userid' => (int)$uid,
+            'count' => $count,
+            'dot' => $dot,
+            'updated_at' => $now,
+        ], $userids);
+        AppBadge::upsert($rows, ['app_id', 'menu_key', 'userid'], ['count', 'dot', 'updated_at']);
+    }
+
+    /**
+     * 清除某应用的全部角标（应用卸载时）。
+     *
+     * @param string $appId
+     * @return void
+     */
+    public static function clearByApp(string $appId): void
+    {
+        $appId = trim($appId);
+        if ($appId === '') {
+            return;
+        }
+        AppBadge::whereAppId($appId)->delete();
+    }
+
+    /**
+     * 清除某用户的全部角标（用户离职时）。
+     *
+     * @param int $userid
+     * @return void
+     */
+    public static function clearByUser(int $userid): void
+    {
+        if ($userid <= 0) {
+            return;
+        }
+        AppBadge::whereUserid($userid)->delete();
+    }
+
+    /**
+     * 获取用户当前全部角标快照，用于前端初始同步。
+     * 过滤掉应用已不存在（卸载 / 自定义微应用被删除）的行，避免父级聚合统计残留数据。
+     *
+     * @param int $userid
+     * @return array app_id => menu_key => ['count'=>int,'dot'=>bool]
+     */
+    public static function userBadges(int $userid): array
+    {
+        $map = [];
+        if ($userid <= 0) {
+            return $map;
+        }
+        $rows = AppBadge::whereUserid($userid)->get(['app_id', 'menu_key', 'count', 'dot']);
+        if ($rows->isEmpty()) {
+            return $map;
+        }
+        // 自定义微应用 id 集合一次性收，避免每行重复 foreach
+        $customIds = [];
+        $customApps = Base::setting('microapp_menu');
+        if (is_array($customApps)) {
+            foreach ($customApps as $app) {
+                if (is_array($app) && !empty($app['id'])) {
+                    $customIds[(string)$app['id']] = true;
+                }
+            }
+        }
+        // 按 app_id 缓存判定结果：插件应用走 Apps::isInstalled（单 yaml + 请求级缓存），
+        // 自定义微应用查 set，避免每行都读 yaml / 遍历 setting。
+        $exists = [];
+        foreach ($rows as $row) {
+            $appId = (string)$row->app_id;
+            if (!isset($exists[$appId])) {
+                $exists[$appId] = isset($customIds[$appId]) || Apps::isInstalled($appId);
+            }
+            if (!$exists[$appId]) {
+                continue;
+            }
+            $map[$appId][$row->menu_key] = [
+                'count' => (int)$row->count,
+                'dot' => (bool)$row->dot,
+            ];
+        }
+        return $map;
+    }
+
+    /**
+     * 向在线用户实时推送角标变更（仅投递，不补发离线）。
+     *
+     * @param string $appId
+     * @param string $menuKey
+     * @param int[] $userids
+     * @param int $count
+     * @param bool $dot
+     * @return void
+     */
+    public static function push(string $appId, string $menuKey, array $userids, int $count, bool $dot): void
+    {
+        $userids = self::intIds($userids);
+        if (empty($userids)) {
+            return;
+        }
+        PushTask::push([
+            'userid' => $userids,
+            'msg' => [
+                'type' => 'appBadge',
+                'data' => [
+                    'appid' => $appId,
+                    'menu_key' => $menuKey,
+                    'count' => $count,
+                    'dot' => $dot,
+                ],
+            ],
+        ], false);
+    }
+}

app/Module/Base.php

@@ -848,6 +848,13 @@ class Base
      */
     public static function getSchemeAndHost()
     {
+        // 优先用当前请求的协议+主机：getScheme() 会经 TrustProxies 采信 X-Forwarded-Proto，
+        // 从而正确识别 https；host 取自 Host 头（不信 X-Forwarded-Host，避免 Host 注入）
+        $request = request();
+        if ($request instanceof \Illuminate\Http\Request && $request->getHttpHost()) {
+            return $request->getSchemeAndHttpHost();
+        }
+        // 非请求上下文（Task/命令行等）的兜底
         $scheme = isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] == '443' ? 'https://' : 'http://';
         return $scheme.($_SERVER['HTTP_HOST'] ?? '');
     }
@@ -2067,8 +2074,20 @@ class Base
      */
     public static function upload($param)
     {
+        // 可选 key 默认值，下游直接访问不会 undefined index
+        $param += [
+            'chmod' => 0644,
+            'saveName' => null,
+            'scale' => null,
+            'size' => 0,
+            'fileName' => null,
+            'quality' => null,
+            'autoThumb' => null,
+            'convertVideo' => null,
+            'compressVideo' => null,
+        ];
         $file = $param['file'];
-        $chmod = $param['chmod'] ?: 0644;
+        $chmod = $param['chmod'];
         if (empty($file)) {
             return Base::retError("您没有选择要上传的文件");
         }
@@ -2123,6 +2142,9 @@ class Base
             $limitSize = intval($param['size']);
             if ($limitSize <= 0) {
                 $fileUploadLimit = intval(Base::settingFind('system', 'file_upload_limit', 0));
+                if ($fileUploadLimit <= 0) {
+                    $fileUploadLimit = 1024;
+                }
                 $limitSize = $fileUploadLimit * 1024;
             }
             try {
@@ -2310,6 +2332,27 @@ class Base
         }
     }
 
+    /**
+     * 把本地文件包装成 UploadedFile(test=true) 转给 Base::upload，复用全套上传逻辑。
+     * @param array $param path_local + name 为本方法特有，其余与 Base::upload 一致
+     */
+    public static function uploadFromPath(array $param)
+    {
+        $localPath = $param['path_local'] ?? '';
+        $name = $param['name'] ?? '';
+        if (!$localPath || !is_file($localPath)) {
+            return Base::retError('源文件不存在');
+        }
+        if (!$name) {
+            $name = basename($localPath);
+        }
+        unset($param['path_local'], $param['name']);
+        // test=true → UploadedFile::move 走 rename()，绕开 move_uploaded_file 的 is_uploaded_file 校验
+        $param['file'] = new \Illuminate\Http\UploadedFile($localPath, $name, null, null, true);
+        $param['fileName'] = $param['fileName'] ?? $name;
+        return self::upload($param);
+    }
+
     /**
      * 上传文件移动
      * @param array $uploadResult
@@ -2582,6 +2625,23 @@ class Base
         return $array;
     }
 
+    /**
+     * 创建 zip 压缩包并添加文件，条目名取文件 basename（等价旧 Madzipper::make()->add()->close()）
+     * @param string $zipPath 压缩包路径
+     * @param string|array $files 要添加的文件路径
+     */
+    public static function zipAddFiles($zipPath, $files)
+    {
+        $zip = new \ZipArchive();
+        if ($zip->open($zipPath, \ZipArchive::CREATE) !== true) {
+            throw new \RuntimeException("Unable to open zip file: " . $zipPath);
+        }
+        foreach ((array)$files as $file) {
+            $zip->addFile($file, basename($file));
+        }
+        $zip->close();
+    }
+
     /**
      * 获取中文字符拼音首字母
      * @param $str
@@ -2597,8 +2657,7 @@ class Base
             return '#';
         }
         if (!preg_match("/^[a-zA-Z]$/", $first)) {
-            $pinyin = new Pinyin();
+            $first = Pinyin::abbr($first, true)->join('');
-            $first = $pinyin->abbr($first, '', PINYIN_NAME);
         }
         return $first ? strtoupper($first) : '#';
     }
@@ -2616,8 +2675,7 @@ class Base
         }
         if (!preg_match("/^[a-zA-Z0-9_.]+$/", $str)) {
             $str = Cache::rememberForever("cn2pinyin:" . md5($str . '_' . $delim), function () use ($delim, $str) {
-                $pinyin = new Pinyin();
+                return Pinyin::permalink($str, $delim);
-                return $pinyin->permalink($str, $delim);
             });
         }
         return $str;

app/Module/ChunkUpload.php

@@ -0,0 +1,511 @@
+<?php
+
+namespace App\Module;
+
+use App\Exceptions\ApiException;
+use App\Models\File as FileModel;
+use App\Models\FileContent;
+use App\Models\User;
+use App\Models\WebSocketDialog;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Redis;
+
+/**
+ * 分片上传核心：状态机与磁盘/Redis 调度。
+ *
+ * 流程：start → receive × N → merge → (scene dispatcher) → cleanup
+ *
+ * Redis key:
+ *   upload:{upload_id}                  → JSON 元数据  (TTL 24h)
+ *   upload:{upload_id}:chunks           → SET 已收分片 index  (TTL 24h)
+ *   upload:hash:{userid}:{hash}         → upload_id 反查（续传 / 同 hash 复用） (TTL 24h)
+ *
+ * 磁盘：
+ *   uploads/tmp/chunks/{userid}/{upload_id}/{index}
+ */
+class ChunkUpload
+{
+    /** 单个分片大小（5MB）。注意：要小于 Swoole package_max_length 1G */
+    const CHUNK_SIZE = 5 * 1024 * 1024;
+
+    /** 状态/反查索引 TTL（秒）：24h */
+    const STATE_TTL = 86400;
+
+    /** 单文件硬上限（KB）：系统设置之外的兜底保护，10G */
+    const MAX_FILE_KB = 10 * 1024 * 1024;
+
+    /** 支持的 scene 枚举 */
+    const SCENES = ['file_cabinet', 'dialog_file', 'image', 'generic_file'];
+
+    /**
+     * 启动上传。
+     *   - 同用户同 hash 命中 files 表 → 秒传
+     *   - 同用户同 hash 命中 upload 反查 → 续传
+     *   - 否则新建 upload_id
+     *
+     * @param User $user
+     * @param array $param [hash, size(B), name, scene, scene_params(array)]
+     * @return array
+     */
+    public static function start(User $user, array $param): array
+    {
+        $hash = strtolower(trim($param['hash'] ?? ''));
+        $size = intval($param['size'] ?? 0);
+        $name = trim($param['name'] ?? '');
+        $scene = trim($param['scene'] ?? '');
+        $sceneParams = $param['scene_params'] ?? [];
+        if (!is_array($sceneParams)) {
+            $sceneParams = [];
+        }
+
+        if (strlen($hash) !== 32) {
+            return Base::retError('文件 hash 格式错误');
+        }
+        if ($size <= 0) {
+            return Base::retError('文件大小无效');
+        }
+        if (intval(ceil($size / 1024)) > self::MAX_FILE_KB) {
+            return Base::retError('文件超过系统支持的最大尺寸');
+        }
+        // init 时拦截系统配置上限，避免传完分片才在 merge 阶段被 Base::upload 拒绝
+        $fileUploadLimit = intval(Base::settingFind('system', 'file_upload_limit', 0));
+        if ($fileUploadLimit <= 0) {
+            $fileUploadLimit = 1024;
+        }
+        if ($size > $fileUploadLimit * 1024 * 1024) {
+            return Base::retError('文件大小超限，最大限制：' . $fileUploadLimit . 'MB');
+        }
+        if ($name === '') {
+            return Base::retError('文件名不能为空');
+        }
+        if (!in_array($scene, self::SCENES, true)) {
+            return Base::retError('不支持的上传场景');
+        }
+
+        // 1) 秒传：同用户已上传过同 hash 文件 → 直接复用入库
+        $hit = self::trySecondPass($user, $scene, $hash, $name, $sceneParams);
+        if ($hit !== null) {
+            return Base::retSuccess('success', $hit);
+        }
+
+        // 2) 续传：同用户同 hash 有未完成上传
+        $reuseKey = self::keyHashIndex($user->userid, $hash);
+        $existingId = Redis::get($reuseKey);
+        if ($existingId) {
+            $meta = self::loadMeta($existingId);
+            if ($meta && $meta['userid'] === $user->userid && $meta['hash'] === $hash) {
+                return Base::retSuccess('success', self::sessionView($existingId, $meta));
+            }
+            // 反查指向了已失效的 upload_id，清掉
+            Redis::del($reuseKey);
+        }
+
+        // 3) 新建
+        $uploadId = Base::generatePassword(32);
+        $chunkCount = intval(ceil($size / self::CHUNK_SIZE));
+        $meta = [
+            'hash' => $hash,
+            'size' => $size,
+            'name' => $name,
+            'scene' => $scene,
+            'scene_params' => $sceneParams,
+            'userid' => intval($user->userid),
+            'chunk_size' => self::CHUNK_SIZE,
+            'chunk_count' => $chunkCount,
+            'created_at' => time(),
+        ];
+        Redis::setex(self::keyMeta($uploadId), self::STATE_TTL, json_encode($meta, JSON_UNESCAPED_UNICODE));
+        Redis::setex($reuseKey, self::STATE_TTL, $uploadId);
+        Base::makeDir(self::chunkDir($user->userid, $uploadId));
+
+        return Base::retSuccess('success', self::sessionView($uploadId, $meta));
+    }
+
+    /**
+     * 接收一个分片。
+     *
+     * @param User $user
+     * @param string $uploadId
+     * @param int $index 分片序号（0-based）
+     * @param UploadedFile|null $blob
+     * @return array
+     */
+    public static function receive(User $user, string $uploadId, int $index, $blob): array
+    {
+        $meta = self::loadMeta($uploadId);
+        if (!$meta) {
+            return Base::retError('上传会话不存在或已过期');
+        }
+        if ($meta['userid'] !== intval($user->userid)) {
+            return Base::retError('上传会话归属错误');
+        }
+        if ($index < 0 || $index >= $meta['chunk_count']) {
+            return Base::retError('分片序号超出范围');
+        }
+        if (!$blob || !$blob->isValid()) {
+            return Base::retError('分片数据无效');
+        }
+        // 最后一片可能小于 CHUNK_SIZE，其余必须等于
+        $isLast = $index === $meta['chunk_count'] - 1;
+        $chunkSize = $blob->getSize();
+        if (!$isLast && $chunkSize !== self::CHUNK_SIZE) {
+            return Base::retError('分片大小不符合预期');
+        }
+        if ($isLast) {
+            $expectLast = $meta['size'] - self::CHUNK_SIZE * ($meta['chunk_count'] - 1);
+            if ($chunkSize !== $expectLast) {
+                return Base::retError('末尾分片大小不符合预期');
+            }
+        }
+        $dir = self::chunkDir($user->userid, $uploadId);
+        Base::makeDir($dir);
+        $blob->move($dir, (string)$index);
+        // 记录已收 + 续期三个相关 key
+        Redis::sadd(self::keyChunks($uploadId), $index);
+        Redis::expire(self::keyChunks($uploadId), self::STATE_TTL);
+        Redis::expire(self::keyMeta($uploadId), self::STATE_TTL);
+        Redis::expire(self::keyHashIndex($user->userid, $meta['hash']), self::STATE_TTL);
+
+        return Base::retSuccess('success', [
+            'upload_id' => $uploadId,
+            'received' => self::receivedList($uploadId),
+        ]);
+    }
+
+    /**
+     * 合并分片并入库。需要在 Lock 内调用。
+     *
+     * @param User $user
+     * @param string $uploadId
+     * @return array scene 入库返回结构（与 retSuccess/retError 对齐）
+     */
+    public static function merge(User $user, string $uploadId): array
+    {
+        $meta = self::loadMeta($uploadId);
+        if (!$meta) {
+            return Base::retError('上传会话不存在或已过期');
+        }
+        if ($meta['userid'] !== intval($user->userid)) {
+            return Base::retError('上传会话归属错误');
+        }
+        $received = self::receivedList($uploadId);
+        if (count($received) !== $meta['chunk_count']) {
+            return Base::retError('分片不完整，无法合并');
+        }
+
+        return Lock::withLock("upload:merge:{$uploadId}", function () use ($user, $uploadId, $meta) {
+            $dir = self::chunkDir($user->userid, $uploadId);
+            $mergedPath = $dir . '/merged.' . substr($meta['hash'], 0, 8);
+            $writeFp = @fopen($mergedPath, 'wb');
+            if (!$writeFp) {
+                return Base::retError('无法创建合并文件');
+            }
+            // 拼接与 md5 同步进行：一遍磁盘读完成"写文件 + 算 hash"
+            $hashCtx = hash_init('md5');
+            try {
+                for ($i = 0; $i < $meta['chunk_count']; $i++) {
+                    $partPath = $dir . '/' . $i;
+                    $readFp = @fopen($partPath, 'rb');
+                    if (!$readFp) {
+                        return Base::retError("分片读取失败：{$i}");
+                    }
+                    while (!feof($readFp)) {
+                        $buf = fread($readFp, 1024 * 1024);
+                        if ($buf === false) {
+                            fclose($readFp);
+                            return Base::retError("分片读取失败：{$i}");
+                        }
+                        fwrite($writeFp, $buf);
+                        hash_update($hashCtx, $buf);
+                    }
+                    fclose($readFp);
+                }
+            } finally {
+                fclose($writeFp);
+            }
+            $actualHash = hash_final($hashCtx);
+            if ($actualHash !== $meta['hash']) {
+                @unlink($mergedPath);
+                return Base::retError('文件校验失败，请重试');
+            }
+
+            // 调用 scene 入库
+            $result = self::dispatch($user, $meta, $mergedPath);
+
+            // 清理（无论成功失败都清，失败用户重新启 upload）
+            self::cleanup($user->userid, $uploadId, $meta['hash']);
+
+            return $result;
+        }, 60000, 60000);
+    }
+
+    /**
+     * 用户主动取消：校验归属后清理。会话不存在或归属错误一律静默成功，前端取消按钮不需要分支处理。
+     */
+    public static function cancelByUser(User $user, string $uploadId): void
+    {
+        $meta = self::loadMeta($uploadId);
+        if (!$meta || intval($meta['userid'] ?? 0) !== $user->userid) {
+            return;
+        }
+        self::cleanup($user->userid, $uploadId, $meta['hash'] ?? '');
+    }
+
+    /**
+     * 清理一个 upload_id 的所有状态。
+     */
+    public static function cleanup(int $userid, string $uploadId, string $hash = ''): void
+    {
+        Redis::del(self::keyMeta($uploadId));
+        Redis::del(self::keyChunks($uploadId));
+        if ($hash) {
+            Redis::del(self::keyHashIndex($userid, $hash));
+        }
+        $dir = self::chunkDir($userid, $uploadId);
+        if (is_dir($dir)) {
+            Base::deleteDirAndFile($dir);
+        }
+    }
+
+    // ===== scene dispatcher =====
+
+    /**
+     * 把合并后的本地文件交给对应 scene 入库。
+     * 返回结构对齐各 scene 老接口的 retSuccess。
+     */
+    protected static function dispatch(User $user, array $meta, string $mergedPath): array
+    {
+        $scene = $meta['scene'];
+        $name = $meta['name'];
+        $hash = $meta['hash'];
+        $params = $meta['scene_params'] ?? [];
+
+        switch ($scene) {
+            case 'file_cabinet':
+                $pid = intval($params['pid'] ?? 0);
+                $webkitRelativePath = strval($params['webkit_relative_path'] ?? $name);
+                $overwrite = boolval($params['overwrite'] ?? false);
+                // pid 锁避免与并发上传的 handleDuplicateName / 中间目录创建竞态
+                try {
+                    return Lock::withLock("file:upload:{$user->userid}:{$pid}", function () use ($user, $pid, $mergedPath, $name, $webkitRelativePath, $hash, $overwrite) {
+                        $result = (new FileModel)->contentUploadFromPath($user, $pid, $mergedPath, $name, $webkitRelativePath, $hash, $overwrite);
+                        $outName = $result['data']['name'] ?? $name;
+                        return Base::retSuccess($outName . ' 上传成功', $result['addItem']);
+                    }, 120000, 120000);
+                } catch (ApiException $e) {
+                    return Base::retError($e->getMessage());
+                } catch (\Exception $e) {
+                    if (str_contains($e->getMessage(), 'Failed to acquire lock')) {
+                        return Base::retError('上传繁忙，请稍后再试');
+                    }
+                    return Base::retError($e->getMessage());
+                }
+
+            case 'image':
+                // 头像 / 系统图片 / 编辑器粘贴图片，对齐 system/imgupload
+                $width = intval($params['width'] ?? 0);
+                $height = intval($params['height'] ?? 0);
+                $whcut = strval($params['whcut'] ?? 'percentage');
+                $whcut = match ($whcut) {
+                    '1' => 'cover',
+                    '0' => 'contain',
+                    'cover', 'contain' => $whcut,
+                    default => 'percentage',
+                };
+                $scale = [$width ?: 2160, $height ?: 4160, $whcut];
+                $imagePath = "uploads/user/picture/" . $user->userid . "/" . date("Ym") . "/";
+                $data = Base::uploadFromPath([
+                    "path_local" => $mergedPath,
+                    "name" => $name,
+                    "type" => 'image',
+                    "path" => $imagePath,
+                    "scale" => $scale,
+                    "quality" => true,
+                ]);
+                if (Base::isError($data)) {
+                    return $data;
+                }
+                return Base::retSuccess('success', $data['data']);
+
+            case 'generic_file':
+                // 编辑器粘贴文件 / 系统通用文件，对齐 system/fileupload
+                $filePath = "uploads/user/file/" . $user->userid . "/" . date("Ym") . "/";
+                $data = Base::uploadFromPath([
+                    "path_local" => $mergedPath,
+                    "name" => $name,
+                    "type" => 'file',
+                    "path" => $filePath,
+                    "quality" => true,
+                ]);
+                return $data;
+
+            case 'dialog_file':
+                // 聊天发文件 + 任务附件共用同一接入（任务附件本质是任务对话流的一条消息）
+                $dialogIds = $params['dialog_ids'] ?? [];
+                if (!is_array($dialogIds)) {
+                    $dialogIds = [$dialogIds];
+                }
+                $dialogIds = array_values(array_filter(array_map('intval', $dialogIds)));
+                if (empty($dialogIds)) {
+                    return Base::retError('dialog_ids 不能为空');
+                }
+                $replyId = intval($params['reply_id'] ?? 0);
+                $imageAttachment = boolval($params['image_attachment'] ?? false);
+                try {
+                    return WebSocketDialog::sendMsgFilesFromPath($user, $dialogIds, $mergedPath, $name, $replyId, $imageAttachment);
+                } catch (ApiException $e) {
+                    return Base::retError($e->getMessage());
+                }
+
+            default:
+                return Base::retError("scene 暂未实现：{$scene}");
+        }
+    }
+
+    /**
+     * 同 hash 命中则在目标位置复用源 FileContent 指向的物理文件，零字节传输。
+     * 未命中返回 null 让上层走真上传。
+     */
+    protected static function trySecondPass(User $user, string $scene, string $hash, string $name, array $sceneParams): ?array
+    {
+        if ($scene !== 'file_cabinet') {
+            return null;
+        }
+        $hit = FileModel::whereUserid($user->userid)->whereHash($hash)->whereNull('deleted_at')->first();
+        if (!$hit) {
+            return null;
+        }
+        $srcContent = FileContent::whereFid($hit->id)->orderByDesc('id')->first();
+        if (!$srcContent) {
+            return null;
+        }
+        $contentArr = is_array($srcContent->content)
+            ? $srcContent->content
+            : json_decode($srcContent->content, true);
+        if (empty($contentArr['url'])) {
+            return null;
+        }
+        $rawPid = intval($sceneParams['pid'] ?? 0);
+        $webkitRelativePath = strval($sceneParams['webkit_relative_path'] ?? $name);
+        $overwrite = boolval($sceneParams['overwrite'] ?? false);
+
+        try {
+            return Lock::withLock("file:upload:{$user->userid}:{$rawPid}", function () use ($user, $rawPid, $webkitRelativePath, $overwrite, $hit, $hash, $name, $contentArr) {
+                [$pid, $userid, $addItem] = (new FileModel)->contentUploadPrep($user, $rawPid, $webkitRelativePath);
+
+                $ext = $hit->ext;
+                $bareName = Base::rightDelete($name, '.' . $ext);
+                $existing = null;
+                if ($overwrite) {
+                    $existing = FileModel::wherePid($pid)->whereName($bareName)->whereExt($ext)->whereNull('deleted_at')->first();
+                }
+                if ($existing) {
+                    $existing->size = $hit->size;
+                    $existing->hash = $hash;
+                    $existing->type = $hit->type;
+                    if (!$existing->saveBeforePP()) {
+                        throw new ApiException('秒传保存失败');
+                    }
+                    FileContent::createInstance([
+                        'fid' => $existing->id,
+                        'content' => $contentArr,
+                        'text' => '',
+                        'size' => $existing->size,
+                        'userid' => $user->userid,
+                    ])->save();
+                    $created = FileModel::find($existing->id);
+                    $overwriteFlag = 1;
+                } else {
+                    $newFile = FileModel::createInstance([
+                        'pid' => $pid,
+                        'name' => $bareName,
+                        'type' => $hit->type,
+                        'ext' => $ext,
+                        'size' => $hit->size,
+                        'hash' => $hash,
+                        'userid' => $userid,
+                        'created_id' => $user->userid,
+                    ]);
+                    $newFile->handleDuplicateName();
+                    if (!$newFile->saveBeforePP()) {
+                        throw new ApiException('秒传保存失败');
+                    }
+                    FileContent::createInstance([
+                        'fid' => $newFile->id,
+                        'content' => $contentArr,
+                        'text' => '',
+                        'size' => $newFile->size,
+                        'userid' => $user->userid,
+                    ])->save();
+                    $created = FileModel::find($newFile->id);
+                    $overwriteFlag = 0;
+                }
+                $created->pushMsg($overwriteFlag ? 'update' : 'add', $created);
+                $data = FileModel::handleImageUrl($created->toArray());
+                $data['full_name'] = $name;
+                $data['overwrite'] = $overwriteFlag;
+                $addItem[] = $data;
+                return [
+                    'done' => true,
+                    'instant' => true,
+                    'addItem' => $addItem,
+                    'msg' => $name . ' 秒传成功',
+                ];
+            }, 120000, 120000);
+        } catch (\Throwable $_e) {
+            // 退化到真上传：错误由 dispatch 阶段权威报出，避免两条路径错误码不一致
+            return null;
+        }
+    }
+
+    // ===== helpers =====
+
+    protected static function keyMeta(string $uploadId): string
+    {
+        return "upload:{$uploadId}";
+    }
+
+    protected static function keyChunks(string $uploadId): string
+    {
+        return "upload:{$uploadId}:chunks";
+    }
+
+    protected static function keyHashIndex(int $userid, string $hash): string
+    {
+        return "upload:hash:{$userid}:{$hash}";
+    }
+
+    protected static function chunkDir(int $userid, string $uploadId): string
+    {
+        return public_path("uploads/tmp/chunks/{$userid}/{$uploadId}");
+    }
+
+    protected static function loadMeta(string $uploadId): ?array
+    {
+        $raw = Redis::get(self::keyMeta($uploadId));
+        if (!$raw) {
+            return null;
+        }
+        $data = json_decode($raw, true);
+        return is_array($data) ? $data : null;
+    }
+
+    protected static function receivedList(string $uploadId): array
+    {
+        $list = Redis::smembers(self::keyChunks($uploadId)) ?: [];
+        $list = array_map('intval', $list);
+        sort($list);
+        return $list;
+    }
+
+    protected static function sessionView(string $uploadId, array $meta): array
+    {
+        return [
+            'done' => false,
+            'upload_id' => $uploadId,
+            'chunk_size' => $meta['chunk_size'],
+            'chunk_count' => $meta['chunk_count'],
+            'received' => self::receivedList($uploadId),
+        ];
+    }
+}

app/Module/DashboardTeam.php

@@ -0,0 +1,538 @@
+<?php
+
+namespace App\Module;
+
+use App\Exceptions\ApiException;
+use App\Models\ProjectUser;
+use App\Models\Setting;
+use App\Models\User;
+use App\Models\UserDepartment;
+use Carbon\Carbon;
+use Illuminate\Database\Query\Builder;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * 仪表盘负责人视角数据聚合。
+ *
+ * 口径：所选管理部门（含下级部门）的在职成员所参与、且允许负责人查看的未归档项目；
+ * 仅统计主任务、全员可见任务，任务需由范围内成员负责或当前没有负责人。
+ */
+class DashboardTeam
+{
+    public const SOON_DAYS = 3;
+    public const HIGH_PRIORITY_COUNT = 2;
+    public const STATS_CACHE_SECONDS = 30;
+
+    /**
+     * 解析并校验负责人视角范围。
+     */
+    public static function context(User $user, $selectedDepartmentIds = null): array
+    {
+        if (Base::settingFind('system', 'department_owner_project_view', 'open') !== 'open') {
+            throw new ApiException('未开启部门负责人视角功能');
+        }
+
+        $managedIds = UserDepartment::getManagedDepartments($user->userid)
+            ->pluck('id')
+            ->map(fn($id) => intval($id))
+            ->values()
+            ->toArray();
+        if (empty($managedIds)) {
+            throw new ApiException('没有可查看的部门数据');
+        }
+
+        $selectedIds = self::normalizeSelectedDepartmentIds($selectedDepartmentIds, $managedIds);
+        if (empty($selectedIds)) {
+            throw new ApiException('没有可查看的部门数据');
+        }
+
+        $departmentIds = self::expandDepartmentIds($selectedIds);
+        $members = self::loadMembers($departmentIds);
+        $memberUserids = $members->pluck('userid')->map(fn($id) => intval($id))->values()->toArray();
+        $projectIds = self::loadProjectIds($memberUserids);
+        $ownProjectIds = empty($projectIds) ? [] : ProjectUser::whereUserid($user->userid)
+            ->whereIn('project_id', $projectIds)
+            ->pluck('project_id')
+            ->map(fn($id) => intval($id))
+            ->unique()
+            ->values()
+            ->toArray();
+
+        return [
+            'viewer_userid' => intval($user->userid),
+            'selected_department_ids' => $selectedIds,
+            'department_ids' => $departmentIds,
+            'member_userids' => $memberUserids,
+            'member_map' => $members->keyBy('userid')->map(fn(User $member) => [
+                'userid' => intval($member->userid),
+                'nickname' => $member->nickname,
+                'userimg' => $member->userimg,
+            ])->toArray(),
+            'project_ids' => $projectIds,
+            'own_project_id_map' => array_fill_keys($ownProjectIds, true),
+        ];
+    }
+
+    /**
+     * 团队统计。
+     */
+    public static function stats(array $context, bool $refresh = false): array
+    {
+        $cacheKey = 'dashboard:team:stats:v3:' . $context['viewer_userid'] . ':' . sha1(json_encode([
+            $context['selected_department_ids'],
+            $context['department_ids'],
+            $context['member_userids'],
+            $context['project_ids'],
+        ]));
+        if ($refresh) {
+            Cache::forget($cacheKey);
+        }
+
+        return Cache::remember($cacheKey, now()->addSeconds(self::STATS_CACHE_SECONDS), function () use ($context) {
+            $now = Carbon::now();
+            $taskAlias = DB::getTablePrefix() . 't';
+            $soonEnd = $now->clone()->addDays(self::SOON_DAYS)->endOfDay();
+            $weekStart = $now->clone()->startOfWeek(Carbon::MONDAY)->startOfDay();
+            $nextWeekStart = $weekStart->clone()->addWeek();
+            $lastWeekStart = $weekStart->clone()->subWeek();
+            $base = self::baseTaskBuilder($context);
+
+            $core = (clone $base)->selectRaw("
+                SUM(CASE WHEN {$taskAlias}.complete_at IS NULL THEN 1 ELSE 0 END) AS stat_uncompleted,
+                SUM(CASE WHEN {$taskAlias}.complete_at IS NULL AND {$taskAlias}.end_at IS NOT NULL AND {$taskAlias}.end_at < ? THEN 1 ELSE 0 END) AS stat_overdue,
+                SUM(CASE WHEN {$taskAlias}.complete_at IS NULL AND {$taskAlias}.end_at IS NOT NULL AND {$taskAlias}.end_at >= ? AND {$taskAlias}.end_at <= ? THEN 1 ELSE 0 END) AS stat_due_soon,
+                SUM(CASE WHEN {$taskAlias}.complete_at >= ? AND {$taskAlias}.complete_at < ? THEN 1 ELSE 0 END) AS stat_week_completed,
+                SUM(CASE WHEN {$taskAlias}.complete_at >= ? AND {$taskAlias}.complete_at < ? THEN 1 ELSE 0 END) AS stat_last_week_completed
+            ", [
+                $now->toDateTimeString(),
+                $now->toDateTimeString(),
+                $soonEnd->toDateTimeString(),
+                $weekStart->toDateTimeString(),
+                $nextWeekStart->toDateTimeString(),
+                $lastWeekStart->toDateTimeString(),
+                $weekStart->toDateTimeString(),
+            ])->first();
+
+            $noOwner = (clone $base)
+                ->whereNull('t.complete_at')
+                ->whereNotExists(self::ownerExistsQuery('t.id'))
+                ->count();
+            $members = self::memberDistribution($context, $now);
+
+            return [
+                'generated_at' => $now->toDateTimeString(),
+                'member_count' => count($context['member_userids']),
+                'blocks' => [
+                    'uncompleted' => intval($core->stat_uncompleted ?? 0),
+                    'overdue' => intval($core->stat_overdue ?? 0),
+                    'overdue_owner_count' => count(array_filter($members, fn($member) => $member['overdue'] > 0)),
+                    'due_soon' => intval($core->stat_due_soon ?? 0),
+                    'week_completed' => intval($core->stat_week_completed ?? 0),
+                    'last_week_completed' => intval($core->stat_last_week_completed ?? 0),
+                    'no_owner' => intval($noOwner),
+                ],
+                'priority' => self::priorityDistribution($context),
+                'members' => $members,
+                'high_levels' => self::highPriorityLevels(),
+            ];
+        });
+    }
+
+    /**
+     * 分页任务列表。
+     */
+    public static function tasks(array $context, array $filters)
+    {
+        $now = Carbon::now();
+        $soonEnd = $now->clone()->addDays(self::SOON_DAYS)->endOfDay();
+        $memberId = intval($filters['member_id'] ?? 0);
+        $level = $filters['level'] ?? null;
+        $type = $filters['type'] ?? '';
+
+        $builder = self::baseTaskBuilder($context)->whereNull('t.complete_at');
+        if ($memberId > 0) {
+            $builder->whereExists(self::ownerExistsQuery('t.id', [$memberId]));
+        } elseif ($level !== null) {
+            if (intval($level) === -1) {
+                $levels = self::priorityLevels();
+                if (!empty($levels)) {
+                    $builder->whereNotIn('t.p_level', $levels);
+                }
+            } else {
+                $builder->where('t.p_level', intval($level));
+            }
+        } else {
+            switch ($type) {
+                case 'overdue':
+                    $builder->whereNotNull('t.end_at')->where('t.end_at', '<', $now);
+                    break;
+
+                case 'soon':
+                    $builder->whereNotNull('t.end_at')->whereBetween('t.end_at', [$now, $soonEnd]);
+                    break;
+
+                case 'hi':
+                    $levels = self::highPriorityLevels();
+                    $builder->whereIn('t.p_level', $levels ?: [-1]);
+                    break;
+
+                case 'noowner':
+                    $builder->whereNotExists(self::ownerExistsQuery('t.id'));
+                    break;
+            }
+        }
+
+        $taskAlias = DB::getTablePrefix() . 't';
+        $builder->leftJoin('project_flow_items as fi', 'fi.id', '=', 't.flow_item_id')
+            ->select([
+                't.id',
+                't.parent_id',
+                't.project_id',
+                't.column_id',
+                't.name',
+                't.end_at',
+                't.p_level',
+                't.p_name',
+                't.p_color',
+                't.flow_item_id',
+                't.flow_item_name',
+                'p.name as project_name',
+                'fi.status as flow_item_status',
+                'fi.color as flow_item_color',
+            ])
+            ->orderByRaw("{$taskAlias}.end_at IS NULL")
+            ->orderBy('t.end_at')
+            ->orderByDesc('t.id');
+
+        $list = $builder->paginate(Base::getPaginate(50, 20));
+        $taskIds = $list->getCollection()->pluck('id')->map(fn($id) => intval($id))->toArray();
+        $owners = self::taskOwners($taskIds, $context['member_userids'], $memberId);
+        $ownProjectMap = $context['own_project_id_map'];
+
+        $list->setCollection($list->getCollection()->map(function ($task) use ($owners, $ownProjectMap) {
+            $item = (array)$task;
+            $item['id'] = intval($item['id']);
+            $item['parent_id'] = intval($item['parent_id']);
+            $item['project_id'] = intval($item['project_id']);
+            $item['column_id'] = intval($item['column_id']);
+            $item['p_level'] = intval($item['p_level']);
+            $flowParts = explode('|', $item['flow_item_name'] ?: '');
+            if (count($flowParts) >= 2) {
+                $item['flow_item_status'] = $item['flow_item_status'] ?: ($flowParts[0] ?? '');
+                $item['flow_item_name'] = $flowParts[1] ?? $item['flow_item_name'];
+                $item['flow_item_color'] = $item['flow_item_color'] ?: ($flowParts[2] ?? '');
+            }
+            $item['owners'] = $owners[$item['id']] ?? [];
+            $item['owner'] = $item['owners'][0] ?? null;
+            $item['department_readonly'] = !isset($ownProjectMap[$item['project_id']]);
+            return $item;
+        }));
+        return $list;
+    }
+
+    /**
+     * 当前系统优先级ID列表（保持设置顺序）。
+     * @return array<int>
+     */
+    public static function priorityLevels(): array
+    {
+        return array_map(fn($item) => intval($item['priority']), self::priorityList());
+    }
+
+    /**
+     * 基础任务范围：主任务、全员可见、未归档项目，且由团队成员负责或没有负责人。
+     */
+    protected static function baseTaskBuilder(array $context): Builder
+    {
+        $projectIds = $context['project_ids'] ?: [0];
+        $memberUserids = $context['member_userids'];
+
+        return DB::table('project_tasks as t')
+            ->join('projects as p', 'p.id', '=', 't.project_id')
+            ->whereIn('t.project_id', $projectIds)
+            ->where('t.parent_id', 0)
+            ->where('t.visibility', 1)
+            ->whereNull('t.archived_at')
+            ->whereNull('t.deleted_at')
+            ->whereNull('p.archived_at')
+            ->whereNull('p.deleted_at')
+            ->where(function (Builder $query) {
+                $query->where('p.department_owner_view', '<>', 'close')
+                    ->orWhereNull('p.department_owner_view');
+            })
+            ->where(function (Builder $query) use ($memberUserids) {
+                if (empty($memberUserids)) {
+                    $query->whereRaw('1 = 0');
+                    return;
+                }
+                $query->whereExists(self::ownerExistsQuery('t.id', $memberUserids))
+                    ->orWhereNotExists(self::ownerExistsQuery('t.id'));
+            });
+    }
+
+    /**
+     * 负责人存在子查询。
+     */
+    protected static function ownerExistsQuery(string $taskColumn, ?array $userids = null): callable
+    {
+        return function (Builder $query) use ($taskColumn, $userids) {
+            $query->selectRaw('1')
+                ->from('project_task_users as owner_scope')
+                ->whereColumn('owner_scope.task_id', $taskColumn)
+                ->where('owner_scope.owner', 1);
+            if ($userids !== null) {
+                $query->whereIn('owner_scope.userid', $userids ?: [0]);
+            }
+        };
+    }
+
+    /**
+     * 优先级分布（包含无负责人任务）。
+     */
+    protected static function priorityDistribution(array $context): array
+    {
+        $taskAlias = DB::getTablePrefix() . 't';
+        $rows = self::baseTaskBuilder($context)
+            ->whereNull('t.complete_at')
+            ->selectRaw("{$taskAlias}.p_level, COUNT(*) AS stat_num")
+            ->groupBy('t.p_level')
+            ->pluck('stat_num', 't.p_level');
+
+        $result = [];
+        $matched = [];
+        foreach (self::priorityList() as $item) {
+            $level = intval($item['priority']);
+            $matched[] = $level;
+            $result[] = [
+                'level' => $level,
+                'name' => $item['name'],
+                'color' => $item['color'],
+                'num' => intval($rows->get($level, 0)),
+            ];
+        }
+
+        $unset = 0;
+        foreach ($rows as $level => $num) {
+            if (!in_array(intval($level), $matched, true)) {
+                $unset += intval($num);
+            }
+        }
+        if ($unset > 0) {
+            $result[] = [
+                'level' => -1,
+                'name' => '',
+                'color' => '#c5c8ce',
+                'num' => $unset,
+            ];
+        }
+        return $result;
+    }
+
+    /**
+     * 成员任务分配。流程阶段与超期风险独立统计，无工作流的普通未完成任务归入待处理；
+     * 多负责人任务会分别计入每个负责人的工作量，团队总数仍按任务去重。
+     */
+    protected static function memberDistribution(array $context, Carbon $now): array
+    {
+        $memberUserids = $context['member_userids'];
+        if (empty($memberUserids) || empty($context['project_ids'])) {
+            return array_values(array_map(fn($member) => array_merge($member, [
+                'total' => 0,
+                'overdue' => 0,
+                'segments' => ['progress' => 0, 'start' => 0, 'test' => 0],
+            ]), $context['member_map']));
+        }
+
+        $nowText = $now->toDateTimeString();
+        $prefix = DB::getTablePrefix();
+        $taskAlias = $prefix . 't';
+        $taskUserAlias = $prefix . 'tu';
+        $flowAlias = $prefix . 'fi';
+        $rows = DB::table('project_task_users as tu')
+            ->join('project_tasks as t', 't.id', '=', 'tu.task_id')
+            ->join('projects as p', 'p.id', '=', 't.project_id')
+            ->leftJoin('project_flow_items as fi', 'fi.id', '=', 't.flow_item_id')
+            ->whereIn('tu.userid', $memberUserids)
+            ->where('tu.owner', 1)
+            ->whereIn('t.project_id', $context['project_ids'])
+            ->where('t.parent_id', 0)
+            ->where('t.visibility', 1)
+            ->whereNull('t.complete_at')
+            ->whereNull('t.archived_at')
+            ->whereNull('t.deleted_at')
+            ->whereNull('p.archived_at')
+            ->whereNull('p.deleted_at')
+            ->where(function (Builder $query) {
+                $query->where('p.department_owner_view', '<>', 'close')
+                    ->orWhereNull('p.department_owner_view');
+            })
+            ->selectRaw("
+                {$taskUserAlias}.userid,
+                COUNT(DISTINCT {$taskAlias}.id) AS stat_total,
+                COUNT(DISTINCT CASE WHEN {$taskAlias}.end_at IS NOT NULL AND {$taskAlias}.end_at < ? THEN {$taskAlias}.id END) AS stat_overdue,
+                COUNT(DISTINCT CASE WHEN {$flowAlias}.status = 'progress' THEN {$taskAlias}.id END) AS stat_progress,
+                COUNT(DISTINCT CASE WHEN {$flowAlias}.status = 'test' THEN {$taskAlias}.id END) AS stat_test,
+                COUNT(DISTINCT CASE WHEN {$flowAlias}.status IS NULL OR {$flowAlias}.status NOT IN ('progress', 'test') THEN {$taskAlias}.id END) AS stat_start
+            ", [$nowText])
+            ->groupBy('tu.userid')
+            ->get()
+            ->keyBy(fn($row) => intval($row->userid));
+
+        $members = [];
+        foreach ($context['member_map'] as $userid => $member) {
+            $row = $rows->get(intval($userid));
+            $members[] = array_merge($member, [
+                'total' => intval($row->stat_total ?? 0),
+                'overdue' => intval($row->stat_overdue ?? 0),
+                'segments' => [
+                    'progress' => intval($row->stat_progress ?? 0),
+                    'start' => intval($row->stat_start ?? 0),
+                    'test' => intval($row->stat_test ?? 0),
+                ],
+            ]);
+        }
+        usort($members, function ($a, $b) {
+            return $b['overdue'] <=> $a['overdue']
+                ?: $b['total'] <=> $a['total']
+                ?: $a['userid'] <=> $b['userid'];
+        });
+        return $members;
+    }
+
+    /**
+     * 任务负责人数据，范围内成员优先展示；成员筛选时将该成员置首。
+     */
+    protected static function taskOwners(array $taskIds, array $memberUserids, int $preferredUserid = 0): array
+    {
+        if (empty($taskIds)) {
+            return [];
+        }
+        $rows = DB::table('project_task_users')
+            ->whereIn('task_id', $taskIds)
+            ->where('owner', 1)
+            ->orderBy('id')
+            ->get(['task_id', 'userid']);
+        $userids = $rows->pluck('userid')->map(fn($id) => intval($id))->unique()->values()->toArray();
+        $users = empty($userids) ? collect() : User::select(User::$basicField)
+            ->whereIn('userid', $userids)
+            ->get()
+            ->keyBy('userid');
+        $memberMap = array_fill_keys($memberUserids, true);
+        $owners = [];
+        foreach ($rows as $row) {
+            $userid = intval($row->userid);
+            $user = $users->get($userid);
+            $owners[intval($row->task_id)][] = [
+                'userid' => $userid,
+                'nickname' => $user?->nickname ?? '',
+            ];
+        }
+        foreach ($owners as &$list) {
+            usort($list, function ($a, $b) use ($memberMap, $preferredUserid) {
+                if ($preferredUserid > 0) {
+                    $preferred = ($b['userid'] === $preferredUserid) <=> ($a['userid'] === $preferredUserid);
+                    if ($preferred !== 0) {
+                        return $preferred;
+                    }
+                }
+                $managed = isset($memberMap[$b['userid']]) <=> isset($memberMap[$a['userid']]);
+                return $managed !== 0 ? $managed : $a['userid'] <=> $b['userid'];
+            });
+        }
+        unset($list);
+        return $owners;
+    }
+
+    /**
+     * 在全部部门中一次性展开下级部门，避免递归 N+1。
+     */
+    protected static function expandDepartmentIds(array $selectedIds): array
+    {
+        $children = UserDepartment::select(['id', 'parent_id'])
+            ->get()
+            ->groupBy(fn(UserDepartment $department) => intval($department->parent_id));
+        $result = [];
+        $queue = array_values(array_unique(array_map('intval', $selectedIds)));
+        while (!empty($queue)) {
+            $departmentId = array_shift($queue);
+            if ($departmentId <= 0 || isset($result[$departmentId])) {
+                continue;
+            }
+            $result[$departmentId] = true;
+            foreach ($children->get($departmentId, collect()) as $child) {
+                $queue[] = intval($child->id);
+            }
+        }
+        return array_keys($result);
+    }
+
+    /**
+     * 当前范围内的在职非机器人成员。users.department 为现有权限口径的权威数据源。
+     */
+    protected static function loadMembers(array $departmentIds): Collection
+    {
+        if (empty($departmentIds)) {
+            return collect();
+        }
+        return User::select(User::$basicField)
+            ->whereNull('disable_at')
+            ->where('bot', 0)
+            ->where(function ($query) use ($departmentIds) {
+                foreach ($departmentIds as $departmentId) {
+                    $query->orWhere('department', 'like', "%,{$departmentId},%");
+                }
+            })
+            ->orderBy('userid')
+            ->get();
+    }
+
+    /**
+     * 成员参与且允许负责人查看的活动项目。
+     */
+    protected static function loadProjectIds(array $memberUserids): array
+    {
+        if (empty($memberUserids)) {
+            return [];
+        }
+        return DB::table('project_users as pu')
+            ->join('projects as p', 'p.id', '=', 'pu.project_id')
+            ->whereIn('pu.userid', $memberUserids)
+            ->whereNull('p.archived_at')
+            ->whereNull('p.deleted_at')
+            ->where(function (Builder $query) {
+                $query->where('p.department_owner_view', '<>', 'close')
+                    ->orWhereNull('p.department_owner_view');
+            })
+            ->distinct()
+            ->orderBy('p.id')
+            ->pluck('p.id')
+            ->map(fn($id) => intval($id))
+            ->toArray();
+    }
+
+    protected static function normalizeSelectedDepartmentIds($selectedIds, array $managedIds): array
+    {
+        if ($selectedIds === null || $selectedIds === '' || $selectedIds === 'all' || $selectedIds === []) {
+            return $managedIds;
+        }
+        if (!is_array($selectedIds)) {
+            $selectedIds = explode(',', (string)$selectedIds);
+        }
+        return array_values(array_unique(array_intersect(
+            array_map('intval', $selectedIds),
+            $managedIds
+        )));
+    }
+
+    protected static function highPriorityLevels(): array
+    {
+        return array_slice(self::priorityLevels(), 0, self::HIGH_PRIORITY_COUNT);
+    }
+
+    protected static function priorityList(): array
+    {
+        return Setting::normalizeTaskPriorityList(Base::setting('priority'));
+    }
+}

app/Module/Doo.php

@@ -53,7 +53,7 @@ class Doo
      */
     public static function licenseContent(): string
     {
-        if (env("SYSTEM_LICENSE") == 'hidden') {
+        if (config('dootask.system_license') == 'hidden') {
             return '';
         }
         $paths = [
@@ -81,6 +81,39 @@ class Doo
         self::load()->licenseSave($license);
     }
 
+    /**
+     * 解析License取字段
+     * @param $license
+     * @return array
+     */
+    public static function licenseDecode($license): array
+    {
+        return self::load()->licenseDecode($license);
+    }
+
+    /**
+     * 校验 license 的 SN/MAC 是否与本机匹配。通过返回 null，否则返回错误文案。
+     * @param array $info license 信息，含 people/sn/mac（mac 兼容数组或逗号串）
+     * @return string|null
+     */
+    public static function licenseBindingError(array $info): ?string
+    {
+        $people = (int)($info['people'] ?? 0);
+        if (!($people === 0 || $people > 3)) {
+            return null;
+        }
+        if ((string)($info['sn'] ?? '') !== self::dooSN()) {
+            return '终端SN与License不匹配';
+        }
+        $mac = $info['mac'] ?? [];
+        $licenseMacs = array_filter(array_map('trim', is_array($mac) ? $mac : explode(',', (string)$mac)));
+        $curMacs = self::macs();
+        if ($licenseMacs && $curMacs && !array_intersect($licenseMacs, $curMacs)) {
+            return '终端MAC与License不匹配';
+        }
+        return null;
+    }
+
     /**
      * 当前会员ID（来自请求的token）
      * @return int

app/Module/Ihttp.php

@@ -14,6 +14,8 @@ class Ihttp
         }
         if(!empty($urlset['query'])) {
             $urlset['query'] = "?{$urlset['query']}";
+        } else {
+            $urlset['query'] = '';
         }
         if(empty($urlset['port'])) {
             $urlset['port'] = $urlset['scheme'] == 'https' ? '443' : '80';
@@ -194,13 +196,14 @@ class Ihttp
         $rlt['status'] = $matches[3];
         $rlt['responseline'] = $split2[0];
         $header = explode("\r\n", $split2[1]);
+        $rlt['headers'] = [];
         $isgzip = false;
         $ischunk = false;
         foreach ($header as $v) {
             $row = explode(':', $v);
             $key = trim($row[0]);
             $value = trim(substr($v, strlen($row[0]) + 1));
-            if (is_array($rlt['headers'][$key])) {
+            if (isset($rlt['headers'][$key]) && is_array($rlt['headers'][$key])) {
                 $rlt['headers'][$key][] = $value;
             } elseif (!empty($rlt['headers'][$key])) {
                 $temp = $rlt['headers'][$key];

app/Module/Manticore/ManticoreBase.php

@@ -8,6 +8,7 @@ use App\Module\Base;
 use App\Module\AI;
 use PDO;
 use PDOException;
+use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Log;
 
 /**
@@ -21,6 +22,30 @@ class ManticoreBase
     private static ?PDO $pdo = null;
     private static bool $initialized = false;
 
+    /**
+     * 向量表结构版本；修改表结构/向量列参数时递增，触发已部署实例自动重建
+     */
+    private const SCHEMA_VERSION = 1;
+
+    /**
+     * Auto Embeddings 的 MODEL_NAME。必须用 Manticore 不认识的名字：
+     * 已知名字（如 text-embedding-ada-002）会按引擎硬编码维度校验，
+     * 未知名字才会在建表时向 API_URL 探测真实维度（免费模型为 1024）。
+     * 实际模型由 ai 插件的 EMBEDDING_MODEL 决定，此处仅为路由标签。
+     */
+    private const EMBEDDING_MODEL_NAME = 'openai/qwen3-embedding';
+
+    /**
+     * 批量写入分块上限：行数与字节预算（Manticore max_allowed_packet 默认 128MB，取保守值）
+     */
+    private const BATCH_CHUNK_ROWS = 30;
+    private const BATCH_CHUNK_BYTES = 8388608;
+
+    /**
+     * 5 张向量表名（键值即 VECTOR_TABLE_CONFIG 的 type）
+     */
+    private const VECTOR_TABLES = ['msg', 'file', 'task', 'project', 'user'];
+
     private string $host;
     private int $port;
 
@@ -29,8 +54,8 @@ class ManticoreBase
      */
     public function __construct()
     {
-        $this->host = env('SEARCH_HOST', 'search');
+        $this->host = config('dootask.search_host');
-        $this->port = (int) env('SEARCH_PORT', 9306);
+        $this->port = (int) config('dootask.search_port');
     }
 
     /**
@@ -70,13 +95,169 @@ class ManticoreBase
 
     /**
      * 初始化表结构
+     *
+     * 向量列使用 Manticore Auto Embeddings（MODEL_NAME/API_URL 指向 ai 插件 /embeddings），
+     * 引擎在写入/更新行时自动按 FROM 字段生成向量，无需 PHP 侧生成。
+     * key_values 中的 vector:schema 标记记录当前结构指纹（结构版本/模型/端点/APP_KEY 哈希），
+     * 不匹配（首次安装、老版本升级、APP_KEY 轮换）即整体重建并重置同步指针，触发全量重灌。
      */
     private function initializeTables(PDO $pdo): void
     {
         try {
-            // 创建文件向量表
+            // 键值表必须最先建（用于读取/持久化结构标记与同步指针）
-            // charset_table='non_cjk, cjk' 同时支持英文和中日韩文字
             $pdo->exec("
+                CREATE TABLE IF NOT EXISTS key_values (
+                    id BIGINT,
+                    k STRING,
+                    v TEXT
+                )
+            ");
+
+            $expected = self::schemaMarker();
+            if (self::kvGetPdo($pdo, 'vector:schema') === $expected
+                && self::allVectorTablesExist($pdo)
+                && !self::embeddingModelChanged($pdo)) {
+                return;
+            }
+
+            // 并发进程只允许一个执行重建；抢锁失败的进程本轮写入失败会进重试队列，无碍
+            $lock = Cache::lock('manticore:schema-rebuild', 300);
+            if (!$lock->get()) {
+                return;
+            }
+            try {
+                // 拿到锁时可能另一进程刚完成重建（marker 写入在锁内），先复检避免重复重建
+                if (self::kvGetPdo($pdo, 'vector:schema') === $expected
+                    && self::allVectorTablesExist($pdo)
+                    && !self::embeddingModelChanged($pdo)) {
+                    return;
+                }
+
+                // 先用一次性探针表验证 ai 端点可用（CREATE 会向端点探测维度、未就绪则抛错），
+                // 通过后才 DROP 现有表——避免 ai 未就绪时销毁旧索引后建不回来
+                $pdo->exec("DROP TABLE IF EXISTS _schema_probe");
+                $pdo->exec("CREATE TABLE _schema_probe (t TEXT, " . self::vectorColumnDDL('t') . ")");
+                $pdo->exec("DROP TABLE IF EXISTS _schema_probe");
+
+                foreach (self::vectorTableDDLs() as $table => $ddl) {
+                    $pdo->exec("DROP TABLE IF EXISTS {$table}");
+                    $pdo->exec($ddl);
+                }
+
+                self::resetSyncPointersPdo($pdo);
+                // 清理旧向量管道遗留键（vector:dim 与 vector:*LastId 指针）
+                $legacy = ["'vector:dim'"];
+                foreach (self::VECTOR_TABLES as $t) {
+                    $legacy[] = "'vector:manticore" . ucfirst($t) . "LastId'";
+                }
+                $pdo->exec("DELETE FROM key_values WHERE k IN (" . implode(',', $legacy) . ")");
+                self::rememberEmbeddingModel($pdo);
+                // marker 最后写入且在锁内：写入即代表重建完整成功
+                self::kvSetPdo($pdo, 'vector:schema', $expected);
+                Log::info("Manticore vector tables rebuilt for auto-embeddings schema {$expected}");
+            } catch (\Throwable $e) {
+                // 重建失败（如 ai 插件未就绪/未升级）：不写 marker，下个进程重试，可自愈
+                Log::error('Manticore schema rebuild failed: ' . $e->getMessage());
+            } finally {
+                $lock->release();
+            }
+        } catch (\Throwable $e) {
+            Log::error('Manticore initializeTables failed: ' . $e->getMessage());
+        }
+    }
+
+    /**
+     * ai 插件向量化端点地址（唯一来源在 AI::embeddingsUrl，查询侧与表定义共用）
+     */
+    private static function embeddingsApiUrl(): string
+    {
+        return AI::embeddingsUrl();
+    }
+
+    /**
+     * 写入表定义的派生密钥：sha256(APP_KEY:embeddings)，与 ai 插件约定一致。
+     * 不直接写 APP_KEY（Laravel 主密钥），避免其落入搜索引擎元数据/数据卷；
+     * 派生值不可反推，且仅授予 /embeddings 调用权限。
+     */
+    private static function embeddingsApiKey(): string
+    {
+        return hash('sha256', config('app.key') . ':embeddings');
+    }
+
+    /**
+     * 当前向量表结构指纹：结构版本/模型名/端点/APP_KEY 哈希任一变化都会触发整体重建
+     */
+    private static function schemaMarker(): string
+    {
+        return md5(self::SCHEMA_VERSION . '|' . self::EMBEDDING_MODEL_NAME . '|'
+            . self::embeddingsApiUrl() . '|' . hash('sha256', (string) config('app.key')));
+    }
+
+    /**
+     * 检测 ai 插件实际生效的向量模型是否与建表时不一致（不一致需重建，否则维度可能不匹配）。
+     *
+     * 实际模型（EMBEDDING_MODEL env）对主程序不可见，由查询侧在成功请求后
+     * 写入缓存 ai:embedding_model；建表时的模型记录在 key_values 的 vector:model。
+     * 任一侧未知时不触发（返回 false），已知且存量缺失时顺手补记。
+     */
+    private static function embeddingModelChanged(PDO $pdo): bool
+    {
+        $live = (string) Cache::get('ai:embedding_model', '');
+        if ($live === '') {
+            return false;
+        }
+        $stored = self::kvGetPdo($pdo, 'vector:model');
+        if ($stored === null || $stored === '') {
+            // 旧部署/首次：补记当前模型，不触发重建
+            self::kvSetPdo($pdo, 'vector:model', $live);
+            return false;
+        }
+        return $stored !== $live;
+    }
+
+    /**
+     * 重建成功后记录当前生效的向量模型（优先取查询侧维护的缓存值）
+     */
+    private static function rememberEmbeddingModel(PDO $pdo): void
+    {
+        $live = (string) Cache::get('ai:embedding_model', '');
+        if ($live !== '') {
+            self::kvSetPdo($pdo, 'vector:model', $live);
+        } else {
+            // 未知则清掉存量，待查询侧探得后由 embeddingModelChanged 补记
+            $pdo->exec("DELETE FROM key_values WHERE k = 'vector:model'");
+        }
+    }
+
+    /**
+     * 生成 Auto Embeddings 向量列定义（引擎按 FROM 字段自动生成/更新向量）
+     *
+     * 注意不写 KNN_DIMS（与 MODEL_NAME 互斥），维度由引擎建表时向端点探测。
+     *
+     * @param string $from 参与向量化的字段（镜像旧 PHP 管道的拼接字段，逗号分隔）
+     */
+    private static function vectorColumnDDL(string $from): string
+    {
+        return "content_vector float_vector knn_type='hnsw' hnsw_similarity='cosine'"
+            . " MODEL_NAME='" . self::EMBEDDING_MODEL_NAME . "'"
+            . " FROM='{$from}'"
+            . " API_KEY='" . self::embeddingsApiKey() . "'"
+            . " API_URL='" . self::embeddingsApiUrl() . "'"
+            . " API_TIMEOUT='60'";
+    }
+
+    /**
+     * 生成 5 张向量表的建表语句
+     *
+     * charset_table='non_cjk, cjk' 同时支持英文和中日韩文字
+     *
+     * @return array [table => DDL]
+     */
+    private static function vectorTableDDLs(): array
+    {
+        $tail = "\n                ) charset_table='non_cjk, cjk' morphology='icu_chinese'";
+        return [
+            'file_vectors' => "
                 CREATE TABLE IF NOT EXISTS file_vectors (
                     id BIGINT,
                     file_id BIGINT,
@@ -87,21 +268,8 @@ class ManticoreBase
                     file_ext STRING,
                     content TEXT,
                     allowed_users MULTI,
-                    content_vector float_vector knn_type='hnsw' knn_dims='1536' hnsw_similarity='cosine'
+                    " . self::vectorColumnDDL('file_name,content') . $tail,
-                ) charset_table='non_cjk, cjk' morphology='icu_chinese'
+            'user_vectors' => "
-            ");
-
-            // 创建键值存储表
-            $pdo->exec("
-                CREATE TABLE IF NOT EXISTS key_values (
-                    id BIGINT,
-                    k STRING,
-                    v TEXT
-                )
-            ");
-
-            // 创建用户向量表
-            $pdo->exec("
                 CREATE TABLE IF NOT EXISTS user_vectors (
                     id BIGINT,
                     userid BIGINT,
@@ -110,12 +278,8 @@ class ManticoreBase
                     profession TEXT,
                     tags TEXT,
                     introduction TEXT,
-                    content_vector float_vector knn_type='hnsw' knn_dims='1536' hnsw_similarity='cosine'
+                    " . self::vectorColumnDDL('nickname,email,profession,tags,introduction') . $tail,
-                ) charset_table='non_cjk, cjk' morphology='icu_chinese'
+            'project_vectors' => "
-            ");
-
-            // 创建项目向量表
-            $pdo->exec("
                 CREATE TABLE IF NOT EXISTS project_vectors (
                     id BIGINT,
                     project_id BIGINT,
@@ -124,12 +288,8 @@ class ManticoreBase
                     project_name TEXT,
                     project_desc TEXT,
                     allowed_users MULTI,
-                    content_vector float_vector knn_type='hnsw' knn_dims='1536' hnsw_similarity='cosine'
+                    " . self::vectorColumnDDL('project_name,project_desc') . $tail,
-                ) charset_table='non_cjk, cjk' morphology='icu_chinese'
+            'task_vectors' => "
-            ");
-
-            // 创建任务向量表
-            $pdo->exec("
                 CREATE TABLE IF NOT EXISTS task_vectors (
                     id BIGINT,
                     task_id BIGINT,
@@ -140,12 +300,8 @@ class ManticoreBase
                     task_desc TEXT,
                     task_content TEXT,
                     allowed_users MULTI,
-                    content_vector float_vector knn_type='hnsw' knn_dims='1536' hnsw_similarity='cosine'
+                    " . self::vectorColumnDDL('task_name,task_desc,task_content') . $tail,
-                ) charset_table='non_cjk, cjk' morphology='icu_chinese'
+            'msg_vectors' => "
-            ");
-
-            // 创建消息向量表
-            $pdo->exec("
                 CREATE TABLE IF NOT EXISTS msg_vectors (
                     id BIGINT,
                     msg_id BIGINT,
@@ -155,13 +311,69 @@ class ManticoreBase
                     content TEXT,
                     allowed_users MULTI,
                     created_at BIGINT,
-                    content_vector float_vector knn_type='hnsw' knn_dims='1536' hnsw_similarity='cosine'
+                    " . self::vectorColumnDDL('content') . $tail,
-                ) charset_table='non_cjk, cjk' morphology='icu_chinese'
+        ];
-            ");
+    }
 
-            // Tables initialized successfully
+    /**
-        } catch (PDOException $e) {
+     * 检查 5 张向量表是否都已存在
-            // 表可能已存在，忽略初始化错误
+     */
+    private static function allVectorTablesExist(PDO $pdo): bool
+    {
+        try {
+            $stmt = $pdo->query("SHOW TABLES");
+            $existing = [];
+            foreach ($stmt->fetchAll(PDO::FETCH_NUM) as $row) {
+                $existing[$row[0]] = true;
+            }
+            foreach (array_keys(self::vectorTableDDLs()) as $table) {
+                if (!isset($existing[$table])) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    /**
+     * 直接用 PDO 读取 key_values（避免初始化期通过 ManticoreKeyValue 造成递归）
+     */
+    private static function kvGetPdo(PDO $pdo, string $key): ?string
+    {
+        try {
+            $stmt = $pdo->prepare("SELECT v FROM key_values WHERE k = ?");
+            $stmt->execute([$key]);
+            $row = $stmt->fetch(PDO::FETCH_ASSOC);
+            return ($row && isset($row['v'])) ? (string)$row['v'] : null;
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+
+    /**
+     * 直接用 PDO 写入 key_values（同 ManticoreKeyValue::set 的 id 规则）
+     */
+    private static function kvSetPdo(PDO $pdo, string $key, string $value): void
+    {
+        try {
+            $del = $pdo->prepare("DELETE FROM key_values WHERE k = ?");
+            $del->execute([$key]);
+            $ins = $pdo->prepare("INSERT INTO key_values (id, k, v) VALUES (?, ?, ?)");
+            $ins->execute([abs(crc32($key)), $key, $value]);
+        } catch (\Throwable $e) {
+            // 忽略
+        }
+    }
+
+    /**
+     * 重置全文同步进度指针（sync:*），触发全量重灌（向量由引擎随行自动生成）
+     */
+    private static function resetSyncPointersPdo(PDO $pdo): void
+    {
+        foreach (self::VECTOR_TABLES as $t) {
+            self::kvSetPdo($pdo, "sync:manticore" . ucfirst($t) . "LastId", '0');
         }
     }
 
@@ -256,13 +468,17 @@ class ManticoreBase
      */
     public function executeRaw(string $sql): bool
     {
+        // 日志上下文只保留 SQL 前 2KB：多行批量语句可达数 MB，完整写入会淹没日志
+        $sqlPreview = strlen($sql) > 2048
+            ? substr($sql, 0, 2048) . ' ...[+' . (strlen($sql) - 2048) . ' bytes]'
+            : $sql;
         return $this->runWithRetry(
             function (PDO $pdo) use ($sql) {
                 $pdo->exec($sql);
                 return true;
             },
             false,
-            ['sql' => $sql]
+            ['sql' => $sqlPreview]
         );
     }
 
@@ -1810,10 +2026,10 @@ class ManticoreBase
     ];
 
     /**
-     * 通用向量插入方法
+     * 通用单行写入方法（REPLACE，向量由引擎 Auto Embeddings 自动生成）
      *
      * 使用 executeRaw 直接执行 SQL，避免 Manticore prepared statement
-     * 无法解析 MVA 和向量字段括号语法的问题。
+     * 无法解析 MVA 字段括号语法的问题。
      *
      * @param string $type 类型: msg/file/task/project/user
      * @param array $data 数据，键名对应字段名
@@ -1828,8 +2044,6 @@ class ManticoreBase
         $config = self::VECTOR_TABLE_CONFIG[$type];
         $table = $config['table'];
         $pk = $config['pk'];
-        $fields = $config['fields'];
-        $mvaFields = $config['mva_fields'];
 
         // 检查主键
         $pkValue = $data[$pk] ?? 0;
@@ -1838,44 +2052,11 @@ class ManticoreBase
         }
 
         $instance = new self();
+        [$fieldList, $valueList] = $instance->buildRowValues($config, $data);
 
-        // 先删除已存在的记录
+        // REPLACE 按 id 原子替换整行，向量列由引擎按 FROM 字段自动重新生成。
-        $instance->execute("DELETE FROM {$table} WHERE {$pk} = ?", [$pkValue]);
+        // 前提：所有 upsertXxxVector 均强制 id = 主键值，故 REPLACE(按 id) 与按主键去重等价
-
+        $sql = "REPLACE INTO {$table} (" . implode(', ', $fieldList) . ") VALUES (" . implode(', ', $valueList) . ")";
-        // 构建字段列表和值
-        $fieldList = [];
-        $valueList = [];
-
-        // 处理普通字段
-        foreach ($fields as $field) {
-            $fieldList[] = $field;
-            $value = $data[$field] ?? ($field === 'created_at' ? time() : (in_array($field, self::NUMERIC_FIELDS) ? 0 : ''));
-
-            if (in_array($field, self::NUMERIC_FIELDS)) {
-                $valueList[] = (int)$value;
-            } else {
-                $valueList[] = $instance->quoteValue((string)$value);
-            }
-        }
-
-        // 处理 MVA 字段
-        foreach ($mvaFields as $mvaField) {
-            $fieldList[] = $mvaField;
-            $mvaData = $data[$mvaField] ?? [];
-            $valueList[] = !empty($mvaData)
-                ? '(' . implode(',', array_map('intval', $mvaData)) . ')'
-                : '()';
-        }
-
-        // 处理向量字段
-        $vectorValue = $data['content_vector'] ?? null;
-        if ($vectorValue) {
-            $fieldList[] = 'content_vector';
-            $valueList[] = str_replace(['[', ']'], ['(', ')'], $vectorValue);
-        }
-
-        // 构建并执行 SQL
-        $sql = "INSERT INTO {$table} (" . implode(', ', $fieldList) . ") VALUES (" . implode(', ', $valueList) . ")";
 
         $result = $instance->executeRaw($sql);
 
@@ -1885,12 +2066,46 @@ class ManticoreBase
             ManticoreSyncFailure::removeSuccess($type, $pkValue, 'sync');
         } else {
             // 失败则记录
-            ManticoreSyncFailure::recordFailure($type, $pkValue, 'sync', "INSERT failed for {$table}");
+            ManticoreSyncFailure::recordFailure($type, $pkValue, 'sync', "REPLACE failed for {$table}");
         }
 
         return $result;
     }
 
+    /**
+     * 构建一行数据的字段列表与内联值（普通字段 + MVA 字段，向量列由引擎自动生成，不在此列）
+     *
+     * @param array $config VECTOR_TABLE_CONFIG 中的类型配置
+     * @param array $data 行数据
+     * @return array [fieldList, valueList]
+     */
+    private function buildRowValues(array $config, array $data): array
+    {
+        $fieldList = [];
+        $valueList = [];
+
+        foreach ($config['fields'] as $field) {
+            $fieldList[] = $field;
+            $value = $data[$field] ?? ($field === 'created_at' ? time() : (in_array($field, self::NUMERIC_FIELDS) ? 0 : ''));
+
+            if (in_array($field, self::NUMERIC_FIELDS)) {
+                $valueList[] = (int)$value;
+            } else {
+                $valueList[] = $this->quoteValue((string)$value);
+            }
+        }
+
+        foreach ($config['mva_fields'] as $mvaField) {
+            $fieldList[] = $mvaField;
+            $mvaData = $data[$mvaField] ?? [];
+            $valueList[] = !empty($mvaData)
+                ? '(' . implode(',', array_map('intval', $mvaData)) . ')'
+                : '()';
+        }
+
+        return [$fieldList, $valueList];
+    }
+
     /**
      * 通用向量删除方法
      *
@@ -1924,179 +2139,92 @@ class ManticoreBase
     }
 
     /**
-     * 通用批量更新向量方法（高性能版本）
+     * 通用批量写入方法：每块一条多行 REPLACE，向量由引擎 Auto Embeddings 自动生成
      *
-     * 优化：将 N 条记录的 3N 次操作减少为 N+2 次操作
+     * 引擎对一条多行语句只调用一次向量化接口（实测 30 行 ≈ 0.9s），
-     * 1. 批量 SELECT 获取现有记录 (1次)
+     * 多行语句失败是原子的；整块失败时回退逐行 upsertVector，
-     * 2. 预构建所有 INSERT SQL（验证数据完整性）
+     * 使单条坏行不毒化整批、且失败按真实主键记入重试表。
-     * 3. 批量 DELETE 删除旧记录 (1次)
-     * 4. 逐条 INSERT 新记录带向量 (N次，因向量字段无法批量绑定)
      *
      * @param string $type 类型: msg/file/task/project/user
-     * @param array $vectorData 向量数据 [pk_value => vectorStr, ...]
+     * @param array $rows 行数据数组（与 upsertVector 的 $data 同构，需含 id 与主键）
-     * @return int 成功更新的数量
+     * @return int 成功写入的数量
      */
-    public static function batchUpdateVectors(string $type, array $vectorData): int
+    public static function batchUpsertVectors(string $type, array $rows): int
     {
-        if (empty($vectorData) || !isset(self::VECTOR_TABLE_CONFIG[$type])) {
+        if (empty($rows) || !isset(self::VECTOR_TABLE_CONFIG[$type])) {
             return 0;
         }
 
         $config = self::VECTOR_TABLE_CONFIG[$type];
         $table = $config['table'];
         $pk = $config['pk'];
-        $fields = $config['fields'];
-        $mvaFields = $config['mva_fields'];
-
         $instance = new self();
-        $ids = array_keys($vectorData);
 
-        // 1. 批量查询现有记录
+        // 剔除无主键行；按内容长度估算分块（不在此渲染 SQL，块内惰性渲染以压低内存峰值）
-        $placeholders = implode(',', array_fill(0, count($ids), '?'));
+        $pending = [];
-        $existingRows = $instance->query(
+        foreach ($rows as $row) {
-            "SELECT * FROM {$table} WHERE {$pk} IN ({$placeholders})",
+            if (($row[$pk] ?? 0) <= 0) {
-            $ids
-        );
-
-        if (empty($existingRows)) {
-            return 0;
-        }
-
-        // 建立 pk => row 的映射
-        $existingMap = [];
-        foreach ($existingRows as $row) {
-            $existingMap[$row[$pk]] = $row;
-        }
-
-        $idsToUpdate = array_keys($existingMap);
-        if (empty($idsToUpdate)) {
-            return 0;
-        }
-
-        // 2. 预构建所有 INSERT 语句（在删除前验证数据完整性）
-        $insertStatements = [];
-        foreach ($idsToUpdate as $pkValue) {
-            $existing = $existingMap[$pkValue];
-            $vectorStr = $vectorData[$pkValue] ?? null;
-
-            if (empty($vectorStr)) {
                 continue;
             }
-
+            $bytes = 64;
-            // Manticore 向量使用 () 格式
+            foreach ($row as $value) {
-            $vectorStr = str_replace(['[', ']'], ['(', ')'], $vectorStr);
+                if (is_string($value)) {
-
+                    $bytes += strlen($value);
-            // 构建字段列表和值（直接内联值，不使用参数绑定）
-            $fieldList = $fields;
-            $quotedValues = [];
-            foreach ($fields as $field) {
-                $value = $existing[$field] ?? null;
-                // 处理默认值：数值字段用 0，时间戳字段用当前时间，其他用空字符串
-                if ($value === null) {
-                    if ($field === 'created_at') {
-                        $value = time();
-                    } elseif (in_array($field, self::NUMERIC_FIELDS)) {
-                        $value = 0;
-                    } else {
-                        $value = '';
                 }
             }
-                // 根据字段类型处理值
+            $pending[] = ['pk' => $row[$pk], 'bytes' => $bytes, 'row' => $row];
-                if (in_array($field, self::NUMERIC_FIELDS)) {
-                    $quotedValues[] = (int)$value;
-                } else {
-                    $quotedValues[] = $instance->quoteValue((string)$value);
         }
-            }
+        if (empty($pending)) {
-
-            // 构建 MVA 字段
-            $mvaValuesStr = [];
-            foreach ($mvaFields as $mvaField) {
-                $fieldList[] = $mvaField;
-                $mvaValuesStr[] = !empty($existing[$mvaField])
-                    ? '(' . $existing[$mvaField] . ')'
-                    : '()';
-            }
-
-            // 添加向量字段
-            $fieldList[] = 'content_vector';
-
-            // 构建 SQL（所有值直接内联，使用 executeRaw 避免 prepared statement 解析问题）
-            $allValues = implode(', ', array_merge($quotedValues, $mvaValuesStr, [$vectorStr]));
-            $sql = "INSERT INTO {$table} (" . implode(', ', $fieldList) . ") VALUES ({$allValues})";
-
-            $insertStatements[] = ['sql' => $sql, 'pk' => $pkValue];
-        }
-
-        // 如果没有有效的插入语句，直接返回
-        if (empty($insertStatements)) {
             return 0;
         }
 
-        // 3. 批量删除旧记录（只删除有有效向量的记录）
+        // 分块：行数上限 + 字节预算（文件内容可达 10 万字符/行）
-        $validPks = array_column($insertStatements, 'pk');
+        $chunks = [];
-        $deletePlaceholders = implode(',', array_fill(0, count($validPks), '?'));
+        $current = [];
-        $instance->execute(
+        $currentBytes = 0;
-            "DELETE FROM {$table} WHERE {$pk} IN ({$deletePlaceholders})",
+        foreach ($pending as $item) {
-            $validPks
+            if (!empty($current)
-        );
+                && (count($current) >= self::BATCH_CHUNK_ROWS || $currentBytes + $item['bytes'] > self::BATCH_CHUNK_BYTES)) {
+                $chunks[] = $current;
+                $current = [];
+                $currentBytes = 0;
+            }
+            $current[] = $item;
+            $currentBytes += $item['bytes'];
+        }
+        $chunks[] = $current;
 
-        // 4. 逐条插入新记录（使用 executeRaw 避免 prepared statement 解析问题）
         $successCount = 0;
-        foreach ($insertStatements as $stmt) {
+        foreach ($chunks as $chunk) {
-            if ($instance->executeRaw($stmt['sql'])) {
+            // 块内渲染，执行后即释放，内存峰值 = 原始行 + 单块 SQL
-                $successCount++;
+            $fieldListRef = null;
-                // 成功则删除失败记录（如果有）
+            $valuesSql = [];
-                ManticoreSyncFailure::removeSuccess($type, $stmt['pk'], 'sync');
+            foreach ($chunk as $item) {
+                [$fieldList, $valueList] = $instance->buildRowValues($config, $item['row']);
+                $fieldListRef = $fieldList;
+                $valuesSql[] = '(' . implode(', ', $valueList) . ')';
+            }
+            $sql = "REPLACE INTO {$table} (" . implode(', ', $fieldListRef) . ") VALUES "
+                . implode(', ', $valuesSql);
+            unset($valuesSql);
+            $ok = $instance->executeRaw($sql);
+            unset($sql);
+            if ($ok) {
+                $successCount += count($chunk);
+                ManticoreSyncFailure::removeSuccessBatch($type, array_column($chunk, 'pk'), 'sync');
             } else {
-                // 失败则记录
+                // 整块失败：回退逐行（REPLACE 幂等，重复写已生效行无害）
-                ManticoreSyncFailure::recordFailure($type, $stmt['pk'], 'sync', "Batch INSERT failed for {$table}");
+                foreach ($chunk as $item) {
+                    if (self::upsertVector($type, $item['row'])) {
+                        $successCount++;
+                    }
+                }
             }
         }
 
         return $successCount;
     }
 
-    /**
-     * 批量更新消息向量（兼容方法）
-     */
-    public static function batchUpdateMsgVectors(array $vectorData): int
-    {
-        return self::batchUpdateVectors('msg', $vectorData);
-    }
-
-    /**
-     * 批量更新文件向量
-     */
-    public static function batchUpdateFileVectors(array $vectorData): int
-    {
-        return self::batchUpdateVectors('file', $vectorData);
-    }
-
-    /**
-     * 批量更新任务向量
-     */
-    public static function batchUpdateTaskVectors(array $vectorData): int
-    {
-        return self::batchUpdateVectors('task', $vectorData);
-    }
-
-    /**
-     * 批量更新项目向量
-     */
-    public static function batchUpdateProjectVectors(array $vectorData): int
-    {
-        return self::batchUpdateVectors('project', $vectorData);
-    }
-
-    /**
-     * 批量更新用户向量
-     */
-    public static function batchUpdateUserVectors(array $vectorData): int
-    {
-        return self::batchUpdateVectors('user', $vectorData);
-    }
-
     // ==============================
     // 通用工具方法
     // ==============================

app/Module/Manticore/ManticoreFile.php

@@ -8,7 +8,6 @@ use App\Models\FileUser;
 use App\Module\Apps;
 use App\Module\Base;
 use App\Module\TextExtractor;
-use App\Module\AI;
 use Illuminate\Support\Facades\Log;
 
 /**
@@ -38,7 +37,9 @@ class ManticoreFile
     public const SEARCHABLE_TYPES = ['document', 'word', 'excel', 'ppt', 'txt', 'md', 'text', 'code'];
 
     /**
-     * 最大内容长度（字符）- 提取后的文本内容限制
+     * 最大内容长度（字符）- 提取后的文本内容限制（服务全文检索范围）。
+     * 注意：向量化输入在 ai 插件侧另有 30000 字符上限（main.py _EMBEDDING_INPUT_MAX_CHARS），
+     * 超出部分只参与全文检索、不参与语义向量。
      */
     public const MAX_CONTENT_LENGTH = 100000; // 100K 字符
 
@@ -214,13 +215,12 @@ class ManticoreFile
     // ==============================
 
     /**
-     * 同步单个文件到 Manticore（含 allowed_users）
+     * 同步单个文件到 Manticore（含 allowed_users，向量由引擎 Auto Embeddings 自动生成）
      *
      * @param File $file 文件模型
-     * @param bool $withVector 是否同时生成向量（默认 false，向量由后台任务生成）
      * @return bool 是否成功
      */
-    public static function sync(File $file, bool $withVector = false): bool
+    public static function sync(File $file): bool
     {
         if (!Apps::isInstalled("search")) {
             return false;
@@ -240,42 +240,7 @@ class ManticoreFile
         }
 
         try {
-            // 提取文件内容
+            return ManticoreBase::upsertFileVector(self::buildRow($file));
-            $content = self::extractFileContent($file);
-
-            // 限制提取后的内容长度
-            $content = mb_substr($content, 0, self::MAX_CONTENT_LENGTH);
-
-            // 只有明确要求时才生成向量（默认不生成，由后台任务处理）
-            $embedding = null;
-            if ($withVector && Apps::isInstalled('ai')) {
-                // 向量内容包含文件名和文件内容
-                $vectorContent = self::buildVectorContent($file->name, $content);
-                if (!empty($vectorContent)) {
-                    $embeddingResult = ManticoreBase::getEmbedding($vectorContent);
-                    if (!empty($embeddingResult)) {
-                        $embedding = '[' . implode(',', $embeddingResult) . ']';
-                    }
-                }
-            }
-
-            // 获取文件的 allowed_users
-            $allowedUsers = self::getAllowedUsers($file);
-
-            // 写入 Manticore（含 allowed_users）
-            $result = ManticoreBase::upsertFileVector([
-                'file_id' => $file->id,
-                'userid' => $file->userid,
-                'pshare' => $file->pshare ?? 0,
-                'file_name' => $file->name,
-                'file_type' => $file->type,
-                'file_ext' => $file->ext,
-                'content' => $content,
-                'content_vector' => $embedding,
-                'allowed_users' => $allowedUsers,
-            ]);
-
-            return $result;
         } catch (\Exception $e) {
             Log::error('Manticore sync error: ' . $e->getMessage(), [
                 'file_id' => $file->id,
@@ -285,6 +250,30 @@ class ManticoreFile
         }
     }
 
+    /**
+     * 构建文件索引行数据（含提取的文件内容与 allowed_users）
+     *
+     * @param File $file 文件模型
+     * @return array 行数据
+     */
+    private static function buildRow(File $file): array
+    {
+        // 提取文件内容并限制长度
+        $content = mb_substr(self::extractFileContent($file), 0, self::MAX_CONTENT_LENGTH);
+
+        return [
+            'id' => $file->id,
+            'file_id' => $file->id,
+            'userid' => $file->userid,
+            'pshare' => $file->pshare ?? 0,
+            'file_name' => $file->name,
+            'file_type' => $file->type,
+            'file_ext' => $file->ext,
+            'content' => $content,
+            'allowed_users' => self::getAllowedUsers($file),
+        ];
+    }
+
     /**
      * 根据文件扩展名获取最大文件大小限制
      *
@@ -317,25 +306,41 @@ class ManticoreFile
     }
 
     /**
-     * 批量同步文件
+     * 批量同步文件（每块一条多行 REPLACE，向量由引擎自动生成）
      *
      * @param iterable $files 文件列表
-     * @param bool $withVector 是否同时生成向量
      * @return int 成功同步的数量
      */
-    public static function batchSync(iterable $files, bool $withVector = false): int
+    public static function batchSync(iterable $files): int
     {
         if (!Apps::isInstalled("search")) {
             return 0;
         }
 
         $count = 0;
+        $rows = [];
         foreach ($files as $file) {
-            if (self::sync($file, $withVector)) {
+            // 文件夹不索引
+            if ($file->type === 'folder') {
                 $count++;
+                continue;
+            }
+            // 超限文件删除旧索引
+            if ($file->size > self::getMaxFileSizeByExt($file->ext)) {
+                self::delete($file->id);
+                $count++;
+                continue;
+            }
+            try {
+                $rows[] = self::buildRow($file);
+            } catch (\Exception $e) {
+                Log::error('Manticore file batchSync build error: ' . $e->getMessage(), [
+                    'file_id' => $file->id,
+                ]);
             }
         }
-        return $count;
+
+        return $count + ManticoreBase::batchUpsertVectors('file', $rows);
     }
 
     /**
@@ -497,27 +502,6 @@ class ManticoreFile
         return $result['data'] ?? '';
     }
 
-    /**
-     * 构建用于生成向量的内容
-     * 包含文件名和文件内容，确保语义搜索能匹配文件名
-     *
-     * @param string $fileName 文件名
-     * @param string $content 文件内容
-     * @return string 用于生成向量的文本
-     */
-    private static function buildVectorContent(string $fileName, string $content): string
-    {
-        $parts = [];
-
-        if (!empty($fileName)) {
-            $parts[] = $fileName;
-        }
-        if (!empty($content)) {
-            $parts[] = $content;
-        }
-
-        return implode(' ', $parts);
-    }
 
     /**
      * 清空所有索引
@@ -577,94 +561,4 @@ class ManticoreFile
             return false;
         }
     }
-
-    // ==============================
-    // 批量向量生成方法
-    // ==============================
-
-    /**
-     * 批量生成文件向量
-     * 用于后台异步处理，将已索引文件的向量批量生成
-     *
-     * @param array $fileIds 文件ID数组
-     * @param int $batchSize 每批 embedding 数量（默认20）
-     * @return int 成功处理的数量
-     */
-    public static function generateVectorsBatch(array $fileIds, int $batchSize = 20): int
-    {
-        if (!Apps::isInstalled("search") || !Apps::isInstalled("ai") || empty($fileIds)) {
-            return 0;
-        }
-
-        try {
-            // 1. 查询文件信息
-            $files = File::whereIn('id', $fileIds)
-                ->where('type', '!=', 'folder')
-                ->get();
-
-            if ($files->isEmpty()) {
-                return 0;
-            }
-
-            // 2. 提取每个文件的内容（包含文件名）
-            $fileContents = [];
-            foreach ($files as $file) {
-                // 检查文件大小限制
-                $maxSize = self::getMaxFileSizeByExt($file->ext);
-                if ($file->size > $maxSize) {
-                    continue;
-                }
-
-                $content = self::extractFileContent($file);
-                // 向量内容包含文件名和文件内容
-                $vectorContent = self::buildVectorContent($file->name, $content);
-                if (!empty($vectorContent)) {
-                    // 限制内容长度
-                    $vectorContent = mb_substr($vectorContent, 0, self::MAX_CONTENT_LENGTH);
-                    $fileContents[$file->id] = $vectorContent;
-                }
-            }
-
-            if (empty($fileContents)) {
-                return 0;
-            }
-
-            // 3. 分批处理
-            $successCount = 0;
-            $chunks = array_chunk($fileContents, $batchSize, true);
-
-            foreach ($chunks as $chunk) {
-                $texts = array_values($chunk);
-                $ids = array_keys($chunk);
-
-                // 4. 批量获取 embedding
-                $result = AI::getBatchEmbeddings($texts);
-                if (!Base::isSuccess($result) || empty($result['data'])) {
-                    continue;
-                }
-
-                $embeddings = $result['data'];
-
-                // 5. 构建批量更新数据
-                $vectorData = [];
-                foreach ($ids as $index => $fileId) {
-                    if (!isset($embeddings[$index]) || empty($embeddings[$index])) {
-                        continue;
-                    }
-                    $vectorData[$fileId] = '[' . implode(',', $embeddings[$index]) . ']';
-                }
-
-                // 6. 批量更新向量
-                if (!empty($vectorData)) {
-                    $batchCount = ManticoreBase::batchUpdateFileVectors($vectorData);
-                    $successCount += $batchCount;
-                }
-            }
-
-            return $successCount;
-        } catch (\Exception $e) {
-            Log::error('ManticoreFile generateVectorsBatch error: ' . $e->getMessage());
-            return 0;
-        }
-    }
 }

app/Module/Manticore/ManticoreMsg.php

@@ -5,8 +5,6 @@ namespace App\Module\Manticore;
 use App\Models\WebSocketDialogMsg;
 use App\Models\WebSocketDialogUser;
 use App\Module\Apps;
-use App\Module\Base;
-use App\Module\AI;
 use Carbon\Carbon;
 use DB;
 use Illuminate\Support\Facades\Log;
@@ -39,7 +37,8 @@ class ManticoreMsg
     public const INDEXABLE_TYPES = ['text', 'file', 'record', 'meeting', 'vote'];
 
     /**
-     * 最大内容长度（字符）
+     * 最大内容长度（字符）。向量化输入在 ai 插件侧另有 30000 字符上限
+     * （main.py _EMBEDDING_INPUT_MAX_CHARS），超出部分只参与全文检索
      */
     public const MAX_CONTENT_LENGTH = 50000; // 50K 字符
 
@@ -328,13 +327,12 @@ class ManticoreMsg
     // ==============================
 
     /**
-     * 同步单个消息到 Manticore（含 allowed_users）
+     * 同步单个消息到 Manticore（含 allowed_users，向量由引擎 Auto Embeddings 自动生成）
      *
      * @param WebSocketDialogMsg $msg 消息模型
-     * @param bool $withVector 是否同时生成向量（默认 false，向量由后台任务生成）
      * @return bool 是否成功
      */
-    public static function sync(WebSocketDialogMsg $msg, bool $withVector = false): bool
+    public static function sync(WebSocketDialogMsg $msg): bool
     {
         if (!Apps::isInstalled("search")) {
             return false;
@@ -347,37 +345,7 @@ class ManticoreMsg
         }
 
         try {
-            // 提取消息内容（使用 key 字段）
+            return ManticoreBase::upsertMsgVector(self::buildRow($msg));
-            $content = $msg->key ?? '';
-
-            // 限制内容长度
-            $content = mb_substr($content, 0, self::MAX_CONTENT_LENGTH);
-
-            // 只有明确要求时才生成向量（默认不生成，由后台任务处理）
-            $embedding = null;
-            if ($withVector && !empty($content) && Apps::isInstalled('ai')) {
-                $embeddingResult = ManticoreBase::getEmbedding($content);
-                if (!empty($embeddingResult)) {
-                    $embedding = '[' . implode(',', $embeddingResult) . ']';
-                }
-            }
-
-            // 获取消息的 allowed_users
-            $allowedUsers = self::getAllowedUsers($msg);
-
-            // 写入 Manticore（含 allowed_users）
-            $result = ManticoreBase::upsertMsgVector([
-                'msg_id' => $msg->id,
-                'dialog_id' => $msg->dialog_id,
-                'userid' => $msg->userid,
-                'msg_type' => $msg->type,
-                'content' => $content,
-                'content_vector' => $embedding,
-                'allowed_users' => $allowedUsers,
-                'created_at' => $msg->created_at ? $msg->created_at->timestamp : time(),
-            ]);
-
-            return $result;
         } catch (\Exception $e) {
             Log::error('Manticore msg sync error: ' . $e->getMessage(), [
                 'msg_id' => $msg->id,
@@ -388,106 +356,59 @@ class ManticoreMsg
     }
 
     /**
-     * 批量同步消息
+     * 构建消息索引行数据（含 allowed_users）
+     *
+     * @param WebSocketDialogMsg $msg 消息模型
+     * @return array 行数据
+     */
+    private static function buildRow(WebSocketDialogMsg $msg): array
+    {
+        // 提取消息内容（使用 key 字段）并限制长度
+        $content = mb_substr($msg->key ?? '', 0, self::MAX_CONTENT_LENGTH);
+
+        return [
+            'id' => $msg->id,
+            'msg_id' => $msg->id,
+            'dialog_id' => $msg->dialog_id,
+            'userid' => $msg->userid,
+            'msg_type' => $msg->type,
+            'content' => $content,
+            'allowed_users' => self::getAllowedUsers($msg),
+            'created_at' => $msg->created_at ? $msg->created_at->timestamp : time(),
+        ];
+    }
+
+    /**
+     * 批量同步消息（每块一条多行 REPLACE，向量由引擎自动生成）
      *
      * @param iterable $msgs 消息列表
-     * @param bool $withVector 是否同时生成向量
      * @return int 成功同步的数量
      */
-    public static function batchSync(iterable $msgs, bool $withVector = false): int
+    public static function batchSync(iterable $msgs): int
     {
         if (!Apps::isInstalled("search")) {
             return 0;
         }
 
         $count = 0;
+        $rows = [];
         foreach ($msgs as $msg) {
-            if (self::sync($msg, $withVector)) {
+            if (!self::shouldIndex($msg)) {
+                if (ManticoreBase::deleteMsgVector($msg->id)) {
                     $count++;
                 }
-        }
-        return $count;
-    }
-
-    /**
-     * 批量生成向量（供后台任务调用）
-     *
-     * @param array $msgIds 消息ID数组
-     * @param int $batchSize 每批 embedding 数量
-     * @return int 成功生成向量的数量
-     */
-    public static function generateVectorsBatch(array $msgIds, int $batchSize = 20): int
-    {
-        if (!Apps::isInstalled("search") || !Apps::isInstalled('ai') || empty($msgIds)) {
-            return 0;
-        }
-
-        $count = 0;
-
-        // 分批处理
-        foreach (array_chunk($msgIds, $batchSize) as $batchIds) {
-            // 获取消息
-            $msgs = WebSocketDialogMsg::whereIn('id', $batchIds)
-                ->whereIn('type', self::INDEXABLE_TYPES)
-                ->where('bot', '!=', 1)
-                ->whereNotNull('key')
-                ->where('key', '!=', '')
-                ->get()
-                ->keyBy('id');
-
-            if ($msgs->isEmpty()) {
                 continue;
             }
-
+            try {
-            // 准备文本
+                $rows[] = self::buildRow($msg);
-            $texts = [];
+            } catch (\Exception $e) {
-            $idsArray = [];
+                Log::error('Manticore msg batchSync build error: ' . $e->getMessage(), [
-            foreach ($batchIds as $id) {
+                    'msg_id' => $msg->id,
-                if (isset($msgs[$id])) {
+                ]);
-                    $content = mb_substr($msgs[$id]->key ?? '', 0, self::MAX_CONTENT_LENGTH);
-                    if (!empty($content)) {
-                        $texts[] = $content;
-                        $idsArray[] = $id;
-                    }
-                }
-            }
-
-            if (empty($texts)) {
-                continue;
-            }
-
-            // 批量获取 embeddings
-            $result = AI::getBatchEmbeddings($texts);
-
-            if (Base::isError($result)) {
-                continue;
-            }
-
-            $embeddings = $result['data'] ?? [];
-
-            // 构建批量更新数据 [msg_id => vectorStr]
-            $vectorData = [];
-            foreach ($embeddings as $index => $embedding) {
-                if (empty($embedding) || !is_array($embedding)) {
-                    continue;
-                }
-
-                $msgId = $idsArray[$index] ?? null;
-                if (!$msgId) {
-                    continue;
-                }
-
-                $vectorData[$msgId] = '[' . implode(',', $embedding) . ']';
-            }
-
-            // 批量更新向量（优化：减少数据库操作次数）
-            if (!empty($vectorData)) {
-                $batchCount = ManticoreBase::batchUpdateMsgVectors($vectorData);
-                $count += $batchCount;
             }
         }
 
-        return $count;
+        return $count + ManticoreBase::batchUpsertVectors('msg', $rows);
     }
 
     /**

app/Module/Manticore/ManticoreProject.php

@@ -5,8 +5,6 @@ namespace App\Module\Manticore;
 use App\Models\Project;
 use App\Models\ProjectUser;
 use App\Module\Apps;
-use App\Module\Base;
-use App\Module\AI;
 use Illuminate\Support\Facades\Log;
 
 /**
@@ -122,13 +120,12 @@ class ManticoreProject
     }
 
     /**
-     * 同步单个项目到 Manticore（含 allowed_users）
+     * 同步单个项目到 Manticore（含 allowed_users，向量由引擎 Auto Embeddings 自动生成）
      *
      * @param Project $project 项目模型
-     * @param bool $withVector 是否同时生成向量（默认 false，向量由后台任务生成）
      * @return bool 是否成功
      */
-    public static function sync(Project $project, bool $withVector = false): bool
+    public static function sync(Project $project): bool
     {
         if (!Apps::isInstalled("search")) {
             return false;
@@ -140,33 +137,7 @@ class ManticoreProject
         }
 
         try {
-            // 构建用于搜索的文本内容
+            return ManticoreBase::upsertProjectVector(self::buildRow($project));
-            $searchableContent = self::buildSearchableContent($project);
-
-            // 只有明确要求时才生成向量（默认不生成，由后台任务处理）
-            $embedding = null;
-            if ($withVector && !empty($searchableContent) && Apps::isInstalled('ai')) {
-                $embeddingResult = ManticoreBase::getEmbedding($searchableContent);
-                if (!empty($embeddingResult)) {
-                    $embedding = '[' . implode(',', $embeddingResult) . ']';
-                }
-            }
-
-            // 获取项目成员列表（作为 allowed_users）
-            $allowedUsers = self::getAllowedUsers($project->id);
-
-            // 写入 Manticore（含 allowed_users）
-            $result = ManticoreBase::upsertProjectVector([
-                'project_id' => $project->id,
-                'userid' => $project->userid ?? 0,
-                'personal' => $project->personal ?? 0,
-                'project_name' => $project->name ?? '',
-                'project_desc' => $project->desc ?? '',
-                'content_vector' => $embedding,
-                'allowed_users' => $allowedUsers,
-            ]);
-
-            return $result;
         } catch (\Exception $e) {
             Log::error('Manticore project sync error: ' . $e->getMessage(), [
                 'project_id' => $project->id,
@@ -177,45 +148,55 @@ class ManticoreProject
     }
 
     /**
-     * 构建可搜索的文本内容
+     * 构建项目索引行数据（含 allowed_users）
      *
      * @param Project $project 项目模型
-     * @return string 可搜索的文本
+     * @return array 行数据
      */
-    private static function buildSearchableContent(Project $project): string
+    private static function buildRow(Project $project): array
     {
-        $parts = [];
+        return [
-
+            'id' => $project->id,
-        if (!empty($project->name)) {
+            'project_id' => $project->id,
-            $parts[] = $project->name;
+            'userid' => $project->userid ?? 0,
-        }
+            'personal' => $project->personal ?? 0,
-        if (!empty($project->desc)) {
+            'project_name' => $project->name ?? '',
-            $parts[] = $project->desc;
+            'project_desc' => $project->desc ?? '',
-        }
+            'allowed_users' => self::getAllowedUsers($project->id),
-
+        ];
-        return implode(' ', $parts);
     }
 
     /**
-     * 批量同步项目
+     * 批量同步项目（每块一条多行 REPLACE，向量由引擎自动生成）
      *
      * @param iterable $projects 项目列表
-     * @param bool $withVector 是否同时生成向量
      * @return int 成功同步的数量
      */
-    public static function batchSync(iterable $projects, bool $withVector = false): int
+    public static function batchSync(iterable $projects): int
     {
         if (!Apps::isInstalled("search")) {
             return 0;
         }
 
         $count = 0;
+        $rows = [];
         foreach ($projects as $project) {
-            if (self::sync($project, $withVector)) {
+            if ($project->archived_at) {
+                if (self::delete($project->id)) {
                     $count++;
                 }
+                continue;
             }
-        return $count;
+            try {
+                $rows[] = self::buildRow($project);
+            } catch (\Exception $e) {
+                Log::error('Manticore project batchSync build error: ' . $e->getMessage(), [
+                    'project_id' => $project->id,
+                ]);
+            }
+        }
+
+        return $count + ManticoreBase::batchUpsertVectors('project', $rows);
     }
 
     /**
@@ -286,84 +267,4 @@ class ManticoreProject
             return false;
         }
     }
-
-    // ==============================
-    // 批量向量生成方法
-    // ==============================
-
-    /**
-     * 批量生成项目向量
-     * 用于后台异步处理，将已索引项目的向量批量生成
-     *
-     * @param array $projectIds 项目ID数组
-     * @param int $batchSize 每批 embedding 数量（默认20）
-     * @return int 成功处理的数量
-     */
-    public static function generateVectorsBatch(array $projectIds, int $batchSize = 20): int
-    {
-        if (!Apps::isInstalled("search") || !Apps::isInstalled("ai") || empty($projectIds)) {
-            return 0;
-        }
-
-        try {
-            // 1. 查询项目信息
-            $projects = Project::whereIn('id', $projectIds)
-                ->whereNull('archived_at')
-                ->get();
-
-            if ($projects->isEmpty()) {
-                return 0;
-            }
-
-            // 2. 提取每个项目的内容
-            $projectContents = [];
-            foreach ($projects as $project) {
-                $searchableContent = self::buildSearchableContent($project);
-                if (!empty($searchableContent)) {
-                    $projectContents[$project->id] = $searchableContent;
-                }
-            }
-
-            if (empty($projectContents)) {
-                return 0;
-            }
-
-            // 3. 分批处理
-            $successCount = 0;
-            $chunks = array_chunk($projectContents, $batchSize, true);
-
-            foreach ($chunks as $chunk) {
-                $texts = array_values($chunk);
-                $ids = array_keys($chunk);
-
-                // 4. 批量获取 embedding
-                $result = AI::getBatchEmbeddings($texts);
-                if (!Base::isSuccess($result) || empty($result['data'])) {
-                    continue;
-                }
-
-                $embeddings = $result['data'];
-
-                // 5. 构建批量更新数据
-                $vectorData = [];
-                foreach ($ids as $index => $projectId) {
-                    if (!isset($embeddings[$index]) || empty($embeddings[$index])) {
-                        continue;
-                    }
-                    $vectorData[$projectId] = '[' . implode(',', $embeddings[$index]) . ']';
-                }
-
-                // 6. 批量更新向量
-                if (!empty($vectorData)) {
-                    $batchCount = ManticoreBase::batchUpdateProjectVectors($vectorData);
-                    $successCount += $batchCount;
-                }
-            }
-
-            return $successCount;
-        } catch (\Exception $e) {
-            Log::error('ManticoreProject generateVectorsBatch error: ' . $e->getMessage());
-            return 0;
-        }
-    }
 }

app/Module/Manticore/ManticoreTask.php

@@ -9,7 +9,6 @@ use App\Models\ProjectTaskVisibilityUser;
 use App\Models\ProjectUser;
 use App\Module\Apps;
 use App\Module\Base;
-use App\Module\AI;
 use Illuminate\Support\Facades\Log;
 
 /**
@@ -42,7 +41,8 @@ use Illuminate\Support\Facades\Log;
 class ManticoreTask
 {
     /**
-     * 最大内容长度（字符）
+     * 最大内容长度（字符）。向量化输入在 ai 插件侧另有 30000 字符上限
+     * （main.py _EMBEDDING_INPUT_MAX_CHARS），超出部分只参与全文检索
      */
     public const MAX_CONTENT_LENGTH = 50000; // 50K 字符
 
@@ -189,13 +189,12 @@ class ManticoreTask
     // ==============================
 
     /**
-     * 同步单个任务到 Manticore（含 allowed_users）
+     * 同步单个任务到 Manticore（含 allowed_users，向量由引擎 Auto Embeddings 自动生成）
      *
      * @param ProjectTask $task 任务模型
-     * @param bool $withVector 是否同时生成向量（默认 false，向量由后台任务生成）
      * @return bool 是否成功
      */
-    public static function sync(ProjectTask $task, bool $withVector = false): bool
+    public static function sync(ProjectTask $task): bool
     {
         if (!Apps::isInstalled("search")) {
             return false;
@@ -207,38 +206,7 @@ class ManticoreTask
         }
 
         try {
-            // 获取任务详细内容
+            return ManticoreBase::upsertTaskVector(self::buildRow($task));
-            $taskContent = self::getTaskContent($task);
-
-            // 构建用于搜索的文本内容
-            $searchableContent = self::buildSearchableContent($task, $taskContent);
-
-            // 只有明确要求时才生成向量（默认不生成，由后台任务处理）
-            $embedding = null;
-            if ($withVector && !empty($searchableContent) && Apps::isInstalled('ai')) {
-                $embeddingResult = ManticoreBase::getEmbedding($searchableContent);
-                if (!empty($embeddingResult)) {
-                    $embedding = '[' . implode(',', $embeddingResult) . ']';
-                }
-            }
-
-            // 获取任务的 allowed_users
-            $allowedUsers = self::getAllowedUsers($task);
-
-            // 写入 Manticore（含 allowed_users）
-            $result = ManticoreBase::upsertTaskVector([
-                'task_id' => $task->id,
-                'project_id' => $task->project_id ?? 0,
-                'userid' => $task->userid ?? 0,
-                'visibility' => $task->visibility ?? 1,
-                'task_name' => $task->name ?? '',
-                'task_desc' => $task->desc ?? '',
-                'task_content' => $taskContent,
-                'content_vector' => $embedding,
-                'allowed_users' => $allowedUsers,
-            ]);
-
-            return $result;
         } catch (\Exception $e) {
             Log::error('Manticore task sync error: ' . $e->getMessage(), [
                 'task_id' => $task->id,
@@ -248,6 +216,27 @@ class ManticoreTask
         }
     }
 
+    /**
+     * 构建任务索引行数据（含详细内容与 allowed_users）
+     *
+     * @param ProjectTask $task 任务模型
+     * @return array 行数据
+     */
+    private static function buildRow(ProjectTask $task): array
+    {
+        return [
+            'id' => $task->id,
+            'task_id' => $task->id,
+            'project_id' => $task->project_id ?? 0,
+            'userid' => $task->userid ?? 0,
+            'visibility' => $task->visibility ?? 1,
+            'task_name' => $task->name ?? '',
+            'task_desc' => $task->desc ?? '',
+            'task_content' => self::getTaskContent($task),
+            'allowed_users' => self::getAllowedUsers($task),
+        ];
+    }
+
     /**
      * 获取任务详细内容
      *
@@ -311,49 +300,36 @@ class ManticoreTask
     }
 
     /**
-     * 构建可搜索的文本内容
+     * 批量同步任务（每块一条多行 REPLACE，向量由引擎自动生成）
-     *
-     * @param ProjectTask $task 任务模型
-     * @param string $taskContent 任务详细内容
-     * @return string 可搜索的文本
-     */
-    private static function buildSearchableContent(ProjectTask $task, string $taskContent): string
-    {
-        $parts = [];
-
-        if (!empty($task->name)) {
-            $parts[] = $task->name;
-        }
-        if (!empty($task->desc)) {
-            $parts[] = $task->desc;
-        }
-        if (!empty($taskContent)) {
-            $parts[] = $taskContent;
-        }
-
-        return implode(' ', $parts);
-    }
-
-    /**
-     * 批量同步任务
      *
      * @param iterable $tasks 任务列表
-     * @param bool $withVector 是否同时生成向量
      * @return int 成功同步的数量
      */
-    public static function batchSync(iterable $tasks, bool $withVector = false): int
+    public static function batchSync(iterable $tasks): int
     {
         if (!Apps::isInstalled("search")) {
             return 0;
         }
 
         $count = 0;
+        $rows = [];
         foreach ($tasks as $task) {
-            if (self::sync($task, $withVector)) {
+            if ($task->archived_at || $task->deleted_at) {
+                if (self::delete($task->id)) {
                     $count++;
                 }
+                continue;
             }
-        return $count;
+            try {
+                $rows[] = self::buildRow($task);
+            } catch (\Exception $e) {
+                Log::error('Manticore task batchSync build error: ' . $e->getMessage(), [
+                    'task_id' => $task->id,
+                ]);
+            }
+        }
+
+        return $count + ManticoreBase::batchUpsertVectors('task', $rows);
     }
 
     /**
@@ -506,88 +482,4 @@ class ManticoreTask
             Log::error('Manticore cascadeToChildren error: ' . $e->getMessage(), ['task_id' => $taskId]);
         }
     }
-
-    // ==============================
-    // 批量向量生成方法
-    // ==============================
-
-    /**
-     * 批量生成任务向量
-     * 用于后台异步处理，将已索引任务的向量批量生成
-     *
-     * @param array $taskIds 任务ID数组
-     * @param int $batchSize 每批 embedding 数量（默认20）
-     * @return int 成功处理的数量
-     */
-    public static function generateVectorsBatch(array $taskIds, int $batchSize = 20): int
-    {
-        if (!Apps::isInstalled("search") || !Apps::isInstalled("ai") || empty($taskIds)) {
-            return 0;
-        }
-
-        try {
-            // 1. 查询任务信息
-            $tasks = ProjectTask::whereIn('id', $taskIds)
-                ->whereNull('deleted_at')
-                ->whereNull('archived_at')
-                ->get();
-
-            if ($tasks->isEmpty()) {
-                return 0;
-            }
-
-            // 2. 提取每个任务的内容
-            $taskContents = [];
-            foreach ($tasks as $task) {
-                $taskContent = self::getTaskContent($task);
-                $searchableContent = self::buildSearchableContent($task, $taskContent);
-                if (!empty($searchableContent)) {
-                    // 限制内容长度
-                    $searchableContent = mb_substr($searchableContent, 0, self::MAX_CONTENT_LENGTH);
-                    $taskContents[$task->id] = $searchableContent;
-                }
-            }
-
-            if (empty($taskContents)) {
-                return 0;
-            }
-
-            // 3. 分批处理
-            $successCount = 0;
-            $chunks = array_chunk($taskContents, $batchSize, true);
-
-            foreach ($chunks as $chunk) {
-                $texts = array_values($chunk);
-                $ids = array_keys($chunk);
-
-                // 4. 批量获取 embedding
-                $result = AI::getBatchEmbeddings($texts);
-                if (!Base::isSuccess($result) || empty($result['data'])) {
-                    continue;
-                }
-
-                $embeddings = $result['data'];
-
-                // 5. 构建批量更新数据
-                $vectorData = [];
-                foreach ($ids as $index => $taskId) {
-                    if (!isset($embeddings[$index]) || empty($embeddings[$index])) {
-                        continue;
-                    }
-                    $vectorData[$taskId] = '[' . implode(',', $embeddings[$index]) . ']';
-                }
-
-                // 6. 批量更新向量
-                if (!empty($vectorData)) {
-                    $batchCount = ManticoreBase::batchUpdateTaskVectors($vectorData);
-                    $successCount += $batchCount;
-                }
-            }
-
-            return $successCount;
-        } catch (\Exception $e) {
-            Log::error('ManticoreTask generateVectorsBatch error: ' . $e->getMessage());
-            return 0;
-        }
-    }
 }

app/Module/Manticore/ManticoreUser.php

@@ -5,8 +5,6 @@ namespace App\Module\Manticore;
 use App\Models\User;
 use App\Models\UserTag;
 use App\Module\Apps;
-use App\Module\Base;
-use App\Module\AI;
 use Illuminate\Support\Facades\Log;
 
 /**
@@ -123,13 +121,12 @@ class ManticoreUser
     }
 
     /**
-     * 同步单个用户到 Manticore
+     * 同步单个用户到 Manticore（向量由引擎 Auto Embeddings 按行内文本自动生成）
      *
      * @param User $user 用户模型
-     * @param bool $withVector 是否同时生成向量（默认 false，向量由后台任务生成）
      * @return bool 是否成功
      */
-    public static function sync(User $user, bool $withVector = false): bool
+    public static function sync(User $user): bool
     {
         if (!Apps::isInstalled("search")) {
             return false;
@@ -146,33 +143,13 @@ class ManticoreUser
         }
 
         try {
-            // 获取用户标签（Top 10）
+            $row = self::buildRow($user);
-            $tags = self::getUserTags($user->userid);
+            // 脏检查：与已索引行完全一致则跳过。标签点赞/识别等高频事件经常不改变
-
+            // Top-10 标签文本，跳过可省一次真实的向量化调用与整行重写
-            // 构建用于搜索的文本内容
+            if (self::rowUnchanged($row)) {
-            $searchableContent = self::buildSearchableContent($user, $tags);
+                return true;
-
-            // 只有明确要求时才生成向量（默认不生成，由后台任务处理）
-            $embedding = null;
-            if ($withVector && !empty($searchableContent) && Apps::isInstalled('ai')) {
-                $embeddingResult = ManticoreBase::getEmbedding($searchableContent);
-                if (!empty($embeddingResult)) {
-                    $embedding = '[' . implode(',', $embeddingResult) . ']';
             }
-            }
+            return ManticoreBase::upsertUserVector($row);
-
-            // 写入 Manticore
-            $result = ManticoreBase::upsertUserVector([
-                'userid' => $user->userid,
-                'nickname' => $user->nickname ?? '',
-                'email' => $user->email ?? '',
-                'profession' => $user->profession ?? '',
-                'tags' => $tags,
-                'introduction' => $user->introduction ?? '',
-                'content_vector' => $embedding,
-            ]);
-
-            return $result;
         } catch (\Exception $e) {
             Log::error('Manticore user sync error: ' . $e->getMessage(), [
                 'userid' => $user->userid,
@@ -183,55 +160,81 @@ class ManticoreUser
     }
 
     /**
-     * 构建可搜索的文本内容
+     * 判断待写入行与当前已索引行是否完全一致（文本字段逐一比较）
-     *
-     * @param User $user 用户模型
-     * @param string $tags 用户标签（空格分隔）
-     * @return string 可搜索的文本
      */
-    private static function buildSearchableContent(User $user, string $tags = ''): string
+    private static function rowUnchanged(array $row): bool
     {
-        $parts = [];
+        $existing = (new ManticoreBase())->queryOne(
-
+            "SELECT nickname, email, profession, tags, introduction FROM user_vectors WHERE userid = ?",
-        if (!empty($user->nickname)) {
+            [$row['userid']]
-            $parts[] = $user->nickname;
+        );
+        if (!$existing) {
+            return false;
         }
-        if (!empty($user->email)) {
+        foreach (['nickname', 'email', 'profession', 'tags', 'introduction'] as $field) {
-            $parts[] = $user->email;
+            if ((string) ($existing[$field] ?? '') !== (string) $row[$field]) {
+                return false;
             }
-        if (!empty($user->profession)) {
-            $parts[] = $user->profession;
         }
-        if (!empty($tags)) {
+        return true;
-            $parts[] = $tags;
-        }
-        if (!empty($user->introduction)) {
-            $parts[] = $user->introduction;
-        }
-
-        return implode(' ', $parts);
     }
 
     /**
-     * 批量同步用户
+     * 构建用户索引行数据（含标签 Top 10）
+     *
+     * @param User $user 用户模型
+     * @return array 行数据
+     */
+    private static function buildRow(User $user): array
+    {
+        $tags = self::getUserTags($user->userid);
+
+        return [
+            'id' => $user->userid,
+            'userid' => $user->userid,
+            'nickname' => $user->nickname ?? '',
+            'email' => $user->email ?? '',
+            'profession' => $user->profession ?? '',
+            'tags' => $tags,
+            'introduction' => $user->introduction ?? '',
+        ];
+    }
+
+    /**
+     * 批量同步用户（每块一条多行 REPLACE，向量由引擎自动生成）
      *
      * @param iterable $users 用户列表
-     * @param bool $withVector 是否同时生成向量
      * @return int 成功同步的数量
      */
-    public static function batchSync(iterable $users, bool $withVector = false): int
+    public static function batchSync(iterable $users): int
     {
         if (!Apps::isInstalled("search")) {
             return 0;
         }
 
         $count = 0;
+        $rows = [];
         foreach ($users as $user) {
-            if (self::sync($user, $withVector)) {
+            if ($user->bot) {
+                $count++;
+                continue;
+            }
+            if ($user->disable_at) {
+                if (self::delete($user->userid)) {
                     $count++;
                 }
+                continue;
             }
-        return $count;
+            try {
+                $rows[] = self::buildRow($user);
+            } catch (\Exception $e) {
+                Log::error('Manticore user batchSync build error: ' . $e->getMessage(), [
+                    'userid' => $user->userid,
+                ]);
+            }
+        }
+
+        return $count + ManticoreBase::batchUpsertVectors('user', $rows);
     }
 
     /**
@@ -276,87 +279,4 @@ class ManticoreUser
 
         return ManticoreBase::getIndexedUserCount();
     }
-
-    // ==============================
-    // 批量向量生成方法
-    // ==============================
-
-    /**
-     * 批量生成用户向量
-     * 用于后台异步处理，将已索引用户的向量批量生成
-     *
-     * @param array $userIds 用户ID数组
-     * @param int $batchSize 每批 embedding 数量（默认20）
-     * @return int 成功处理的数量
-     */
-    public static function generateVectorsBatch(array $userIds, int $batchSize = 20): int
-    {
-        if (!Apps::isInstalled("search") || !Apps::isInstalled("ai") || empty($userIds)) {
-            return 0;
-        }
-
-        try {
-            // 1. 查询用户信息
-            $users = User::whereIn('userid', $userIds)
-                ->where('bot', 0)
-                ->whereNull('disable_at')
-                ->get();
-
-            if ($users->isEmpty()) {
-                return 0;
-            }
-
-            // 2. 提取每个用户的内容（包含标签）
-            $userContents = [];
-            foreach ($users as $user) {
-                $tags = self::getUserTags($user->userid);
-                $searchableContent = self::buildSearchableContent($user, $tags);
-                if (!empty($searchableContent)) {
-                    $userContents[$user->userid] = $searchableContent;
-                }
-            }
-
-            if (empty($userContents)) {
-                return 0;
-            }
-
-            // 3. 分批处理
-            $successCount = 0;
-            $chunks = array_chunk($userContents, $batchSize, true);
-
-            foreach ($chunks as $chunk) {
-                $texts = array_values($chunk);
-                $ids = array_keys($chunk);
-
-                // 4. 批量获取 embedding
-                $result = AI::getBatchEmbeddings($texts);
-                if (!Base::isSuccess($result) || empty($result['data'])) {
-                    continue;
-                }
-
-                $embeddings = $result['data'];
-
-                // 5. 构建批量更新数据
-                $vectorData = [];
-                foreach ($ids as $index => $userid) {
-                    if (!isset($embeddings[$index]) || empty($embeddings[$index])) {
-                        continue;
-                    }
-                    $vectorData[$userid] = '[' . implode(',', $embeddings[$index]) . ']';
-                }
-
-                // 6. 批量更新向量
-                if (!empty($vectorData)) {
-                    $batchCount = ManticoreBase::batchUpdateUserVectors($vectorData);
-                    $successCount += $batchCount;
-                }
-            }
-
-            return $successCount;
-        } catch (\Exception $e) {
-            Log::error('ManticoreUser generateVectorsBatch error: ' . $e->getMessage());
-            return 0;
-        }
-    }
 }
-

app/Module/OnlineLicense.php

@@ -0,0 +1,485 @@
+<?php
+
+namespace App\Module;
+
+use App\Exceptions\ApiException;
+use App\Services\RequestContext;
+use Carbon\Carbon;
+use Illuminate\Support\Facades\Crypt;
+
+/**
+ * 在线授权客户端编排。
+ *
+ * 在线授权产出的仍是现有格式的离线 license blob，只是「获取方式」变成用 appstore 账号登录
+ * 自助签发、并由本类定时续期。doo.so 本地校验、license 文件存储全部复用。绑定状态以单例
+ * 形式存于 settings 表（name=onlineLicense），instance_token 用 Crypt 加密。
+ *
+ * 四级状态机（基于租约内嵌到期 lease_expired_at 与本地宽限，全程不依赖 appstore 可达）：
+ *   active   续期正常
+ *   reminder 续期失败/租约剩余不足 warn_days（仅管理员可见提醒）
+ *   frozen   租约已过期（doo.so 既有行为：限制新增用户）
+ *   revoked  冻结超过 grace_days 或 appstore 明确吊销 → 回落默认 3 人版
+ */
+class OnlineLicense
+{
+    const KEY = 'onlineLicense';
+
+    // ---- 配置 ----
+
+    protected static function appstoreUrl(): string
+    {
+        return rtrim((string)config('dootask.online_license_appstore_url'), '/');
+    }
+
+    protected static function renewWithinDays(): int
+    {
+        return (int)config('dootask.online_license_renew_within_days', 20);
+    }
+
+    protected static function warnDays(): int
+    {
+        return (int)config('dootask.online_license_warn_days', 7);
+    }
+
+    protected static function graceDays(): int
+    {
+        return (int)config('dootask.online_license_grace_days', 14);
+    }
+
+    // ---- 状态读写（单例 settings）----
+
+    public static function get(): array
+    {
+        return Base::setting(self::KEY) ?: [];
+    }
+
+    protected static function set(array $patch): array
+    {
+        $next = array_merge(self::get(), $patch);
+        Base::setting(self::KEY, $next);
+        return $next;
+    }
+
+    public static function enabled(): bool
+    {
+        $s = self::get();
+        return !empty($s['enabled']) && ($s['mode'] ?? '') === 'online';
+    }
+
+    protected static function token(): string
+    {
+        $enc = self::get()['instance_token'] ?? '';
+        if (empty($enc)) {
+            return '';
+        }
+        try {
+            return Crypt::decryptString($enc);
+        } catch (\Throwable) {
+            return '';
+        }
+    }
+
+    /**
+     * 当前请求语言，透传给 appstore 用于邮件按语言渲染（中文/繁体→中文，其余→英文）。
+     * 非请求上下文（如定时续期）返回空串，由 appstore 回落默认语言。
+     */
+    protected static function lang(): string
+    {
+        return (string)Base::headerOrInput('language');
+    }
+
+    protected static function fingerprint(): array
+    {
+        return [
+            'sn' => Doo::dooSN(),
+            'macs' => implode(',', Doo::macs()),
+            // 优先真实外网地址：config('app.url') 若为 localhost 由 replaceBaseUrl 替换为缓存的访问地址
+            'url' => RequestContext::replaceBaseUrl((string)config('app.url')),
+            // DooTask 应用版本（非 doo.so 库版本）
+            'version' => Base::getVersion(),
+        ];
+    }
+
+    // ---- appstore 调用 ----
+
+    /**
+     * 调 appstore license 接口。返回 ['ok'=>bool, 'data'=>array, 'message'=>string]。
+     * $bearer 非空时带实例令牌（续期/释放）。
+     */
+    protected static function call(string $path, array $payload, string $bearer = ''): array
+    {
+        $url = self::appstoreUrl() . '/api/v1/license/' . ltrim($path, '/');
+        $headers = ['Content-Type' => 'application/json'];
+        if ($bearer !== '') {
+            $headers['Authorization'] = 'Bearer ' . $bearer;
+        }
+        $resp = Ihttp::ihttp_request($url, json_encode($payload, JSON_UNESCAPED_UNICODE), $headers, 15);
+        if (Base::isError($resp)) {
+            return ['ok' => false, 'data' => [], 'message' => $resp['msg'] ?: '无法连接授权服务'];
+        }
+        $body = Base::json2array($resp['data'] ?? '');
+        if (($body['code'] ?? 0) !== 200) {
+            return ['ok' => false, 'data' => [], 'message' => $body['message'] ?: '授权服务返回错误'];
+        }
+        return ['ok' => true, 'data' => $body['data'] ?? [], 'message' => ''];
+    }
+
+    /**
+     * 处理签发结果：issued/renewed 则落地 license + 更新绑定状态；其它状态原样返回供上层决策。
+     */
+    protected static function applyIssue(string $account, array $d): string
+    {
+        $status = $d['status'] ?? '';
+        if (in_array($status, ['issued', 'renewed'], true)) {
+            $blob = $d['license'] ?? '';
+            if ($blob === '') {
+                throw new ApiException('授权服务未返回 license');
+            }
+            Doo::licenseSave($blob); // 复用离线落地与 doo.so 校验
+            $snap = $d['snapshot'] ?? [];
+            $patch = [
+                'enabled' => true,
+                'mode' => 'online',
+                'account' => $account,
+                'plan' => $snap['plan'] ?? '',
+                'people' => $snap['people'] ?? 0,
+                'valid_until' => $snap['valid_until'] ?? null,
+                'lease_expired_at' => $snap['lease_expired_at'] ?? null,
+                'server_status' => $status,
+                'error_count' => 0,
+                'last_error' => '',
+                'frozen_since' => null,
+                'last_renewed_at' => Carbon::now()->toDateTimeString(),
+            ];
+            if (!empty($d['instance_token'])) {
+                $patch['instance_token'] = Crypt::encryptString($d['instance_token']);
+            }
+            self::set($patch);
+            self::computeStage();
+        }
+        return $status;
+    }
+
+    // ---- 对外动作 ----
+
+    /**
+     * 发送邮箱验证码（登录与试用共用），返回脱敏邮箱。
+     */
+    public static function emailSend(string $email): string
+    {
+        $r = self::call('email/send', ['email' => $email, 'lang' => self::lang()]);
+        if (!$r['ok']) {
+            throw new ApiException($r['message']);
+        }
+        return $r['data']['email'] ?? '';
+    }
+
+    /**
+     * 邮箱 + 验证码登录并签发。失败抛 ApiException。
+     * 本机有多条可用授权时，appstore 返回 select_required + candidates，
+     * 此处不签发、原样返回候选，由前端选定后走 loginConfirm()。
+     */
+    public static function login(string $email, string $code): array
+    {
+        $r = self::call('login', array_merge(['email' => $email, 'code' => $code, 'lang' => self::lang()], self::fingerprint()));
+        if (!$r['ok']) {
+            throw new ApiException($r['message']);
+        }
+        $d = $r['data'];
+        if (($d['status'] ?? '') === 'select_required') {
+            return [
+                'select_required' => true,
+                'candidates' => $d['candidates'] ?? [],
+            ];
+        }
+        $status = self::applyIssue($email, $d);
+        if (!in_array($status, ['issued', 'renewed'], true)) {
+            throw new ApiException(self::statusHint($status));
+        }
+        return self::status();
+    }
+
+    /**
+     * 多条可用授权时，用户选定 $entitlementId 后确认签发（复用同一验证码）。失败抛 ApiException。
+     */
+    public static function loginConfirm(string $email, string $code, int $entitlementId): array
+    {
+        $payload = array_merge([
+            'email' => $email,
+            'code' => $code,
+            'entitlement_id' => $entitlementId,
+            'lang' => self::lang(),
+        ], self::fingerprint());
+        $r = self::call('login/confirm', $payload);
+        if (!$r['ok']) {
+            throw new ApiException($r['message']);
+        }
+        $status = self::applyIssue($email, $r['data']);
+        if (!in_array($status, ['issued', 'renewed'], true)) {
+            throw new ApiException(self::statusHint($status));
+        }
+        return self::status();
+    }
+
+    /**
+     * 邮箱 + 验证码申请试用并签发。
+     */
+    public static function trial(string $email, string $code): array
+    {
+        $payload = array_merge(['email' => $email, 'code' => $code, 'lang' => self::lang()], self::fingerprint());
+        $r = self::call('trial', $payload);
+        if (!$r['ok']) {
+            throw new ApiException($r['message']);
+        }
+        $status = self::applyIssue($email, $r['data']);
+        if (!in_array($status, ['issued', 'renewed'], true)) {
+            throw new ApiException(self::statusHint($status));
+        }
+        return self::status();
+    }
+
+    /**
+     * 续期（定时任务调用）。不抛异常：网络/服务错误只累加计数，最终由状态机本地降级。
+     */
+    public static function renew(): void
+    {
+        if (!self::enabled()) {
+            return;
+        }
+        $token = self::token();
+        if ($token === '') {
+            return;
+        }
+        $r = self::call('renew', self::fingerprint(), $token);
+        if (!$r['ok']) {
+            $s = self::get();
+            self::set([
+                'error_count' => (int)($s['error_count'] ?? 0) + 1,
+                'last_error' => $r['message'],
+            ]);
+            self::computeStage();
+            return;
+        }
+        $status = $r['data']['status'] ?? '';
+        if (in_array($status, ['issued', 'renewed'], true)) {
+            self::applyIssue(self::get()['account'] ?? '', $r['data']);
+            return;
+        }
+        // 服务侧明确状态（revoked/suspended/no_entitlement）：不延长租约，记录后交状态机
+        self::set(['server_status' => $status, 'last_error' => self::statusHint($status)]);
+        self::computeStage();
+    }
+
+    /**
+     * 是否到了该续期的时间（租约剩余不足 renew_within_days）。
+     */
+    public static function dueForRenew(): bool
+    {
+        $lease = self::get()['lease_expired_at'] ?? null;
+        if (!$lease) {
+            return true;
+        }
+        return Carbon::parse($lease)->lte(Carbon::now()->addDays(self::renewWithinDays()));
+    }
+
+    /**
+     * 定时续期入口：由容器内独立进程的 artisan 命令（online-license:renew）按小时调用。
+     * 先本地状态机推进（断网也能降级 frozen→revoked），再在租约将尽时续期。
+     */
+    public static function cron(): void
+    {
+        if (!self::enabled()) {
+            return;
+        }
+        self::computeStage();
+        if (self::enabled() && self::dueForRenew()) {
+            self::renew();
+        }
+    }
+
+    /**
+     * 进入授权页时的静默刷新：服务可达则按服务结果更新（成功续签 / 反映吊销冻结），
+     * 网络失败则什么都不做、不提示、不降级（避免一次页面刷新失败就误报）。
+     */
+    public static function refresh(): void
+    {
+        if (!self::enabled()) {
+            return;
+        }
+        $token = self::token();
+        if ($token === '') {
+            return;
+        }
+        try {
+            $r = self::call('renew', self::fingerprint(), $token);
+            if (!$r['ok']) {
+                return; // 刷新失败：不更新、不提示
+            }
+            $status = $r['data']['status'] ?? '';
+            if (in_array($status, ['issued', 'renewed'], true)) {
+                self::applyIssue(self::get()['account'] ?? '', $r['data']);
+            } elseif (in_array($status, ['revoked', 'suspended', 'no_entitlement'], true)) {
+                // 服务侧明确结果（非网络失败）：如实反映
+                self::set(['server_status' => $status, 'last_error' => self::statusHint($status)]);
+                self::computeStage();
+            }
+        } catch (\Throwable) {
+            // 忽略，保持现状
+        }
+    }
+
+    /**
+     * 退出在线授权：释放座位 + 回落默认。
+     */
+    public static function logout(): void
+    {
+        $token = self::token();
+        if ($token !== '') {
+            self::call('deactivate', [], $token);
+        }
+        self::fallbackToDefault();
+        Base::setting(self::KEY, ['enabled' => false, 'mode' => 'offline']);
+    }
+
+    /**
+     * 切换到离线授权（互斥）：保存离线 license 后调用。
+     * 尽力释放在线座位 + 清在线标志，但「不」删除 license 文件（刚保存的离线 license 要保留）。
+     */
+    public static function switchToOffline(): void
+    {
+        if (!self::enabled()) {
+            return;
+        }
+        $token = self::token();
+        if ($token !== '') {
+            self::call('deactivate', [], $token); // 尽力释放座位，失败忽略
+        }
+        Base::setting(self::KEY, ['enabled' => false, 'mode' => 'offline']);
+    }
+
+    // ---- 状态机 ----
+
+    /**
+     * 据租约到期 + 宽限重新计算 status，并在 revoked 时执行降级。
+     */
+    public static function computeStage(): string
+    {
+        $s = self::get();
+        if (($s['mode'] ?? '') !== 'online' || empty($s['enabled'])) {
+            return 'offline';
+        }
+        $now = Carbon::now();
+        $server = $s['server_status'] ?? '';
+        $lease = $s['lease_expired_at'] ?? null;
+
+        if ($server === 'revoked') {
+            return self::transitionRevoked();
+        }
+
+        if ($lease && Carbon::parse($lease)->lte($now)) {
+            // 租约已过期 → 冻结；超过宽限 → 吊销
+            $frozenSince = $s['frozen_since'] ?? null;
+            if (!$frozenSince) {
+                $frozenSince = $now->toDateTimeString();
+                self::set(['frozen_since' => $frozenSince]);
+            }
+            if (Carbon::parse($frozenSince)->addDays(self::graceDays())->lte($now)) {
+                return self::transitionRevoked();
+            }
+            self::set(['status' => 'frozen']);
+            return 'frozen';
+        }
+
+        // 租约有效
+        $remindByLease = $lease && Carbon::parse($lease)->lte($now->copy()->addDays(self::warnDays()));
+        $remindByError = (int)($s['error_count'] ?? 0) > 0 || $server === 'suspended' || $server === 'no_entitlement';
+        $status = ($remindByLease || $remindByError) ? 'reminder' : 'active';
+        self::set(['status' => $status, 'frozen_since' => null]);
+        return $status;
+    }
+
+    protected static function transitionRevoked(): string
+    {
+        self::fallbackToDefault();
+        self::set(['status' => 'revoked', 'enabled' => false]);
+        return 'revoked';
+    }
+
+    /**
+     * 删除在线 license 文件，让 dooso 回落默认 3 人版（触发既有超员禁用）。
+     */
+    protected static function fallbackToDefault(): void
+    {
+        foreach (['LICENSE', 'license'] as $name) {
+            $path = config_path($name);
+            if (is_file($path)) {
+                @unlink($path);
+            }
+        }
+    }
+
+    // ---- 提醒文案（注入 system/license 的 error[]，复用 dashboard 警告条与 license 页）----
+
+    public static function stageMessages(): array
+    {
+        if (!self::enabled() && (self::get()['status'] ?? '') !== 'revoked') {
+            return [];
+        }
+        $s = self::get();
+        $status = $s['status'] ?? self::computeStage();
+        $msgs = [];
+        switch ($status) {
+            case 'reminder':
+                if (($s['server_status'] ?? '') === 'suspended') {
+                    $msgs[] = '在线授权已被冻结，请联系服务商';
+                } elseif ((int)($s['error_count'] ?? 0) > 0) {
+                    $msgs[] = '在线授权续期失败，请检查网络';
+                } else {
+                    $msgs[] = '在线授权即将到期，请保持联网续期';
+                }
+                break;
+            case 'frozen':
+                $msgs[] = '在线授权已过期，新增用户受限，请尽快续期';
+                break;
+            case 'revoked':
+                $msgs[] = '在线授权已失效，已回落到基础版';
+                break;
+        }
+        return $msgs;
+    }
+
+    protected static function statusHint(string $status): string
+    {
+        return match ($status) {
+            'no_entitlement' => '该账号暂无可用授权，请先申请试用或购买',
+            'revoked' => '该授权已被吊销',
+            'suspended' => '该授权已被冻结',
+            'seat_taken' => '该授权已在另一台实例使用，请先在原实例释放（换机）',
+            'entitlement_expired' => '该授权已到期',
+            default => '签发失败（' . $status . '）',
+        };
+    }
+
+    /**
+     * 对外状态（前端在线 Tab / status 接口用，不含敏感 token）。
+     */
+    public static function status(): array
+    {
+        $s = self::get();
+        if (($s['mode'] ?? '') !== 'online' || empty($s['enabled'])) {
+            return ['mode' => 'offline'];
+        }
+        return [
+            'mode' => 'online',
+            'account' => $s['account'] ?? '',
+            'plan' => $s['plan'] ?? '',
+            'people' => $s['people'] ?? 0,
+            'valid_until' => $s['valid_until'] ?? null,
+            'lease_expired_at' => $s['lease_expired_at'] ?? null,
+            'last_renewed_at' => $s['last_renewed_at'] ?? null,
+            'status' => $s['status'] ?? self::computeStage(),
+            'error_count' => (int)($s['error_count'] ?? 0),
+            'last_error' => $s['last_error'] ?? '',
+        ];
+    }
+}

app/Module/PatchedAvatar.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Module;
+
+use Intervention\Image\Drivers\Gd\Driver as GdDriver;
+use Intervention\Image\Drivers\Imagick\Driver as ImagickDriver;
+use Intervention\Image\ImageManager;
+use Intervention\Image\Typography\FontFactory;
+use Laravolt\Avatar\Avatar;
+
+/**
+ * laravolt/avatar 6.5.0 的 buildAvatar 给纵向对齐传 'middle'，
+ * 而 intervention/image 4.1.3 的 Alignment 枚举仅接受 'center'，会抛
+ * InvalidArgumentException(Invalid value for alignment)。上游修复前以子类覆写修正。
+ */
+class PatchedAvatar extends Avatar
+{
+    public function buildAvatar(): static
+    {
+        $this->buildInitial();
+
+        $x = $this->width / 2;
+        $y = $this->height / 2;
+
+        $driver = $this->driver === 'gd' ? new GdDriver : new ImagickDriver;
+        $this->image = ImageManager::usingDriver($driver)->createImage($this->width, $this->height);
+
+        $this->createShape();
+
+        if (empty($this->initials)) {
+            return $this;
+        }
+
+        $this->image->text(
+            $this->initials,
+            (int) $x,
+            (int) $y,
+            function (FontFactory $font) {
+                $font->filepath($this->font);
+                $font->size($this->fontSize);
+                $font->color($this->foreground);
+                $font->align('center', 'center');
+            }
+        );
+
+        return $this;
+    }
+}

app/Module/Table/AbstractData.php

@@ -24,7 +24,8 @@ abstract class AbstractData
 
     protected function __construct()
     {
-        $this->table = app('swoole')->{$this->getTableName()};
+        // 非 Swoole 运行时（artisan/测试）无 swoole 绑定，table 为 null，各方法返回默认值
+        $this->table = app()->bound('swoole') ? app('swoole')->{$this->getTableName()} : null;
     }
 
     public function getTable()
@@ -42,22 +43,34 @@ abstract class AbstractData
 
     public static function set($key, $value)
     {
+        if (!self::instance()->table) {
+            return false;
+        }
         return self::instance()->table->set($key, ['value' => $value]);
     }
 
     public static function get($key, $default = null)
     {
+        if (!self::instance()->table) {
+            return $default;
+        }
         $data = self::instance()->table->get($key);
         return $data ? $data['value'] : $default;
     }
 
     public static function del($key)
     {
+        if (!self::instance()->table) {
+            return false;
+        }
         return self::instance()->table->del($key);
     }
 
     public static function exist($key)
     {
+        if (!self::instance()->table) {
+            return false;
+        }
         return self::instance()->table->exist($key);
     }
 
@@ -70,6 +83,9 @@ abstract class AbstractData
 
     public static function clear()
     {
+        if (!self::instance()->table) {
+            return;
+        }
         foreach (self::instance()->table as $key => $row) {
             self::del($key);
         }
@@ -77,6 +93,9 @@ abstract class AbstractData
 
     public static function getAll()
     {
+        if (!self::instance()->table) {
+            return [];
+        }
         $result = [];
         foreach (self::instance()->table as $key => $row) {
             $result[$key] = $row['value'];

app/Module/Table/OnlineData.php

@@ -17,6 +17,9 @@ class OnlineData extends AbstractData
      */
     public static function online($userid)
     {
+        if (!self::instance()->getTable()) {
+            return 0;
+        }
         $key = "online::" . $userid;
         $value = self::instance()->getTable()->incr($key, 'value');
         if ($value === 1) {
@@ -35,6 +38,9 @@ class OnlineData extends AbstractData
      */
     public static function offline($userid)
     {
+        if (!self::instance()->getTable()) {
+            return 0;
+        }
         $key = "online::" . $userid;
         $value = self::instance()->getTable()->decr($key, 'value');
         if ($value === 0) {
@@ -57,6 +63,9 @@ class OnlineData extends AbstractData
      */
     public static function live($userid)
     {
+        if (!self::instance()->getTable()) {
+            return 0;
+        }
         $key = "online::" . $userid;
         return intval(self::instance()->getTable()->get($key));
     }

app/Observers/UserObserver.php

@@ -4,6 +4,7 @@ namespace App\Observers;
 
 use App\Models\User;
 use App\Module\Apps;
+use App\Module\Badge;
 use App\Tasks\ManticoreSyncTask;
 
 class UserObserver extends AbstractObserver
@@ -80,6 +81,8 @@ class UserObserver extends AbstractObserver
             } elseif (!$originalDisableAt && $currentDisableAt) {
                 // disable_at 从 null 变为有值 → 离职 (offboarded)
                 Apps::dispatchUserHook($user, 'user_offboard', 'offboarded');
+                // 离职清除该用户全部应用角标
+                Badge::clearByUser((int)$user->userid);
             }
             return;
         }
@@ -122,6 +125,9 @@ class UserObserver extends AbstractObserver
         if (!$user->bot) {
             Apps::dispatchUserHook($user, 'user_offboard', 'delete');
         }
+
+        // 清除该用户全部应用角标
+        Badge::clearByUser((int)$user->userid);
     }
 }
 

app/Providers/AppServiceProvider.php

@@ -2,6 +2,40 @@
 
 namespace App\Providers;
 
+use App\Models\File;
+use App\Models\FileUser;
+use App\Models\Project;
+use App\Models\ProjectTask;
+use App\Models\ProjectTaskContent;
+use App\Models\ProjectTaskUser;
+use App\Models\ProjectTaskVisibilityUser;
+use App\Models\ProjectUser;
+use App\Models\User;
+use App\Models\UserTag;
+use App\Models\UserTagRecognition;
+use App\Models\WebSocketDialog;
+use App\Models\WebSocketDialogMsg;
+use App\Models\WebSocketDialogUser;
+use App\Observers\FileObserver;
+use App\Observers\FileUserObserver;
+use App\Observers\ProjectObserver;
+use App\Observers\ProjectTaskContentObserver;
+use App\Observers\ProjectTaskObserver;
+use App\Observers\ProjectTaskUserObserver;
+use App\Observers\ProjectTaskVisibilityUserObserver;
+use App\Observers\ProjectUserObserver;
+use App\Observers\UserObserver;
+use App\Observers\UserTagObserver;
+use App\Observers\UserTagRecognitionObserver;
+use App\Observers\WebSocketDialogMsgObserver;
+use App\Observers\WebSocketDialogObserver;
+use App\Observers\WebSocketDialogUserObserver;
+use Illuminate\Auth\Events\Registered;
+use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
+use Illuminate\Cache\RateLimiting\Limit;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Facades\RateLimiter;
 use Illuminate\Support\ServiceProvider;
 
 class AppServiceProvider extends ServiceProvider
@@ -32,5 +66,48 @@ class AppServiceProvider extends ServiceProvider
         \Illuminate\Database\Eloquent\Builder::macro('rawSql', function(){
             return ($this->getQuery()->rawSql());
         });
+
+        $this->configureRateLimiting();
+        $this->registerEvents();
+        $this->registerObservers();
+    }
+
+    /**
+     * api 组限流（原 RouteServiceProvider::configureRateLimiting）
+     */
+    protected function configureRateLimiting()
+    {
+        RateLimiter::for('api', function (Request $request) {
+            return Limit::perMinute(60)->by(optional($request->user())->id ?: $request->ip());
+        });
+    }
+
+    /**
+     * 事件监听（原 EventServiceProvider::$listen）
+     */
+    protected function registerEvents()
+    {
+        Event::listen(Registered::class, SendEmailVerificationNotification::class);
+    }
+
+    /**
+     * 模型观察者（原 EventServiceProvider::boot）
+     */
+    protected function registerObservers()
+    {
+        File::observe(FileObserver::class);
+        FileUser::observe(FileUserObserver::class);
+        Project::observe(ProjectObserver::class);
+        ProjectTask::observe(ProjectTaskObserver::class);
+        ProjectTaskContent::observe(ProjectTaskContentObserver::class);
+        ProjectTaskUser::observe(ProjectTaskUserObserver::class);
+        ProjectTaskVisibilityUser::observe(ProjectTaskVisibilityUserObserver::class);
+        ProjectUser::observe(ProjectUserObserver::class);
+        User::observe(UserObserver::class);
+        UserTag::observe(UserTagObserver::class);
+        UserTagRecognition::observe(UserTagRecognitionObserver::class);
+        WebSocketDialog::observe(WebSocketDialogObserver::class);
+        WebSocketDialogMsg::observe(WebSocketDialogMsgObserver::class);
+        WebSocketDialogUser::observe(WebSocketDialogUserObserver::class);
     }
 }

app/Providers/AuthServiceProvider.php

@@ -1,30 +0,0 @@
-<?php
-
-namespace App\Providers;
-
-use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
-use Illuminate\Support\Facades\Gate;
-
-class AuthServiceProvider extends ServiceProvider
-{
-    /**
-     * The policy mappings for the application.
-     *
-     * @var array
-     */
-    protected $policies = [
-        // 'App\Models\Model' => 'App\Policies\ModelPolicy',
-    ];
-
-    /**
-     * Register any authentication / authorization services.
-     *
-     * @return void
-     */
-    public function boot()
-    {
-        $this->registerPolicies();
-
-        //
-    }
-}

app/Providers/BroadcastServiceProvider.php

@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Providers;
-
-use Illuminate\Support\Facades\Broadcast;
-use Illuminate\Support\ServiceProvider;
-
-class BroadcastServiceProvider extends ServiceProvider
-{
-    /**
-     * Bootstrap any application services.
-     *
-     * @return void
-     */
-    public function boot()
-    {
-        Broadcast::routes();
-
-        require base_path('routes/channels.php');
-    }
-}

app/Providers/EventServiceProvider.php

@@ -1,72 +0,0 @@
-<?php
-
-namespace App\Providers;
-
-use App\Models\File;
-use App\Models\FileUser;
-use App\Models\Project;
-use App\Models\ProjectTask;
-use App\Models\ProjectTaskContent;
-use App\Models\ProjectTaskUser;
-use App\Models\ProjectTaskVisibilityUser;
-use App\Models\ProjectUser;
-use App\Models\User;
-use App\Models\UserTag;
-use App\Models\UserTagRecognition;
-use App\Models\WebSocketDialog;
-use App\Models\WebSocketDialogMsg;
-use App\Models\WebSocketDialogUser;
-use App\Observers\FileObserver;
-use App\Observers\FileUserObserver;
-use App\Observers\ProjectObserver;
-use App\Observers\ProjectTaskContentObserver;
-use App\Observers\ProjectTaskObserver;
-use App\Observers\ProjectTaskUserObserver;
-use App\Observers\ProjectTaskVisibilityUserObserver;
-use App\Observers\ProjectUserObserver;
-use App\Observers\UserObserver;
-use App\Observers\UserTagObserver;
-use App\Observers\UserTagRecognitionObserver;
-use App\Observers\WebSocketDialogMsgObserver;
-use App\Observers\WebSocketDialogObserver;
-use App\Observers\WebSocketDialogUserObserver;
-use Illuminate\Auth\Events\Registered;
-use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
-use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
-
-class EventServiceProvider extends ServiceProvider
-{
-    /**
-     * The event listener mappings for the application.
-     *
-     * @var array
-     */
-    protected $listen = [
-        Registered::class => [
-            SendEmailVerificationNotification::class,
-        ],
-    ];
-
-    /**
-     * Register any events for your application.
-     *
-     * @return void
-     */
-    public function boot()
-    {
-        File::observe(FileObserver::class);
-        FileUser::observe(FileUserObserver::class);
-        Project::observe(ProjectObserver::class);
-        ProjectTask::observe(ProjectTaskObserver::class);
-        ProjectTaskContent::observe(ProjectTaskContentObserver::class);
-        ProjectTaskUser::observe(ProjectTaskUserObserver::class);
-        ProjectTaskVisibilityUser::observe(ProjectTaskVisibilityUserObserver::class);
-        ProjectUser::observe(ProjectUserObserver::class);
-        User::observe(UserObserver::class);
-        UserTag::observe(UserTagObserver::class);
-        UserTagRecognition::observe(UserTagRecognitionObserver::class);
-        WebSocketDialog::observe(WebSocketDialogObserver::class);
-        WebSocketDialogMsg::observe(WebSocketDialogMsgObserver::class);
-        WebSocketDialogUser::observe(WebSocketDialogUserObserver::class);
-    }
-}

app/Providers/RouteServiceProvider.php

@@ -1,63 +0,0 @@
-<?php
-
-namespace App\Providers;
-
-use Illuminate\Cache\RateLimiting\Limit;
-use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
-use Illuminate\Http\Request;
-use Illuminate\Support\Facades\RateLimiter;
-use Illuminate\Support\Facades\Route;
-
-class RouteServiceProvider extends ServiceProvider
-{
-    /**
-     * The path to the "home" route for your application.
-     *
-     * This is used by Laravel authentication to redirect users after login.
-     *
-     * @var string
-     */
-    public const HOME = '/home';
-
-    /**
-     * The controller namespace for the application.
-     *
-     * When present, controller route declarations will automatically be prefixed with this namespace.
-     *
-     * @var string|null
-     */
-    // protected $namespace = 'App\\Http\\Controllers';
-
-    /**
-     * Define your route model bindings, pattern filters, etc.
-     *
-     * @return void
-     */
-    public function boot()
-    {
-        $this->configureRateLimiting();
-
-        $this->routes(function () {
-            Route::prefix('api')
-                ->middleware('api')
-                ->namespace($this->namespace)
-                ->group(base_path('routes/api.php'));
-
-            Route::middleware('web')
-                ->namespace($this->namespace)
-                ->group(base_path('routes/web.php'));
-        });
-    }
-
-    /**
-     * Configure the rate limiters for the application.
-     *
-     * @return void
-     */
-    protected function configureRateLimiting()
-    {
-        RateLimiter::for('api', function (Request $request) {
-            return Limit::perMinute(60)->by(optional($request->user())->id ?: $request->ip());
-        });
-    }
-}

app/Services/WebSocketService.php

@@ -136,6 +136,20 @@ class WebSocketService implements WebSocketHandlerInterface
                 }
                 Cache::put("User::encrypt:" . $frame->fd, Base::array2json($data), Carbon::now()->addDay());
                 return;
+
+            // AI 助手页面操作结果回包（由 assistant/operation/dispatch 派发，前端执行后回传）
+            case 'operationResult':
+                $requestId = trim($data['requestId'] ?? '');
+                if ($requestId !== '') {
+                    $row = WebSocket::whereFd($frame->fd)->first();
+                    Cache::put("ai_op_result:{$requestId}", [
+                        'userid' => $row?->userid ?: 0,
+                        'success' => !empty($data['success']),
+                        'result' => $data['result'] ?? null,
+                        'error' => $data['error'] ?? null,
+                    ], 60);
+                }
+                return;
         }
 
         // 返回消息

app/Tasks/AbstractTask.php

@@ -29,6 +29,19 @@ abstract class AbstractTask extends Task
         }
     }
 
+    /**
+     * 重写投递：非 Swoole 运行时（artisan/测试）无 swoole 绑定，无法投递异步任务，跳过（与 AbstractObserver 守卫一致）
+     * @param mixed $task
+     * @return bool
+     */
+    protected function task($task)
+    {
+        if (!app()->bound('swoole')) {
+            return false;
+        }
+        return parent::task($task);
+    }
+
     /**
      * 开始执行任务
      */

app/Tasks/BotReceiveMsgTask.php

@@ -6,6 +6,7 @@ use App\Models\FileContent;
 use App\Models\Project;
 use App\Models\ProjectTask;
 use App\Models\Report;
+use App\Models\Setting;
 use App\Models\User;
 use App\Models\UserBot;
 use App\Models\UserDepartment;
@@ -469,7 +470,10 @@ class BotReceiveMsgTask extends AbstractTask
                 if ($msg->msg['model_name']) {
                     $extras['model_name'] = $msg->msg['model_name'];
                 }
-                // 提取模型“思考”参数
+                // 优先读取模型列表中按模型配置的思考档位（off|low|medium|high）
+                $thinkingEffort = Setting::AIBotModelThinking($setting[$type . '_models'] ?? '', $extras['model_name']);
+                // 兼容旧约定：模型名带 (thinking)/-reasoning 等后缀时，剥离后缀并视为 medium 档
+                if ($thinkingEffort === 'off') {
                     $thinkPatterns = [
                         "/^(.+?)(\s+|\s*[_-]\s*)(think|thinking|reasoning)\s*$/",
                         "/^(.+?)\s*\(\s*(think|thinking|reasoning)\s*\)\s*$/"
@@ -482,8 +486,13 @@ class BotReceiveMsgTask extends AbstractTask
                     }
                     if ($thinkMatch && !empty($thinkMatch[1])) {
                         $extras['model_name'] = $thinkMatch[1];
+                        $thinkingEffort = 'medium';
+                    }
+                }
+                if ($thinkingEffort !== 'off') {
+                    $extras['thinking_effort'] = $thinkingEffort;
                     $extras['max_tokens'] = 20000;
-                    $extras['thinking'] = 4096;
+                    $extras['thinking'] = 4096; // 兼容旧版插件
                     $extras['temperature'] = 1.0;
                 }
                 // 设定会话ID

app/Tasks/CheckinRemindTask.php

@@ -2,7 +2,6 @@
 
 namespace App\Tasks;
 
-use App\Models\ApproveProcInstHistory;
 use App\Models\User;
 use App\Models\UserCheckinRecord;
 use App\Models\WebSocketDialog;
@@ -80,9 +79,6 @@ class CheckinRemindTask extends AbstractTask
                 if (!UserCheckinRecord::whereUserid($user->userid)->where('created_at', '>', Carbon::now()->subDays(3))->exists()) {
                     continue;   // 3天内没有打卡
                 }
-                if (ApproveProcInstHistory::userIsLeave($user->userid)) {
-                    continue;   // 请假、外出
-                }
                 $dialog = WebSocketDialog::checkUserDialog($botUser, $user->userid);
                 if ($dialog) {
                     if ($type === 'exceed') {

app/Tasks/DeleteTmpTask.php

@@ -65,7 +65,7 @@ class DeleteTmpTask extends AbstractTask
                 break;
 
             case 'file':
-                $day = intval(env("AUTO_EMPTY_FILE_RECYCLE", 365));
+                $day = intval(config('dootask.auto_empty_file_recycle'));
                 if ($day <= 0) {
                     return;
                 }
@@ -81,7 +81,7 @@ class DeleteTmpTask extends AbstractTask
                 break;
 
             case 'tmp_file':
-                $day = intval(env("AUTO_EMPTY_TEMP_FILE", 30));
+                $day = intval(config('dootask.auto_empty_temp_file'));
                 if ($day <= 0) {
                     return;
                 }
@@ -94,6 +94,27 @@ class DeleteTmpTask extends AbstractTask
                 }
                 break;
 
+            case 'tmp_chunks':
+                // 分片上传残留：upload_id 目录超过 hours 小时未合并则整目录清掉
+                $chunksRoot = public_path('uploads/tmp/chunks');
+                if (!is_dir($chunksRoot)) {
+                    break;
+                }
+                $cutoff = time() - 3600 * $this->hours;
+                foreach (glob($chunksRoot . '/*', GLOB_ONLYDIR) ?: [] as $userDir) {
+                    foreach (glob($userDir . '/*', GLOB_ONLYDIR) ?: [] as $uploadDir) {
+                        $mtime = @filemtime($uploadDir);
+                        if ($mtime && $mtime < $cutoff) {
+                            Base::deleteDirAndFile($uploadDir);
+                        }
+                    }
+                    // 顺手清理空 user 目录
+                    if (count(scandir($userDir) ?: []) <= 2) {
+                        @rmdir($userDir);
+                    }
+                }
+                break;
+
             case 'user_device':
                 UserDevice::where('expired_at', '<', Carbon::now()->subHours($this->hours))
                     ->orderBy('id')

app/Tasks/EmailNoticeTask.php

@@ -9,8 +9,9 @@ use App\Module\Base;
 use App\Module\Doo;
 use App\Module\Timer;
 use Carbon\Carbon;
-use Guanguans\Notify\Factory;
+use Symfony\Component\Mailer\Mailer;
-use Guanguans\Notify\Messages\EmailMessage;
+use Symfony\Component\Mailer\Transport;
+use Symfony\Component\Mime\Email;
 
 /**
  * 未读消息邮件通知任务
@@ -258,20 +259,18 @@ class EmailNoticeTask extends AbstractTask
     private function sendEmail($user, $emailData): void
     {
         Setting::validateAddr($user->email, function($to) use ($emailData) {
-            Factory::mailer()
+            $mailer = new Mailer(Transport::fromDsn(sprintf(
-                ->setDsn(sprintf(
                 'smtp://%s:%s@%s:%s?verify_peer=0',
                 $this->emailSetting['account'],
                 $this->emailSetting['password'],
                 $this->emailSetting['smtp_server'],
                 $this->emailSetting['port']
-                ))
+            )));
-                ->setMessage(EmailMessage::create()
+            $mailer->send((new Email())
                 ->from(sprintf('%s <%s>', Base::settingFind('system', 'system_alias', 'Task'), $this->emailSetting['account']))
                 ->to($to)
                 ->subject($emailData['subject'])
-                    ->html($emailData['content']))
+                ->html($emailData['content']));
-                ->send();
         });
     }
 

app/Tasks/LoopTask.php

@@ -23,7 +23,10 @@ class LoopTask extends AbstractTask
         ProjectTask::whereBetween('loop_at', [
             Carbon::now()->subMinutes(10),
             Carbon::now()
-        ])->chunkById(100, function ($list) {
+        ])->whereHas('project', function ($query) {
+            // 仅处理未删除、未归档项目的任务（Project 软删除由全局作用域排除）
+            $query->whereNull('archived_at');
+        })->chunkById(100, function ($list) {
             /** @var ProjectTask $item */
             foreach ($list as $item) {
                 if ($item->parent_id > 0) {
@@ -60,7 +63,7 @@ class LoopTask extends AbstractTask
                     }
                     // 新任务时间、周期
                     if ($task->start_at) {
-                        $diffSecond = Carbon::parse($task->start_at)->diffInSeconds(Carbon::parse($task->end_at), true);
+                        $diffSecond = (int)Carbon::parse($task->start_at)->diffInSeconds(Carbon::parse($task->end_at), true);
                         $task->start_at = Carbon::parse($task->loop_at);
                         $task->end_at = $task->start_at->clone()->addSeconds($diffSecond);
                     }

app/Tasks/ManticoreSyncTask.php

@@ -235,11 +235,8 @@ class ManticoreSyncTask extends AbstractTask
         }
         Cache::put("ManticoreSyncTask:CheckTime", time(), Carbon::now()->addMinutes(5));
 
-        // 执行增量全文索引同步
+        // 执行增量全文索引同步（向量由 Manticore Auto Embeddings 随行自动生成）
         $this->runIncrementalSync();
-
-        // 执行向量生成
-        $this->runVectorGeneration();
     }
 
     /**
@@ -261,22 +258,6 @@ class ManticoreSyncTask extends AbstractTask
         @shell_exec("php /var/www/artisan manticore:retry-failures 2>&1 &");
     }
 
-    /**
-     * 执行向量生成（兜底触发）
-     *
-     * 命令内部有锁机制，如果已在运行会自动跳过
-     * 命令会持续处理直到无待处理数据，然后自动退出
-     */
-    private function runVectorGeneration(): void
-    {
-        if (!Apps::isInstalled("ai")) {
-            return;
-        }
-
-        // 启动向量生成命令
-        @shell_exec("php /var/www/artisan manticore:generate-vectors --type=all --batch=50 2>&1 &");
-    }
-
     public function end()
     {
     }