@fangyb/ahchat-bridge 0.1.32 → 0.1.34

package/dist/index.js

@@ -5515,6 +5515,21 @@ EXCEPTION \u2014 inner-voice envelope overrides no-reply:
 - In group chat, default to short. Long-form only when explicitly asked.
 - In 1:1 chat with the human, you may write longer answers when warranted.
 
+# Media generation replies
+- Official Seedream / Seedance MCP tools render visible AHChat media task cards.
+  Let the card carry status, preview, download, copy, and regenerate actions.
+- Current media generation is one output per user request: one Seedream image or
+  one Seedance video. Do not submit candidate batches, parallel tasks, or
+  alternate versions in the same turn.
+- Do not print raw media URLs, request_id, task_id, polling logs, or repeated
+  "let me check again" narration in the final reply unless the user explicitly
+  asks for diagnostics.
+- For media submission or completion, write a short natural sentence only,
+  such as "\u5DF2\u5F00\u59CB\u751F\u6210\uFF0C\u6211\u4F1A\u5728\u8FD9\u91CC\u66F4\u65B0\u7ED3\u679C\u3002" or "\u751F\u6210\u597D\u4E86\uFF0C\u53EF\u4EE5\u5728\u5361\u7247\u91CC\u67E5\u770B\u3002"
+- Do not use Bash, sleep loops, Monitor, curl polling, or background tasks just
+  to wait for Seedream / Seedance. Seedream returns final images directly.
+  Seedance is tracked by AHChat after one create_task call.
+
 # Group chat \u2014 shared task board
 AHChat group conversations have a shared kanban board that is fed by structured
 task tools (TodoWrite when available; otherwise TaskCreate / TaskUpdate). Treat
@@ -5688,13 +5703,14 @@ list_available_skills \u67E5\u8BE2\u5F53\u524D Agent \u53EF\u76F4\u63A5\u4F7F\u7
 - \u5DF2\u51FA\u73B0\u5728 list_available_skills \u7684 assigned/local skill \u4E0D\u9700\u8981\u8BA9\u7528\u6237\u518D\u786E\u8BA4\u662F\u5426\u53EF\u7528\uFF1B\u4F46\u8BFB\u65E5\u5FD7\u3001\u8DD1\u547D\u4EE4\u3001\u5199\u6587\u4EF6\u3001\u53D1\u5E16\u3001\u8BFB\u5927\u91CF\u79C1\u5BC6\u4E0A\u4E0B\u6587\u7B49\u5177\u4F53\u9AD8\u98CE\u9669\u52A8\u4F5C\u6267\u884C\u524D\u5FC5\u987B\u8BF4\u660E\u539F\u56E0\u5E76\u9075\u5B88\u7528\u6237/\u7CFB\u7EDF\u6743\u9650\u8FB9\u754C\u3002
 
 # Cross-scope session isolation
-\u6BCF\u4E2A scope\uFF08single / group\uFF09\u6709\u72EC\u7ACB\u7684 SDK Session / \u5DE5\u4F5C\u8BB0\u5FC6\uFF0C\u4F46\u540C\u4E00\u4E2A Agent \u7684\u6240\u6709 scope \u4F7F\u7528\u540C\u4E00\u4E2A\u5F53\u524D workdir\u3002
-\u4F60\u5728 # Your scopes \u4E2D\u53EF\u4EE5\u770B\u5230\u6BCF\u4E2A scope \u5F53\u524D\u4F7F\u7528\u7684 workdir \u8DEF\u5F84\uFF1B\u6B63\u5E38\u60C5\u51B5\u4E0B\uFF0C\u540C\u4E00 Agent \u7684 single \u4E0E group scope \u8DEF\u5F84\u76F8\u540C\u3002
+\u6BCF\u4E2A scope\uFF08single / group\uFF09\u6709\u72EC\u7ACB\u7684 SDK Session / \u5DE5\u4F5C\u8BB0\u5FC6\uFF0Cworkdir \u4E5F\u6309 scope \u53D6\u4E0D\u540C\u6743\u5A01\u6765\u6E90\u3002
+\u4F60\u5728 # Your scopes \u4E2D\u53EF\u4EE5\u770B\u5230\u6BCF\u4E2A scope \u5F53\u524D\u4F7F\u7528\u7684 workdir \u8DEF\u5F84\u3002
 
-- \u4F60\u53EF\u4EE5\u5728\u5F53\u524D workdir \u5185 Read/Glob/Grep/Write/Edit\uFF1B\u4E0D\u8981\u5047\u8BBE\u7FA4\u804A\u548C\u5355\u804A\u6709\u4E24\u4EFD\u4E92\u4E0D\u76F8\u901A\u7684\u6587\u4EF6\u533A\u3002
-- \u5F53\u4F60\u5728\u7FA4 scope \u5B8C\u6210\u4E86\u6587\u4EF6\u4EA7\u51FA\uFF0C\u7528 neural_send \u628A\u6587\u4EF6\u8DEF\u5F84\u548C\u6458\u8981\u901A\u77E5\u4F60\u5728 single scope \u7684\u5206\u8EAB\uFF0C\u65B9\u4FBF\u7528\u6237\u5728\u5355\u804A\u4E2D\u67E5\u770B\u3002
-- \u53CD\u8FC7\u6765\u4E5F\u4E00\u6837\uFF1A\u5355\u804A\u4EA7\u51FA\u540E\uFF0C\u7528 neural_send \u901A\u77E5\u76F8\u5173\u7FA4 scope\u3002
-- neural_send \u7528\u6765\u540C\u6B65\u4E0A\u4E0B\u6587\u548C\u7ED3\u8BBA\uFF1B\u540C\u4E00 Agent \u8DE8 scope \u5171\u4EAB\u6587\u4EF6\u65F6\u901A\u5E38\u53EA\u9700\u8981\u4F20\u8DEF\u5F84\u548C\u6458\u8981\uFF0C\u4E0D\u9700\u8981\u590D\u5236\u6587\u4EF6\u3002
+- single workdir \u662F\u4F60\u7684\u79C1\u6709 Agent \u5DE5\u4F5C\u76EE\u5F55\uFF0C\u7528\u4E8E\u4F60\u548C\u7528\u6237\u7684 1:1 \u5355\u804A\u3002
+- group workdir \u662F\u8BE5\u7FA4\u7684\u5171\u4EAB\u5DE5\u4F5C\u76EE\u5F55\uFF1B\u5F53\u4F60\u5728\u8FD9\u4E2A\u7FA4 scope \u4E2D\u8FD0\u884C\u65F6\uFF0C\u5F53\u524D runtime cwd \u5C31\u662F\u8FD9\u4E2A\u7FA4\u76EE\u5F55\u3002
+- \u7528\u6237\u95EE\u201C\u4F60\u81EA\u5DF1\u7684\u5DE5\u4F5C\u76EE\u5F55\u201D\u548C\u201C\u8FD9\u4E2A\u7FA4\u804A\u5DE5\u4F5C\u76EE\u5F55\u201D\u65F6\uFF0C\u8981\u5206\u522B\u62A5\u544A single workdir \u548C\u5F53\u524D group workdir\uFF1B\u9664\u975E # Your scopes \u91CC\u4E24\u4E2A\u8DEF\u5F84\u5B57\u9762\u5B8C\u5168\u76F8\u540C\uFF0C\u4E0D\u8981\u8BF4\u5B83\u4EEC\u76F8\u540C\u3002
+- \u4F60\u53EA\u80FD\u5728\u5F53\u524D runtime cwd \u5185 Read/Glob/Grep/Write/Edit\uFF1B\u5728\u7FA4\u91CC\u4EA7\u51FA\u7684\u6587\u4EF6\u9ED8\u8BA4\u5C5E\u4E8E\u7FA4\u5171\u4EAB\u76EE\u5F55\u3002
+- \u8DE8 scope \u540C\u6B65\u4E0A\u4E0B\u6587\u548C\u7ED3\u8BBA\u7528 neural_send\uFF1B\u5982\u679C\u53E6\u4E00\u4E2A scope \u9700\u8981\u67E5\u770B\u6587\u4EF6\uFF0C\u4F20\u8DEF\u5F84\u548C\u6458\u8981\uFF0C\u4E0D\u8981\u5047\u88C5\u90A3\u4E2A scope \u7684 cwd \u81EA\u52A8\u76F8\u540C\u3002
 
 # Cross-scope awareness (Neural Send)
 
@@ -5921,11 +5937,121 @@ function createMcpToolInvocationId() {
 function isWSMessage(data) {
   return typeof data === "object" && data !== null && "type" in data && "payload" in data;
 }
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto2 = Object.getPrototypeOf(value);
+  return proto2 === Object.prototype || proto2 === null;
+}
+function invalidWsMessage(type, field) {
+  return new Error(`Invalid WS message ${type} payload.${field}`);
+}
+function assertPayloadRecord(type, payload) {
+  if (!isPlainRecord(payload)) {
+    throw new Error(`Invalid WS message ${type} payload`);
+  }
+}
+function assertStringPayloadField(type, payload, field) {
+  if (typeof payload[field] !== "string") {
+    throw invalidWsMessage(type, field);
+  }
+}
+function assertNumberPayloadField(type, payload, field) {
+  if (typeof payload[field] !== "number" || Number.isNaN(payload[field])) {
+    throw invalidWsMessage(type, field);
+  }
+}
+function assertArrayPayloadField(type, payload, field) {
+  if (!Array.isArray(payload[field])) {
+    throw invalidWsMessage(type, field);
+  }
+}
+function assertRecordPayloadField(type, payload, field) {
+  if (!isPlainRecord(payload[field])) {
+    throw invalidWsMessage(type, field);
+  }
+}
+function validateRequiredStrings(type, payload, fields) {
+  for (const field of fields) assertStringPayloadField(type, payload, field);
+}
+function validateWSMessageShape(msg) {
+  const type = msg.type;
+  const payload = msg.payload;
+  switch (type) {
+    case "heartbeat": {
+      assertPayloadRecord(type, payload);
+      assertNumberPayloadField(type, payload, "ts");
+      return;
+    }
+    case "client:hello": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, ["sessionId", "platform", "version", "env", "traceId"]);
+      return;
+    }
+    case "user:send_message": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, ["id", "agentId", "conversationId", "content", "traceId"]);
+      return;
+    }
+    case "user:group_message": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, ["id", "groupId", "conversationId", "content", "traceId"]);
+      assertArrayPayloadField(type, payload, "mentions");
+      return;
+    }
+    case "agent:done": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, [
+        "ackId",
+        "messageId",
+        "agentId",
+        "conversationId",
+        "fullContent",
+        "traceId"
+      ]);
+      assertArrayPayloadField(type, payload, "contentBlocks");
+      assertRecordPayloadField(type, payload, "metadata");
+      return;
+    }
+    case "agent:segment": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, [
+        "messageId",
+        "ackId",
+        "agentId",
+        "conversationId",
+        "groupId",
+        "content",
+        "traceId"
+      ]);
+      assertArrayPayloadField(type, payload, "contentBlocks");
+      return;
+    }
+    case "agent:turn_complete": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, ["ackId", "agentId", "conversationId", "groupId", "traceId"]);
+      assertNumberPayloadField(type, payload, "segmentCount");
+      return;
+    }
+    case "agent:no_reply": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, ["ackId", "agentId", "conversationId", "traceId"]);
+      return;
+    }
+    case "agent:error": {
+      assertPayloadRecord(type, payload);
+      validateRequiredStrings(type, payload, ["ackId", "agentId", "conversationId", "error", "traceId"]);
+      return;
+    }
+    default:
+      return;
+  }
+}
 function parseWSMessage(raw) {
   const parsed = JSON.parse(raw);
   if (!isWSMessage(parsed)) {
     throw new Error("Invalid WS message: missing type/payload");
   }
+  validateWSMessageShape(parsed);
   return parsed;
 }
 function isAskUserQuestionToolName(toolName) {
@@ -5939,7 +6065,7 @@ var SLUG_MAX_LEN = 32;
 function slugifyForFs(name) {
   const trimmed = name.trim();
   if (!trimmed) return "unnamed";
-  const slug = trimmed.replace(/[^\w\u4e00-\u9fa5 \-]/gu, "_").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  const slug = trimmed.replace(/[^\w\u4e00-\u9fa5 -]/gu, "_").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
   const base = slug.length > 0 ? slug : "unnamed";
   return base.length > SLUG_MAX_LEN ? base.slice(0, SLUG_MAX_LEN) : base;
 }
@@ -6443,6 +6569,105 @@ var OFFICIAL_OFFICE_SKILL_MARKDOWN = Object.fromEntries(
   OFFICIAL_OFFICE_SKILLS.map((skill) => [skill.id, renderOfficialOfficeSkillMarkdown(skill)])
 );
 
+// ../shared/src/officialMediaSkills.ts
+var OFFICIAL_MEDIA_SKILL_IDS = [
+  "media-video-generation"
+];
+var OFFICIAL_MEDIA_SKILLS = [
+  {
+    id: "media-video-generation",
+    name: "\u89C6\u9891\u751F\u6210",
+    summary: "\u5B98\u65B9 Seedance \u89C6\u9891\u751F\u6210\u6D41\u7A0B\u6280\u80FD\uFF1A\u628A\u89C6\u9891\u9700\u6C42\u8F6C\u6210\u7A33\u5B9A\u4EFB\u52A1\uFF0C\u6BCF\u6B21\u53EA\u63D0\u4EA4\u4E00\u4E2A\u89C6\u9891\u4EFB\u52A1\uFF0C\u5E76\u4EA4\u7ED9 AHChat \u5A92\u4F53\u4EFB\u52A1\u5361\u8DDF\u8E2A\u7ED3\u679C\u3002",
+    sourceType: "official",
+    trustLevel: "official",
+    status: "team_approved",
+    taskTypes: [
+      "\u89C6\u9891\u751F\u6210",
+      "\u89C6\u9891",
+      "\u751F\u89C6\u9891",
+      "AI \u89C6\u9891",
+      "Seedance",
+      "\u6587\u751F\u89C6\u9891",
+      "\u56FE\u751F\u89C6\u9891",
+      "\u77ED\u89C6\u9891",
+      "video_generation",
+      "media_generation"
+    ],
+    applicableRoles: [
+      "video",
+      "media",
+      "creative",
+      "designer",
+      "\u5BFC\u6F14",
+      "\u89C6\u9891",
+      "\u751F\u89C6\u9891",
+      "\u521B\u610F",
+      "\u8BBE\u8BA1",
+      "\u591A\u5A92\u4F53",
+      "\u5185\u5BB9"
+    ],
+    applicableScopes: ["single", "group", "smith"],
+    problem: "\u89C6\u9891\u751F\u6210\u662F\u957F\u8017\u65F6\u5916\u90E8\u4EFB\u52A1\u3002\u6CA1\u6709\u4E13\u95E8\u6D41\u7A0B\u65F6\uFF0CAgent \u5BB9\u6613\u7528 Bash\u3001sleep \u6216\u53CD\u590D\u67E5\u8BE2\u5236\u9020\u566A\u97F3\uFF0C\u5E76\u628A task_id\u3001\u7B7E\u540D URL \u548C\u8F6E\u8BE2\u65E5\u5FD7\u66B4\u9732\u7ED9\u7528\u6237\u3002",
+    inputs: [
+      { name: "videoGoal", description: "\u89C6\u9891\u4E3B\u9898\u3001\u4E3B\u4F53\u3001\u52A8\u4F5C\u3001\u98CE\u683C\u548C\u7528\u6237\u671F\u671B\u7684\u6548\u679C\u3002", required: true },
+      { name: "duration", description: "\u671F\u671B\u65F6\u957F\uFF1B\u7528\u6237\u672A\u6307\u5B9A\u65F6\u4F7F\u7528 Seedance \u9ED8\u8BA4\u77ED\u89C6\u9891\u65F6\u957F\u3002" },
+      { name: "format", description: "\u6BD4\u4F8B\u3001\u5206\u8FA8\u7387\u3001\u662F\u5426\u5FEB\u901F\u7248\u3001\u662F\u5426\u9700\u8981\u58F0\u97F3\u6216\u53C2\u8003\u56FE\u3002" }
+    ],
+    outputs: [
+      { name: "mediaTask", description: "\u4E00\u5F20 AHChat \u5A92\u4F53\u4EFB\u52A1\u5361\uFF0C\u5C55\u793A\u751F\u6210\u4E2D\u3001\u5B8C\u6210\u3001\u5931\u8D25\u3001\u9884\u89C8\u3001\u4E0B\u8F7D\u548C\u518D\u6B21\u751F\u6210\u3002", required: true },
+      { name: "shortReply", description: "\u4E00\u53E5\u81EA\u7136\u77ED\u56DE\u590D\uFF0C\u907F\u514D\u91CD\u590D\u89E3\u91CA\u5DE5\u5177\u7EC6\u8282\u3002" }
+    ],
+    steps: [
+      "\u5148\u5224\u65AD\u9700\u6C42\u662F\u5426\u8DB3\u591F\u63D0\u4EA4\uFF1A\u4E3B\u4F53\u3001\u52A8\u4F5C\u3001\u573A\u666F\u548C\u98CE\u683C\u6E05\u695A\u65F6\u76F4\u63A5\u5F00\u59CB\uFF1B\u7F3A\u5173\u952E\u8981\u7D20\u65F6\u6700\u591A\u95EE\u4E00\u4E2A\u805A\u7126\u95EE\u9898\u3002",
+      "\u628A\u9700\u6C42\u6574\u7406\u6210 Seedance prompt\uFF1B\u7528\u6237\u8BF4\u201C\u5FEB\u901F\u7248\u3001\u8D28\u91CF\u4E00\u822C\u3001\u5148\u770B\u770B\u201D\u65F6\u4F18\u5148\u9009\u62E9\u5FEB\u901F / \u8F83\u4F4E\u5206\u8FA8\u7387\u53C2\u6570\uFF0C\u7528\u6237\u660E\u786E\u8981\u9AD8\u8D28\u91CF\u65F6\u518D\u63D0\u9AD8\u53C2\u6570\u3002",
+      "\u6BCF\u6B21\u7528\u6237\u8BF7\u6C42\u53EA\u751F\u6210 1 \u4E2A\u89C6\u9891\u3002\u5982\u679C\u7528\u6237\u8981\u6C42\u591A\u4E2A\u89C6\u9891\u3001\u591A\u4E2A\u7248\u672C\u6216\u5019\u9009\uFF0C\u5148\u8BF4\u660E\u5F53\u524D ALL-CAN \u6D41\u7A0B\u4E00\u6B21\u53EA\u751F\u6210\u4E00\u4E2A\u89C6\u9891\uFF0C\u5E76\u8BA9\u7528\u6237\u5148\u9009\u4E00\u4E2A\u65B9\u5411\u3002",
+      "\u8C03\u7528 mcp__seedance__seedance_create_task \u4E00\u6B21\u63D0\u4EA4 1 \u4E2A\u4EFB\u52A1\u3002\u63D0\u4EA4\u540E\u505C\u6B62\u672C\u8F6E\u624B\u52A8\u7B49\u5F85\uFF0C\u4E0D\u8981\u5E76\u53D1\u63D0\u4EA4\u591A\u4E2A\u4EFB\u52A1\uFF0C\u4E5F\u4E0D\u8981\u7528 Bash\u3001sleep\u3001curl\u3001Monitor\u3001\u540E\u53F0\u4EFB\u52A1\u6216\u5FAA\u73AF\u67E5\u8BE2\u6765\u7B49\u7ED3\u679C\u3002",
+      "\u63D0\u4EA4\u6210\u529F\u540E\u53EA\u56DE\u590D\u4E00\u53E5\u81EA\u7136\u8BDD\u672F\uFF0C\u4F8B\u5982\u201C\u5DF2\u5F00\u59CB\u751F\u6210\uFF0C\u6211\u4F1A\u5728\u8FD9\u91CC\u66F4\u65B0\u7ED3\u679C\u3002\u201D\uFF1B\u8BA9 AHChat \u5A92\u4F53\u4EFB\u52A1\u5361\u5C55\u793A\u7B49\u5F85\u72B6\u6001\u3001\u8017\u65F6\u548C\u53C2\u6570\u3002",
+      "\u7528\u6237\u4E3B\u52A8\u95EE\u201C\u597D\u4E86\u6CA1 / \u8FDB\u5EA6\u600E\u6837\u201D\u65F6\uFF0C\u6700\u591A\u8C03\u7528\u4E00\u6B21 mcp__seedance__seedance_check_task\uFF0C\u5E76\u6839\u636E\u7ED3\u679C\u7B80\u77ED\u56DE\u7B54\uFF1B\u4E0D\u8981\u5FAA\u73AF\u8F6E\u8BE2\u3002",
+      "\u4EFB\u52A1\u5B8C\u6210\u540E\u53EA\u56DE\u590D\u4E00\u53E5\u81EA\u7136\u8BDD\u672F\uFF0C\u4F8B\u5982\u201C\u751F\u6210\u597D\u4E86\uFF0C\u53EF\u4EE5\u5728\u5361\u7247\u91CC\u67E5\u770B\u3002\u201D\uFF1B\u9884\u89C8\u3001\u4E0B\u8F7D\u3001\u590D\u5236\u94FE\u63A5\u548C\u518D\u6B21\u751F\u6210\u7531\u5A92\u4F53\u4EFB\u52A1\u5361\u627F\u8F7D\u3002"
+    ],
+    successCriteria: [
+      "\u804A\u5929\u4E2D\u53EA\u51FA\u73B0\u4E00\u5F20\u6301\u7EED\u66F4\u65B0\u7684\u5A92\u4F53\u4EFB\u52A1\u5361\u548C\u4E00\u4E2A\u89C6\u9891\u7ED3\u679C\uFF0C\u4E0D\u51FA\u73B0\u591A\u4E2A\u5019\u9009\u4EFB\u52A1\u3001\u591A\u6BB5 Bash\u3001sleep\u3001curl \u6216\u91CD\u590D check_task \u65E5\u5FD7\u3002",
+      "\u4E0D\u4F1A\u5411\u7528\u6237\u66B4\u9732 raw task_id\u3001request_id\u3001\u957F\u7B7E\u540D URL \u6216\u8F6E\u8BE2\u8FC7\u7A0B\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\u8BCA\u65AD\u3002",
+      "Agent \u7684\u6587\u672C\u56DE\u590D\u77ED\u800C\u81EA\u7136\uFF0C\u751F\u6210\u72B6\u6001\u3001\u53C2\u6570\u3001\u9884\u89C8\u548C\u64CD\u4F5C\u90FD\u7531\u5A92\u4F53\u5361\u5C55\u793A\u3002",
+      "\u751F\u6210\u5931\u8D25\u3001\u989D\u5EA6\u4E0D\u8DB3\u6216\u914D\u7F6E\u7F3A\u5931\u65F6\u8BF4\u660E\u53EF\u7406\u89E3\u539F\u56E0\uFF0C\u5E76\u505C\u6B62\u91CD\u8BD5\u5FAA\u73AF\u3002"
+    ],
+    limitations: [
+      "\u4F9D\u8D56\u5B98\u65B9 Seedance MCP \u5DF2\u542F\u7528\u3001\u516C\u53F8 Ark Key \u5DF2\u914D\u7F6E\u4E14\u6BCF\u65E5\u989D\u5EA6\u672A\u8017\u5C3D\u3002",
+      "\u89C6\u9891\u751F\u6210\u4F1A\u6D88\u8017\u516C\u53F8\u5A92\u4F53\u989D\u5EA6\uFF1B\u5177\u4F53\u63D0\u4EA4\u8C03\u7528\u7531 MCP \u6743\u9650\u3001\u6BCF\u65E5\u9650\u989D\u548C\u5BA1\u8BA1\u7CFB\u7EDF\u63A7\u5236\u3002",
+      "\u7B7E\u540D\u5A92\u4F53 URL \u53EF\u80FD\u8FC7\u671F\uFF0C\u5E94\u63D0\u793A\u7528\u6237\u53CA\u65F6\u5728\u5361\u7247\u91CC\u9884\u89C8\u6216\u4E0B\u8F7D\uFF0C\u4F46\u4E0D\u8981\u76F4\u63A5\u7C98\u8D34\u957F URL\u3002",
+      "\u8BE5\u6280\u80FD\u53EA\u89C4\u8303\u89C6\u9891\u751F\u6210\u6D41\u7A0B\uFF0C\u4E0D\u8D1F\u8D23\u7F16\u8F91\u672C\u5730\u89C6\u9891\u6587\u4EF6\u6216\u957F\u671F\u540E\u53F0\u901A\u77E5\u3002"
+    ],
+    permissions: {
+      readsProjectFiles: false,
+      readsLogs: false,
+      readsConversationContext: true,
+      canRunBash: false,
+      canWriteFiles: false,
+      canPostToForum: false,
+      permissionLevel: "medium"
+    },
+    sourceEvidence: {
+      feedPostIds: [],
+      feedCategories: [],
+      groupIds: [],
+      taskIds: [],
+      contributingAgentIds: [],
+      successExamples: [
+        "ProductCore \u5A92\u4F53\u4EFB\u52A1\u72B6\u6001\u67B6\u6784\uFF1ASeedance \u957F\u4EFB\u52A1\u7531 AHChat \u5A92\u4F53\u4EFB\u52A1\u5361\u8DDF\u8E2A\uFF0C\u800C\u4E0D\u662F\u9760 Agent \u624B\u52A8\u8F6E\u8BE2\u3002",
+        "\u5B98\u65B9 Seedance MCP\uFF1Amcp__seedance__seedance_create_task / mcp__seedance__seedance_check_task\u3002"
+      ],
+      failureExamples: [
+        "Agent \u7528 Bash sleep \u6216\u5FAA\u73AF check_task \u7B49\u5F85\u89C6\u9891\uFF0C\u5BFC\u81F4\u804A\u5929\u91CC\u51FA\u73B0\u5927\u91CF\u65E0\u610F\u4E49\u5DE5\u5177\u8C03\u7528\u3002",
+        "Agent \u628A task_id\u3001\u957F\u7B7E\u540D URL \u548C\u8F6E\u8BE2\u65E5\u5FD7\u4F5C\u4E3A\u6B63\u6587\u8F93\u51FA\uFF0C\u7834\u574F\u5FAE\u4FE1\u5F0F\u804A\u5929\u4F53\u9A8C\u3002"
+      ]
+    },
+    installScope: "team",
+    version: "1.0.0",
+    createdBy: "system"
+  }
+];
+
 // ../shared/src/officialWazaSkills.ts
 var WAZA_VERSION = "3.28.0";
 var WAZA_UPSTREAM = "Upstream: tw93/Waza (MIT) https://github.com/tw93/Waza";
@@ -6762,11 +6987,13 @@ var OFFICIAL_WAZA_SKILLS = [
 // ../shared/src/officialSkills.ts
 var OFFICIAL_SKILL_IDS = [
   ...OFFICIAL_OFFICE_SKILL_IDS,
-  ...OFFICIAL_WAZA_SKILL_IDS
+  ...OFFICIAL_WAZA_SKILL_IDS,
+  ...OFFICIAL_MEDIA_SKILL_IDS
 ];
 var OFFICIAL_SKILLS = [
   ...OFFICIAL_OFFICE_SKILLS,
-  ...OFFICIAL_WAZA_SKILLS
+  ...OFFICIAL_WAZA_SKILLS,
+  ...OFFICIAL_MEDIA_SKILLS
 ];
 function renderOfficialSkillMarkdown(skill) {
   return renderSkillManifestMarkdown(skill, { cacheSource: "shared-official" });
@@ -6900,7 +7127,42 @@ function searchTokens(value) {
     value.split(/[\s,，、/|]+/g).map((token) => token.trim()).filter((token) => token.length >= 2)
   )];
 }
-var BROAD_TASK_TERMS = /* @__PURE__ */ new Set(["\u65B9\u6848", "\u5185\u5BB9", "\u6587\u6863", "\u5206\u6790", "\u4F18\u5316", "plan", "content", "document", "analysis"]);
+var BROAD_TASK_TERMS = /* @__PURE__ */ new Set([
+  "\u65B9\u6848",
+  "\u5185\u5BB9",
+  "\u6587\u6863",
+  "\u5206\u6790",
+  "\u4F18\u5316",
+  "\u7528\u6237",
+  "\u5F53\u524D",
+  "\u8FD9\u4E2A",
+  "\u4E00\u4E2A",
+  "\u4E00\u4E9B",
+  "\u9700\u8981",
+  "\u8D1F\u8D23",
+  "\u53EF\u4EE5",
+  "\u5DE5\u5177",
+  "\u80FD\u529B",
+  "\u8BA1\u5212",
+  "plan",
+  "content",
+  "document",
+  "analysis",
+  "agent",
+  "skill",
+  "tool",
+  "task",
+  "user",
+  "need",
+  "needs",
+  "use",
+  "using",
+  "create",
+  "make",
+  "help",
+  "with"
+]);
+var TASK_TOKEN_SCORE_CAP = 6;
 function entryCorpus(entry) {
   return [
     entry.id,
@@ -6911,6 +7173,27 @@ function entryCorpus(entry) {
     ...entry.applicableRoles
   ].join(" ").toLowerCase();
 }
+function meaningfulTokens(value) {
+  return searchTokens(value).filter((token) => !BROAD_TASK_TERMS.has(token));
+}
+function tokensFuzzyMatch(left, right) {
+  if (left === right) return true;
+  if (left.length >= 2 && right.length >= 2 && (left.includes(right) || right.includes(left))) return true;
+  return false;
+}
+function matchedTaskKeywords(corpus, taskText) {
+  if (!taskText) return [];
+  const taskTokens = meaningfulTokens(taskText);
+  if (taskTokens.length === 0) return [];
+  const corpusTokens = meaningfulTokens(corpus);
+  const matches = [];
+  for (const taskToken of taskTokens) {
+    if (corpus.includes(taskToken) || corpusTokens.some((corpusToken) => tokensFuzzyMatch(taskToken, corpusToken))) {
+      matches.push(taskToken);
+    }
+  }
+  return [...new Set(matches)];
+}
 function scoreEntry(entry, query4) {
   const corpus = entryCorpus(entry);
   const queryText = normalizeText(query4.query);
@@ -6933,6 +7216,7 @@ function scoreEntry(entry, query4) {
       const normalizedTaskType = taskType.toLowerCase().replace(/_/g, " ");
       if (taskText.includes(normalizedTaskType) || taskText.includes(taskType.toLowerCase())) score += 4;
     }
+    score += Math.min(TASK_TOKEN_SCORE_CAP, matchedTaskKeywords(corpus, taskText).length * 2);
     if (taskText && corpus.includes(taskText)) score += 2;
   }
   if (!queryText && !roleText && !taskText) score = 1;
@@ -6970,6 +7254,8 @@ function recommendationReasons(entry, input) {
   if (matchedRoles.length > 0) reasons.push(`\u5339\u914D\u89D2\u8272\uFF1A${matchedRoles.slice(0, 3).join("\u3001")}`);
   const matchedTasks = matchedTaskTypes(entry, taskText);
   if (matchedTasks.length > 0) reasons.push(`\u5339\u914D\u4EFB\u52A1\u7C7B\u578B\uFF1A${matchedTasks.slice(0, 3).join("\u3001")}`);
+  const matchedKeywords = matchedTaskKeywords(entryCorpus(entry), taskText);
+  if (matchedTasks.length === 0 && matchedKeywords.length > 0) reasons.push(`\u5339\u914D\u5173\u952E\u8BCD\uFF1A${matchedKeywords.slice(0, 3).join("\u3001")}`);
   if (entry.permissionLevel === "high") reasons.push("\u9AD8\u6743\u9650 skill\uFF1A\u9ED8\u8BA4\u6216\u5DF2\u5206\u914D\u65F6\u53EF\u6309\u4EFB\u52A1\u4F7F\u7528\uFF1B\u5199\u6587\u4EF6\u3001\u8DD1\u547D\u4EE4\u3001\u53D1\u5E03\u7B49\u5177\u4F53\u52A8\u4F5C\u524D\u518D\u786E\u8BA4");
   if (entry.runtimeAvailability === "smith_only") reasons.push("\u5F53\u524D\u53EA\u80FD\u7531 Smith \u8BFB\u53D6\u5B8C\u6574\u65B9\u6CD5\u5B66");
   if (entry.runtimeAvailability === "planned") reasons.push("\u5F53\u524D\u662F\u89C4\u5212\u4E2D\u7684 P0 skill \u5019\u9009\uFF0C\u4E0D\u80FD\u58F0\u79F0\u5DF2\u5B89\u88C5");
@@ -7200,6 +7486,7 @@ function normalizeMcpConnectionSnapshot(value) {
     customHeaders: normalizeMcpCustomHeaderSnapshot(raw.customHeaders),
     enabled: raw.enabled === true,
     alwaysLoad: raw.alwaysLoad === true,
+    dailyCallLimit: normalizeMcpDailyCallLimitSnapshot(raw.dailyCallLimit),
     isBuiltin: false,
     ownerUserId: null,
     createdBy: null,
@@ -7209,6 +7496,11 @@ function normalizeMcpConnectionSnapshot(value) {
     bindings: bindings.length > 0 ? bindings : [{ connectionId: raw.id, targetKind: "global", targetId: MCP_GLOBAL_TARGET_ID, enabled: true }]
   };
 }
+function normalizeMcpDailyCallLimitSnapshot(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.floor(value));
+}
 function normalizeMcpToolSnapshot(value) {
   if (!value || typeof value !== "object") return null;
   const raw = value;
@@ -7317,6 +7609,60 @@ var readpageScrapeTool = {
   enabled: true,
   permissionPolicy: "always_allow"
 };
+var seedreamGenerateImageTool = {
+  name: "generate_image",
+  displayName: "Seedream \u751F\u56FE",
+  description: "\u4F7F\u7528\u706B\u5C71\u65B9\u821F Seedream \u751F\u6210\u5355\u5F20\u56FE\u7247\uFF0C\u652F\u6301\u6587\u672C\u751F\u56FE\u4E0E\u53C2\u8003\u56FE\u751F\u56FE\uFF0C\u4F1A\u4EA7\u751F\u516C\u53F8 Ark \u8D26\u53F7\u7528\u91CF\u3002",
+  category: "media",
+  riskLevel: "medium",
+  enabled: true,
+  permissionPolicy: "always_ask"
+};
+var seedreamEditImageTool = {
+  name: "edit_image",
+  displayName: "Seedream \u6539\u56FE",
+  description: "\u4F7F\u7528\u706B\u5C71\u65B9\u821F Seedream \u6839\u636E\u53C2\u8003\u56FE\u548C\u63D0\u793A\u8BCD\u7F16\u8F91\u6216\u91CD\u7ED8\u5355\u5F20\u56FE\u7247\uFF0C\u4F1A\u4EA7\u751F\u516C\u53F8 Ark \u8D26\u53F7\u7528\u91CF\u3002",
+  category: "media",
+  riskLevel: "medium",
+  enabled: true,
+  permissionPolicy: "always_ask"
+};
+var seedreamGenerateImageGroupTool = {
+  name: "generate_image_group",
+  displayName: "Seedream \u5355\u56FE",
+  description: "\u517C\u5BB9\u65E7\u540D\u79F0\u7684 Seedream \u5355\u56FE\u751F\u6210\u5DE5\u5177\uFF0C\u4F1A\u4EA7\u751F\u516C\u53F8 Ark \u8D26\u53F7\u7528\u91CF\u3002\u5F53\u524D\u6BCF\u6B21\u8BF7\u6C42\u53EA\u751F\u6210 1 \u5F20\u56FE\u7247\u3002",
+  category: "media",
+  riskLevel: "medium",
+  enabled: true,
+  permissionPolicy: "always_ask"
+};
+var seedanceUsageGuideTool = {
+  name: "seedance_usage_guide",
+  displayName: "Seedance \u4F7F\u7528\u8BF4\u660E",
+  description: "\u67E5\u770B Seedance \u89C6\u9891\u751F\u6210\u6D41\u7A0B\u4E0E\u53C2\u6570\u8BF4\u660E\uFF0C\u4E0D\u521B\u5EFA\u65B0\u7684\u751F\u6210\u4EFB\u52A1\u3002",
+  category: "media",
+  riskLevel: "low",
+  enabled: true,
+  permissionPolicy: "always_allow"
+};
+var seedanceCreateTaskTool = {
+  name: "seedance_create_task",
+  displayName: "Seedance \u751F\u89C6\u9891",
+  description: "\u4F7F\u7528\u706B\u5C71\u65B9\u821F Seedance \u521B\u5EFA\u5355\u4E2A\u89C6\u9891\u751F\u6210\u4EFB\u52A1\uFF0C\u4F1A\u4EA7\u751F\u516C\u53F8 Ark \u8D26\u53F7\u7528\u91CF\u3002\u5F53\u524D\u6BCF\u6B21\u8BF7\u6C42\u53EA\u751F\u6210 1 \u4E2A\u89C6\u9891\u3002",
+  category: "media",
+  riskLevel: "high",
+  enabled: true,
+  permissionPolicy: "always_ask"
+};
+var seedanceCheckTaskTool = {
+  name: "seedance_check_task",
+  displayName: "Seedance \u67E5\u7ED3\u679C",
+  description: "\u67E5\u8BE2 Seedance \u89C6\u9891\u751F\u6210\u4EFB\u52A1\u72B6\u6001\u4E0E\u89C6\u9891 URL\uFF0C\u4E0D\u521B\u5EFA\u65B0\u7684\u751F\u6210\u4EFB\u52A1\u3002",
+  category: "media",
+  riskLevel: "low",
+  enabled: true,
+  permissionPolicy: "always_allow"
+};
 var context7ResolveLibraryTool = {
   name: "resolve-library-id",
   displayName: "\u89E3\u6790\u6587\u6863\u5E93",
@@ -7623,8 +7969,56 @@ var ALIYUN_IQS_MCP_PROVIDERS = [
     tools: [readpageBasicTool, readpageScrapeTool]
   }
 ];
+var VOLCENGINE_SEEDREAM_MCP_PROVIDER = {
+  providerId: "volcengine_seedream",
+  name: "Volcengine Seedream",
+  summary: "\u706B\u5C71\u65B9\u821F Seedream \u56FE\u7247\u751F\u6210/\u7F16\u8F91 MCP\uFF0C\u4F7F\u7528\u516C\u53F8\u7EDF\u4E00 Ark Key\uFF0C\u5E76\u8FDB\u5165 AHChat \u8C03\u7528\u5BA1\u8BA1\u3002",
+  serverName: "seedream",
+  transport: "stdio",
+  url: null,
+  command: "ahchat-builtin",
+  args: ["seedream-mcp"],
+  env: {
+    ARK_API_KEY: "",
+    ARK_BASE_URL: "https://ark.cn-beijing.volces.com/api/v3"
+  },
+  authType: "x_api_key",
+  customHeaders: [],
+  enabled: true,
+  alwaysLoad: true,
+  tools: [
+    seedreamGenerateImageTool,
+    seedreamEditImageTool,
+    seedreamGenerateImageGroupTool
+  ]
+};
+var VOLCENGINE_SEEDANCE_MCP_PROVIDER = {
+  providerId: "volcengine_seedance",
+  name: "Volcengine Seedance",
+  summary: "\u706B\u5C71\u65B9\u821F Seedance \u89C6\u9891\u751F\u6210 MCP\uFF0C\u4F7F\u7528\u516C\u53F8\u7EDF\u4E00 Ark Key\uFF0C\u5E76\u8FDB\u5165 AHChat \u8C03\u7528\u5BA1\u8BA1\u3002",
+  serverName: "seedance",
+  transport: "stdio",
+  url: null,
+  command: "ahchat-builtin",
+  args: ["seedance-mcp"],
+  env: {
+    ARK_API_KEY: "",
+    ARK_BASE_URL: "https://ark.cn-beijing.volces.com/api/v3"
+  },
+  authType: "x_api_key",
+  customHeaders: [],
+  enabled: true,
+  alwaysLoad: true,
+  tools: [
+    seedanceUsageGuideTool,
+    seedanceCreateTaskTool,
+    seedanceCheckTaskTool
+  ]
+};
 var OFFICIAL_MCP_PROVIDERS = [
-  ...ALIYUN_IQS_MCP_PROVIDERS
+  ...ALIYUN_IQS_MCP_PROVIDERS,
+  VOLCENGINE_SEEDANCE_MCP_PROVIDER,
+  VOLCENGINE_SEEDREAM_MCP_PROVIDER
 ];
 var MCP_STORE_PROVIDERS = [
   {
@@ -8724,6 +9118,77 @@ function cronCreateDurableAllow(input) {
     priorDurable: input.durable
   };
 }
+var OFFICIAL_MEDIA_GENERATION_TOOL_NAMES = [
+  "mcp__seedream__generate_image",
+  "mcp__seedream__edit_image",
+  "mcp__seedream__generate_image_group",
+  "mcp__seedance__seedance_create_task"
+];
+var OFFICIAL_MEDIA_GENERATION_TOOLS = new Set(OFFICIAL_MEDIA_GENERATION_TOOL_NAMES);
+var OFFICIAL_MEDIA_GENERATION_TOOL_PATTERNS = [
+  /^mcp__seedream(?:_\d+)?__(?:generate_image|edit_image|generate_image_group)$/,
+  /^mcp__seedance(?:_\d+)?__seedance_create_task$/
+];
+function isOfficialMediaGenerationToolName(toolName) {
+  return OFFICIAL_MEDIA_GENERATION_TOOLS.has(toolName) || OFFICIAL_MEDIA_GENERATION_TOOL_PATTERNS.some((pattern) => pattern.test(toolName));
+}
+function createOfficialMediaGenerationTurnGuard() {
+  return {
+    replyMessageId: null,
+    toolName: null,
+    duplicateDenied: false
+  };
+}
+function resetOfficialMediaGenerationTurnGuard(guard, replyMessageId) {
+  guard.replyMessageId = replyMessageId;
+  guard.toolName = null;
+  guard.duplicateDenied = false;
+}
+var OFFICIAL_MEDIA_DUPLICATE_DENY_REASON = "\u672C\u8F6E\u5DF2\u7ECF\u8C03\u7528\u8FC7\u5B98\u65B9\u5A92\u4F53\u751F\u6210\u5DE5\u5177";
+function isOfficialMediaGenerationDuplicateDenyMessage(message) {
+  return message.includes(OFFICIAL_MEDIA_DUPLICATE_DENY_REASON);
+}
+function guardOfficialMediaGenerationTool(guard, toolName) {
+  if (!isOfficialMediaGenerationToolName(toolName)) return null;
+  if (!guard.toolName) {
+    guard.toolName = toolName;
+    return null;
+  }
+  guard.duplicateDenied = true;
+  return {
+    behavior: "deny",
+    message: `\u672C\u8F6E\u5DF2\u7ECF\u8C03\u7528\u8FC7\u5B98\u65B9\u5A92\u4F53\u751F\u6210\u5DE5\u5177\uFF08${guard.toolName}\uFF09\u3002\u6BCF\u6761\u7528\u6237\u8BF7\u6C42\u53EA\u80FD\u751F\u6210\u4E00\u4E2A\u5A92\u4F53\u7ED3\u679C\uFF1B\u8BF7\u505C\u6B62\u91CD\u8BD5\uFF0C\u76F4\u63A5\u6839\u636E\u5DF2\u7ECF\u8FD4\u56DE\u7684\u5A92\u4F53\u5361\u7247\u56DE\u590D\u7528\u6237\u3002`
+  };
+}
+function createOfficialMediaGenerationPreToolUseHooks(guard, toolNames, meta3) {
+  const mediaToolNames = /* @__PURE__ */ new Set([
+    ...OFFICIAL_MEDIA_GENERATION_TOOL_NAMES,
+    ...Array.from(toolNames).filter(isOfficialMediaGenerationToolName)
+  ]);
+  return Array.from(mediaToolNames).map((toolName) => ({
+    matcher: toolName,
+    hooks: [
+      async (_input) => {
+        const decision = guardOfficialMediaGenerationTool(guard, toolName);
+        if (!decision || decision.behavior !== "deny") return {};
+        meta3.log("PreToolUse deny: duplicate official media generation tool in one turn", {
+          agentId: meta3.agentId,
+          scope: meta3.scope,
+          toolName,
+          firstToolName: guard.toolName,
+          replyMessageId: guard.replyMessageId
+        });
+        return {
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: decision.message
+          }
+        };
+      }
+    ]
+  }));
+}
 function normalizedCommand(input) {
   const raw = input.command;
   return typeof raw === "string" ? raw.replace(/\s+/g, " ").trim() : "";
@@ -23377,8 +23842,10 @@ function date4(params) {
 config(en_default());
 
 // src/documentReader.ts
-import fs3 from "fs/promises";
-import path8 from "path";
+import fs4 from "fs/promises";
+import { execFile } from "child_process";
+import path9 from "path";
+import { promisify } from "util";
 
 // src/runtimeEnv.ts
 import { execFileSync } from "child_process";
@@ -23518,8 +23985,112 @@ function resolveUserPath(input) {
   return path7.isAbsolute(value) ? path7.normalize(value) : path7.resolve(value);
 }
 
+// src/officeRuntime.ts
+import fs3 from "fs";
+import os5 from "os";
+import path8 from "path";
+var OFFICECLI_EXECUTABLE_ENV = "AHCHAT_OFFICECLI_EXECUTABLE";
+var OFFICECLI_BIN_DIR_ENV = "AHCHAT_OFFICECLI_BIN_DIR";
+var logger6 = createModuleLogger("bridge.officeRuntime");
+function sanitizedOfficeCliProbeError(error51) {
+  const rawCode = error51 && typeof error51 === "object" && "code" in error51 ? error51.code : void 0;
+  const code = typeof rawCode === "string" ? rawCode : void 0;
+  const sanitized = new Error(`OfficeCLI executable probe failed${code ? ` (${code})` : ""}`);
+  if (error51 instanceof Error) sanitized.name = error51.name;
+  return sanitized;
+}
+function defaultRuntimeRoot() {
+  if (process.platform === "win32") {
+    return path8.join(process.env.LOCALAPPDATA || path8.join(os5.homedir(), "AppData", "Local"), "AHChat", "runtime", "officecli");
+  }
+  if (process.platform === "darwin") {
+    return path8.join(os5.homedir(), "Library", "Caches", "AHChat", "runtime", "officecli");
+  }
+  return path8.join(process.env.XDG_CACHE_HOME || path8.join(os5.homedir(), ".cache"), "ahchat", "runtime", "officecli");
+}
+function getManagedOfficeCliBinDir(env2 = process.env) {
+  return env2[OFFICECLI_BIN_DIR_ENV] || path8.join(defaultRuntimeRoot(), "bin");
+}
+function getOfficeCliExecutableName() {
+  return process.platform === "win32" ? "officecli.exe" : "officecli";
+}
+function getManagedOfficeCliExecutablePath(env2 = process.env) {
+  return path8.join(getManagedOfficeCliBinDir(env2), getOfficeCliExecutableName());
+}
+function isExecutable(filePath, options = {}) {
+  const logFailure = options.logFailure !== false;
+  try {
+    if (process.platform === "win32") return fs3.existsSync(filePath);
+    fs3.accessSync(filePath, fs3.constants.X_OK);
+    return true;
+  } catch (error51) {
+    if (logFailure) {
+      logger6.error("OfficeCLI executable probe failed", {
+        error: sanitizedOfficeCliProbeError(error51),
+        fileName: path8.basename(filePath)
+      });
+    }
+    return false;
+  }
+}
+function withPrependedPath(env2, entries) {
+  const pathEntries = entries.filter((entry) => entry && fs3.existsSync(entry));
+  if (pathEntries.length === 0) return env2;
+  const current = env2.PATH ?? "";
+  return {
+    ...env2,
+    PATH: [...pathEntries, current].filter(Boolean).join(path8.delimiter)
+  };
+}
+function statusForPath(filePath, source, env2, options = {}) {
+  if (!isExecutable(filePath, { logFailure: options.logProbeFailure })) {
+    return {
+      ok: false,
+      path: filePath,
+      source,
+      message: `officecli not executable at ${filePath}`
+    };
+  }
+  const runtimeEnv = withPrependedPath(env2, [path8.dirname(filePath)]);
+  const version2 = readCommandVersion(filePath, ["--version"], runtimeEnv);
+  if (!version2) {
+    return {
+      ok: false,
+      path: filePath,
+      source,
+      message: `officecli found at ${filePath} but --version failed`
+    };
+  }
+  return { ok: true, path: filePath, source, version: version2 };
+}
+function detectOfficeCliRuntime(env2 = process.env) {
+  const explicitPath = env2[OFFICECLI_EXECUTABLE_ENV]?.trim();
+  if (explicitPath) return statusForPath(explicitPath, "env", env2);
+  const managedPath = getManagedOfficeCliExecutablePath(env2);
+  const managed = statusForPath(managedPath, "managed", env2, { logProbeFailure: false });
+  if (managed.ok) return managed;
+  const resolved = resolveCommand(["officecli"], withPrependedPath(env2, [path8.dirname(managedPath)]));
+  if (!resolved) {
+    return {
+      ok: false,
+      source: "managed",
+      path: managedPath,
+      message: `officecli not found. Run pnpm setup:office-runtime or set ${OFFICECLI_EXECUTABLE_ENV}.`
+    };
+  }
+  return statusForPath(resolved.path, resolved.path === managedPath ? "managed" : "path", env2);
+}
+function withOfficeCliRuntimeEnv(status, env2 = process.env) {
+  if (!status.ok || !status.path) return env2;
+  return {
+    ...withPrependedPath(env2, [path8.dirname(status.path)]),
+    [OFFICECLI_EXECUTABLE_ENV]: status.path
+  };
+}
+
 // src/documentReader.ts
-var logger6 = createModuleLogger("document.reader");
+var logger7 = createModuleLogger("document.reader");
+var execFileAsync = promisify(execFile);
 var SUPPORTED_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".docx",
   ".xls",
@@ -23556,31 +24127,31 @@ var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
 var DEFAULT_MAX_CHARS = 5e5;
 var DEFAULT_TIMEOUT_MS = 45e3;
 function isReadableDocumentPath(filePath) {
-  return SUPPORTED_DOCUMENT_EXTENSIONS.has(path8.extname(filePath).toLowerCase());
+  return SUPPORTED_DOCUMENT_EXTENSIONS.has(path9.extname(filePath).toLowerCase());
 }
 function resolveDocumentPath(inputPath, cwd) {
   const trimmed = inputPath.trim();
   if (!trimmed) throw new Error("path is required");
-  const resolvedCwd = path8.resolve(resolveUserPath(cwd));
-  const candidate = path8.isAbsolute(trimmed) ? path8.resolve(resolveUserPath(trimmed)) : path8.resolve(resolvedCwd, trimmed);
-  const relative = path8.relative(resolvedCwd, candidate);
-  if (relative.startsWith("..") || path8.isAbsolute(relative)) {
+  const resolvedCwd = path9.resolve(resolveUserPath(cwd));
+  const candidate = path9.isAbsolute(trimmed) ? path9.resolve(resolveUserPath(trimmed)) : path9.resolve(resolvedCwd, trimmed);
+  const relative = path9.relative(resolvedCwd, candidate);
+  if (relative.startsWith("..") || path9.isAbsolute(relative)) {
     throw new Error("document path must be inside the current working directory");
   }
   return candidate;
 }
 async function readDocumentAsMarkdown(inputPath, opts = {}) {
-  const resolvedPath = opts.cwd ? resolveDocumentPath(inputPath, opts.cwd) : path8.resolve(resolveUserPath(inputPath));
-  const ext = path8.extname(resolvedPath).toLowerCase();
+  const resolvedPath = opts.cwd ? resolveDocumentPath(inputPath, opts.cwd) : path9.resolve(resolveUserPath(inputPath));
+  const ext = path9.extname(resolvedPath).toLowerCase();
   if (!isReadableDocumentPath(resolvedPath)) {
     throw new Error(`unsupported document type: ${ext || "(no extension)"}`);
   }
-  const stat3 = await fs3.stat(resolvedPath);
+  const stat3 = await fs4.stat(resolvedPath);
   if (!stat3.isFile()) throw new Error("path is not a file");
   const warnings = [];
   let markdown;
   if (TEXT_EXTENSIONS.has(ext)) {
-    markdown = await fs3.readFile(resolvedPath, "utf-8");
+    markdown = await fs4.readFile(resolvedPath, "utf-8");
   } else if (ext === ".xls") {
     markdown = await convertLegacyExcelDocument(resolvedPath);
   } else {
@@ -23598,7 +24169,7 @@ async function readDocumentAsMarkdown(inputPath, opts = {}) {
   if (!markdown.trim()) {
     warnings.push("No readable text was extracted from this document.");
   }
-  logger6.info("Document read as markdown", {
+  logger7.info("Document read as markdown", {
     path: resolvedPath,
     ext,
     length: markdown.length,
@@ -23613,21 +24184,21 @@ async function readDocumentAsMarkdown(inputPath, opts = {}) {
   };
 }
 function documentSidecarPath(filePath, outputDir) {
-  const dir = outputDir ?? path8.dirname(filePath);
-  const base = path8.basename(filePath);
-  return path8.join(dir, `${base}.content.md`);
+  const dir = outputDir ?? path9.dirname(filePath);
+  const base = path9.basename(filePath);
+  return path9.join(dir, `${base}.content.md`);
 }
 async function writeDocumentSidecar(filePath, opts = {}) {
   const result = await readDocumentAsMarkdown(filePath, opts);
-  const sidecarDir = opts.sidecarDir ? path8.resolve(resolveUserPath(opts.sidecarDir)) : path8.dirname(result.path);
+  const sidecarDir = opts.sidecarDir ? path9.resolve(resolveUserPath(opts.sidecarDir)) : path9.dirname(result.path);
   if (opts.cwd) {
-    const resolvedCwd = path8.resolve(resolveUserPath(opts.cwd));
-    const relative = path8.relative(resolvedCwd, sidecarDir);
-    if (relative.startsWith("..") || path8.isAbsolute(relative)) {
+    const resolvedCwd = path9.resolve(resolveUserPath(opts.cwd));
+    const relative = path9.relative(resolvedCwd, sidecarDir);
+    if (relative.startsWith("..") || path9.isAbsolute(relative)) {
       throw new Error("document sidecar path must be inside the current working directory");
     }
   }
-  await fs3.mkdir(sidecarDir, { recursive: true });
+  await fs4.mkdir(sidecarDir, { recursive: true });
   const sidecarPath = documentSidecarPath(result.path, sidecarDir);
   const warningText = result.warnings.length > 0 ? `
 
@@ -23642,8 +24213,8 @@ ${result.warnings.map((w) => `- ${w}`).join("\n")}
     result.markdown,
     warningText
   ].join("\n");
-  await fs3.writeFile(sidecarPath, content, "utf-8");
-  logger6.info("Document sidecar written", {
+  await fs4.writeFile(sidecarPath, content, "utf-8");
+  logger7.info("Document sidecar written", {
     path: result.path,
     sidecarPath,
     length: content.length
@@ -23666,7 +24237,7 @@ async function convertOfficeDocument(filePath, timeoutMs) {
         abortSignal: controller.signal
       },
       onWarning: (issue2) => {
-        logger6.warn("Document conversion warning", {
+        logger7.warn("Document conversion warning", {
           path: filePath,
           code: issue2.code,
           message: issue2.message
@@ -23676,10 +24247,53 @@ async function convertOfficeDocument(filePath, timeoutMs) {
     if (typeof result.value === "string") return result.value;
     if (result.value instanceof Uint8Array) return Buffer.from(result.value).toString("utf-8");
     return JSON.stringify(result.value, null, 2);
+  } catch (e) {
+    if (path9.extname(filePath).toLowerCase() !== ".docx") throw e;
+    logger7.warn("Office parser failed; trying OfficeCLI text fallback", {
+      path: filePath,
+      error: e
+    });
+    try {
+      return await convertDocxWithOfficeCli(filePath, timeoutMs);
+    } catch (fallbackError) {
+      logger7.warn("OfficeCLI text fallback failed", {
+        path: filePath,
+        error: fallbackError
+      });
+      throw e;
+    }
   } finally {
     clearTimeout(timer);
   }
 }
+function parseOfficeCliParagraphText(value) {
+  if (!value || typeof value !== "object") return "";
+  const root = value;
+  if (root.success !== true || !root.data || typeof root.data !== "object") return "";
+  const data = root.data;
+  if (!Array.isArray(data.results)) return "";
+  return data.results.map((item) => {
+    if (!item || typeof item !== "object") return "";
+    const text = item.text;
+    return typeof text === "string" ? text.trim() : "";
+  }).filter((text) => text.length > 0).join("\n\n");
+}
+async function convertDocxWithOfficeCli(filePath, timeoutMs) {
+  const executable = process.env[OFFICECLI_EXECUTABLE_ENV]?.trim() || "officecli";
+  const { stdout } = await execFileAsync(executable, ["query", filePath, "paragraph", "--json"], {
+    timeout: timeoutMs,
+    maxBuffer: 20 * 1024 * 1024,
+    windowsHide: true
+  });
+  const parsed = JSON.parse(stdout);
+  const text = parseOfficeCliParagraphText(parsed);
+  if (!text.trim()) throw new Error("OfficeCLI returned no paragraph text");
+  logger7.info("Document read via OfficeCLI text fallback", {
+    path: filePath,
+    length: text.length
+  });
+  return text;
+}
 async function convertLegacyExcelDocument(filePath) {
   const XLSX = await import("./xlsx-E4ZR5JHK.js");
   const workbook = XLSX.readFile(filePath, { cellDates: true });
@@ -23728,7 +24342,9 @@ function normalizeDocumentText(value) {
 }
 
 // src/neuralMcpServer.ts
-var logger7 = createModuleLogger("neural.mcpServer");
+var logger8 = createModuleLogger("neural.mcpServer");
+var VIDEO_GENERATION_SKILL_ID = OFFICIAL_MEDIA_SKILL_IDS[0];
+var AUTO_LOCAL_ENHANCER_LIMIT = 2;
 function formatSkillEntry(entry, index) {
   return [
     `${index + 1}. ${entry.displayName} (${entry.name})`,
@@ -23761,7 +24377,7 @@ function runtimeSkillIndexEntries(skillStore, agentId, smithDefaultAllSkills = f
       return entry.runtimeAvailability === "available";
     });
   } catch (e) {
-    logger7.warn("Runtime skill index unavailable", { error: e });
+    logger8.warn("Runtime skill index unavailable", { error: e });
     return [];
   }
 }
@@ -23771,7 +24387,7 @@ function runtimeVisibleSkillIds(skillStore, runtimeEntries) {
   try {
     for (const name of skillStore.allowedNames()) ids.add(name);
   } catch (e) {
-    logger7.warn("Runtime skill names unavailable", { error: e });
+    logger8.warn("Runtime skill names unavailable", { error: e });
   }
   for (const entry of runtimeEntries) {
     ids.add(entry.id);
@@ -23790,12 +24406,75 @@ function filterAgentAvailableSkillEntries(entries, availableIds) {
   if (!availableIds) return entries;
   return entries.filter((entry) => availableIds.has(entry.id) || availableIds.has(entry.name));
 }
-function skillRuntimeContext(officeCliRuntime) {
-  return officeCliRuntime ? {
-    officeCliAvailable: officeCliRuntime.ok,
-    officeCliPath: officeCliRuntime.path,
-    officeCliVersion: officeCliRuntime.version,
-    officeCliMessage: officeCliRuntime.message
+function matchesVideoGenerationIntent(input) {
+  const roleText = [input.name, input.role].join("\n").toLowerCase();
+  if (/seedance|生视频|视频生成|生成视频|视频助手|ai\s*video|video\s*generation|creative\s*video/.test(roleText)) {
+    return true;
+  }
+  if (roleText.includes("\u89C6\u9891") && /[生成创作制作导演剪辑]/.test(roleText)) {
+    return true;
+  }
+  const promptText = [input.systemPrompt, input.initialInstruction].join("\n").toLowerCase();
+  return /seedance|生视频|视频生成|生成视频|文生视频|图生视频|text-to-video|image-to-video|ai\s*video|video\s*generation/.test(promptText);
+}
+var AUTO_ASSIGN_SKILL_RULES = [
+  {
+    skillId: VIDEO_GENERATION_SKILL_ID,
+    intent: "media_video_generation",
+    matches: matchesVideoGenerationIntent
+  }
+];
+function autoAssignOfficialSkillIds(input) {
+  return AUTO_ASSIGN_SKILL_RULES.filter((rule) => rule.matches(input)).map((rule) => rule.skillId);
+}
+function runtimeCachedSkillIds(skillStore) {
+  if (!skillStore) return /* @__PURE__ */ new Set();
+  try {
+    return new Set(skillStore.allowedNames());
+  } catch (e) {
+    logger8.warn("Runtime skill names unavailable", { error: e });
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isCurrentMachineLocalTarget(targetBridgeKey, currentBridgeKey) {
+  const target = targetBridgeKey?.trim();
+  if (!target) return true;
+  const current = currentBridgeKey?.trim();
+  return Boolean(current && target === current);
+}
+function selectLocalSkillEnhancersForCreateAgent(input, skillStore, alreadySelectedSkillIds) {
+  if (!skillStore) return [];
+  const cachedSkillIds = runtimeCachedSkillIds(skillStore);
+  if (cachedSkillIds.size === 0) return [];
+  const localCandidates2 = runtimeSkillIndexEntries(
+    skillStore,
+    null,
+    true,
+    true
+  ).filter((entry) => {
+    if (entry.runtimeAvailability !== "available") return false;
+    if (entry.origin !== "local" && !isLocalSkillId(entry.id)) return false;
+    if (alreadySelectedSkillIds.has(entry.id) || alreadySelectedSkillIds.has(entry.name)) return false;
+    return cachedSkillIds.has(entry.id) || cachedSkillIds.has(entry.name);
+  });
+  if (localCandidates2.length === 0) return [];
+  const localCandidateIds = new Set(localCandidates2.map((entry) => entry.id));
+  const recommendations = recommendInitialSkillsForAgent({
+    role: input.role,
+    systemPrompt: input.systemPrompt,
+    workingDirectory: input.workingDirectory,
+    task: [input.name, input.role, input.initialInstruction].filter(Boolean).join("\n"),
+    includePlanned: false,
+    entries: localCandidates2
+  });
+  return recommendations.map((rec) => rec.skill.id).filter((skillId) => localCandidateIds.has(skillId)).filter((skillId, index, ids) => ids.indexOf(skillId) === index).slice(0, AUTO_LOCAL_ENHANCER_LIMIT);
+}
+function skillRuntimeContext(officeCliRuntime) {
+  return officeCliRuntime ? {
+    officeCliAvailable: officeCliRuntime.ok,
+    officeCliPath: officeCliRuntime.path,
+    officeCliVersion: officeCliRuntime.version,
+    officeCliMessage: officeCliRuntime.message
   } : void 0;
 }
 var NEURAL_DEDUP_WINDOW_MS = 3e4;
@@ -23835,6 +24514,16 @@ function formatMachineOptionLine(machine) {
   const bridgeId = machine.bridgeId ? `\uFF0CbridgeId=${machine.bridgeId}` : "";
   return `- machine_bridge_key=${machine.bridgeKey} [${machineStatusText(machine)}] ${formatBridgeMachineLabel(machine)}${bridgeId}`;
 }
+function rejectRemoteCreateMachineBridgeKey(machineBridgeKey, deps) {
+  if (!machineBridgeKey || machineBridgeKey === "auto") return null;
+  const currentBridgeKey = deps.currentBridgeKey?.trim();
+  if (!currentBridgeKey || machineBridgeKey === currentBridgeKey) return null;
+  return [
+    `[create_agent] \u4E3A\u907F\u514D\u628A\u65B0 Agent \u521B\u5EFA\u5230\u522B\u7684\u7535\u8111\uFF0C\u521B\u5EFA\u65F6\u4E0D\u8981\u4F20\u5176\u4ED6\u673A\u5668\u7684 machine_bridge_key\u3002`,
+    `\u8BF7\u7701\u7565 machine_bridge_key\uFF0C\u8BA9\u5B83\u4F7F\u7528\u5F53\u524D\u673A\u5668\uFF08${currentBridgeKey}\uFF09\u3002`,
+    `\u5982\u679C\u7528\u6237\u660E\u786E\u8981\u6C42\u5207\u5230\u5176\u4ED6\u7535\u8111\uFF0C\u8BF7\u5148\u521B\u5EFA Agent\uFF0C\u518D\u7528 update_agent_profile \u5207\u6362\u8FD0\u884C\u673A\u5668\u3002`
+  ].join(" ");
+}
 async function fetchVisibleBridgeMachines(deps) {
   if (!deps.serverApiUrl || !deps.bridgeToken) return [];
   try {
@@ -23843,14 +24532,14 @@ async function fetchVisibleBridgeMachines(deps) {
       headers: bridgeAuthHeaders(deps.bridgeToken)
     });
     if (!res.ok) {
-      logger7.warn("Bridge machine listing failed", { status: res.status });
+      logger8.warn("Bridge machine listing failed", { status: res.status });
       return [];
     }
     const body = await res.json();
     if (!Array.isArray(body)) return [];
     return body.filter(isBridgeMachineSummary);
   } catch (e) {
-    logger7.warn("Bridge machine listing failed", { error: e });
+    logger8.warn("Bridge machine listing failed", { error: e });
     return [];
   }
 }
@@ -23895,7 +24584,7 @@ async function resolveTierSubscriptionPreference(preferredSubscriptionId, deps)
       (subscription) => subscription.billingMode === "company_billable" && subscription.isPrimaryCompany === true
     )?.id ?? preferredSubscriptionId;
   } catch (e) {
-    logger7.warn("Primary company tier preference resolution failed", { error: e });
+    logger8.warn("Primary company tier preference resolution failed", { error: e });
     return preferredSubscriptionId;
   }
 }
@@ -24070,7 +24759,7 @@ async function createNeuralMcpServer(deps) {
       message: external_exports.string().min(1).describe('\u8981\u4F20\u7ED9\u76EE\u6807\u5206\u8EAB\u7684\u4E00\u6BB5\u81EA\u7136\u8BED\u8A00\u3002\u5B83\u4F1A\u4F5C\u4E3A\u4F60\u7684"\u5185\u5FC3\u72EC\u767D"\u51FA\u73B0\u5728\u90A3\u4E2A scope\u3002')
     },
     async (args) => {
-      logger7.info("neural_send tool called", {
+      logger8.info("neural_send tool called", {
         agentId: deps.agentId,
         fromScope: currentScopeKey,
         rawTargetScope: args.target_scope,
@@ -24092,7 +24781,7 @@ async function createNeuralMcpServer(deps) {
         if (singleConvId) {
           conversationId = singleConvId;
         } else {
-          logger7.warn("neural_send: failed to resolve single conv", { agentId: deps.agentId });
+          logger8.warn("neural_send: failed to resolve single conv", { agentId: deps.agentId });
           return {
             content: [{ type: "text", text: "[neural_send] \u65E0\u6CD5\u89E3\u6790\u5355\u804A conversationId\uFF0C\u6D88\u606F\u672A\u9001\u8FBE\u3002\u8BF7\u5237\u65B0\u4F1A\u8BDD\u540E\u91CD\u8BD5\u3002" }],
             isError: true
@@ -24101,7 +24790,7 @@ async function createNeuralMcpServer(deps) {
       } else if (args.target_scope.startsWith("group:")) {
         const r = await deps.groupRegistry.resolveScope(args.target_scope);
         if (!r) {
-          logger7.info("neural_send: target scope not found", { rawTargetScope: args.target_scope });
+          logger8.info("neural_send: target scope not found", { rawTargetScope: args.target_scope });
           return {
             content: [{ type: "text", text: `[neural_send] \u627E\u4E0D\u5230\u7FA4\u300C${args.target_scope.slice(6)}\u300D\u3002\u8BF7\u786E\u8BA4\u7FA4\u540D\u662F\u5426\u6B63\u786E\u3002` }],
             isError: true
@@ -24118,7 +24807,7 @@ async function createNeuralMcpServer(deps) {
           cached2 = deps.groupRegistry.getById(r.groupId);
         }
         if (!cached2 || !cached2.members.includes(deps.agentId)) {
-          logger7.info("neural_send: not a member of target group", {
+          logger8.info("neural_send: not a member of target group", {
             agentId: deps.agentId,
             groupId: r.groupId,
             groupName: r.groupName,
@@ -24133,7 +24822,7 @@ async function createNeuralMcpServer(deps) {
             isError: true
           };
         }
-        logger7.info("neural_send: member check passed", {
+        logger8.info("neural_send: member check passed", {
           agentId: deps.agentId,
           groupId: r.groupId,
           groupName: r.groupName
@@ -24145,7 +24834,7 @@ async function createNeuralMcpServer(deps) {
         };
       }
       if (resolvedKey === currentScopeKey) {
-        logger7.warn("neural_send: self-send refused", { agentId: deps.agentId, scope: currentScopeKey });
+        logger8.warn("neural_send: self-send refused", { agentId: deps.agentId, scope: currentScopeKey });
         return {
           content: [{ type: "text", text: "[neural_send] \u4E0D\u80FD\u628A\u6D88\u606F\u9001\u7ED9\u81EA\u5DF1\u5F53\u524D\u6240\u5728\u7684 scope\u3002" }],
           isError: true
@@ -24163,7 +24852,7 @@ async function createNeuralMcpServer(deps) {
       if (sendHistory.length >= NEURAL_DEDUP_MAX_REPEATS) {
         sendHistory.push(nowTs);
         recentNeuralSends.set(dedupKey, sendHistory);
-        logger7.warn("neural_send: identical message throttled (repetition guard)", {
+        logger8.warn("neural_send: identical message throttled (repetition guard)", {
           agentId: deps.agentId,
           fromScope: currentScopeKey,
           toScope: resolvedKey,
@@ -24192,7 +24881,7 @@ async function createNeuralMcpServer(deps) {
         });
         sendHistory.push(nowTs);
         recentNeuralSends.set(dedupKey, sendHistory);
-        logger7.info("neural_send delivered", {
+        logger8.info("neural_send delivered", {
           agentId: deps.agentId,
           fromScope: currentScopeKey,
           toScope: resolvedKey,
@@ -24203,7 +24892,7 @@ async function createNeuralMcpServer(deps) {
           content: [{ type: "text", text: `[neural_send] \u5DF2\u9001\u8FBE\u5230\u300C${toLabel}\u300D(scope: ${resolvedKey})\u3002` }]
         };
       } catch (err) {
-        logger7.error("neural_send dispatch failed", { agentId: deps.agentId, error: err });
+        logger8.error("neural_send dispatch failed", { agentId: deps.agentId, error: err });
         return {
           content: [{ type: "text", text: `[neural_send] \u9001\u8FBE\u5931\u8D25\uFF1A${err.message}` }],
           isError: true
@@ -24229,7 +24918,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
     async (args) => {
       const action = args.action;
       const content = args.content;
-      logger7.info("self_note tool called", {
+      logger8.info("self_note tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         action,
@@ -24238,7 +24927,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
       if (action === "read") {
         const current = deps.memoryStore.read(deps.agentId);
         if (current.length === 0) {
-          logger7.info("self_note read empty", {
+          logger8.info("self_note read empty", {
             agentId: deps.agentId,
             scope: currentScopeKey
           });
@@ -24246,7 +24935,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
             content: [{ type: "text", text: "[self_note] \u4F60\u7684\u7B14\u8BB0\u672C\u76EE\u524D\u662F\u7A7A\u7684\u3002" }]
           };
         }
-        logger7.info("self_note read ok", {
+        logger8.info("self_note read ok", {
           agentId: deps.agentId,
           scope: currentScopeKey,
           notebookBytes: current.length
@@ -24257,7 +24946,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
       }
       if (action === "append" || action === "write") {
         if (typeof content !== "string" || content.length === 0) {
-          logger7.warn("self_note missing content", {
+          logger8.warn("self_note missing content", {
             agentId: deps.agentId,
             scope: currentScopeKey,
             action
@@ -24274,7 +24963,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
             deps.memoryStore.write(deps.agentId, content);
           }
           const after = deps.memoryStore.read(deps.agentId);
-          logger7.info("self_note persisted", {
+          logger8.info("self_note persisted", {
             agentId: deps.agentId,
             scope: currentScopeKey,
             action,
@@ -24285,14 +24974,14 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
             content: [{ type: "text", text: `[self_note] \u5DF2${action === "append" ? "\u8FFD\u52A0" : "\u8986\u76D6"}\uFF0C\u5F53\u524D\u7B14\u8BB0\u672C\u5171 ${after.length} \u5B57\u7B26\u3002` }]
           };
         } catch (err) {
-          logger7.error("self_note write failed", { agentId: deps.agentId, action, error: err });
+          logger8.error("self_note write failed", { agentId: deps.agentId, action, error: err });
           return {
             content: [{ type: "text", text: `[self_note] \u5199\u5165\u5931\u8D25\uFF1A${err.message}` }],
             isError: true
           };
         }
       }
-      logger7.warn("self_note invalid action", {
+      logger8.warn("self_note invalid action", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         action: String(action)
@@ -24311,7 +25000,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
 \u901A\u5E38\u4F60\u4E0D\u9700\u8981\u4E3B\u52A8\u8C03\u2014\u2014\u8FD9\u4EFD\u5217\u8868\u5DF2\u7ECF\u5728\u4F60\u7684 system prompt \u9876\u90E8\u9759\u6001\u6CE8\u5165\u8FC7\u3002\u4EC5\u5728\u4F60\u6000\u7591\u5217\u8868\u8FC7\u65F6\uFF08\u6BD4\u5982\u7528\u6237\u521A\u8BF4\u81EA\u5DF1\u521A\u62C9\u4F60\u8FDB\u4E86\u4E00\u4E2A\u7FA4\uFF0C\u4F46\u4F60\u7684\u5FEB\u7167\u91CC\u6CA1\u6709\uFF09\u65F6\u5237\u65B0\u4E00\u6B21\u3002`,
     {},
     async () => {
-      logger7.info("neural_list_scopes tool called", {
+      logger8.info("neural_list_scopes tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey
       });
@@ -24319,7 +25008,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
       let myGroups;
       if (cachedScopes && now - cachedScopes.at < SCOPES_CACHE_MS) {
         myGroups = cachedScopes.groups;
-        logger7.info("neural_list_scopes: cache hit", {
+        logger8.info("neural_list_scopes: cache hit", {
           agentId: deps.agentId,
           cachedAt: cachedScopes.at,
           ageMs: now - cachedScopes.at
@@ -24331,7 +25020,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
           name: g.name
         }));
         cachedScopes = { groups: myGroups, at: now };
-        logger7.info("neural_list_scopes: registry refreshed", {
+        logger8.info("neural_list_scopes: registry refreshed", {
           agentId: deps.agentId,
           scope: currentScopeKey,
           myGroupCount: myGroups.length
@@ -24353,7 +25042,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
         '\u8C03 neural_send(target_scope="...") \u65F6\u8BF7\u7528\u4E0A\u9762\u5217\u51FA\u7684 scope \u5B57\u7B26\u4E32\u3002',
         myGroups.length === 0 ? "\uFF08\u4F60\u4E0D\u662F\u4EFB\u4F55\u7FA4\u7684\u6210\u5458\uFF1B\u53EF\u4E0E\u7528\u6237\u5728 single \u901A\u8BDD\uFF0C\u4F46\u6682\u65F6\u6CA1\u6709\u8DE8\u7FA4\u5206\u8EAB\u53EF\u89E6\u8FBE\u3002\uFF09" : "\u82E5\u7528\u6237\u63D0\u5230\u7684\u7FA4\u540D\u4E0D\u5728\u5217\u8868\u91CC\uFF0C\u8BF4\u660E\u4F60\u4E0D\u662F\u8BE5\u7FA4\u6210\u5458\u2014\u2014\u522B\u5C1D\u8BD5 neural_send \u5230\u90A3\u4E2A\u7FA4\uFF08\u4F1A\u88AB\u62D2\uFF09\u3002"
       ].join("\n");
-      logger7.info("neural_list_scopes returned", {
+      logger8.info("neural_list_scopes returned", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         groupCount: myGroups.length
@@ -24384,7 +25073,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
     async (args) => {
       const requestedScope = args.scope?.trim() || "current";
       const limit = Math.min(50, Math.max(1, Math.floor(args.limit ?? 20)));
-      logger7.info("read_chat_history tool called", {
+      logger8.info("read_chat_history tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         requestedScope,
@@ -24414,7 +25103,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
           cached2 = deps.groupRegistry.getById(r.groupId);
         }
         if (!cached2 || !cached2.members.includes(deps.agentId)) {
-          logger7.info("read_chat_history: membership denied", {
+          logger8.info("read_chat_history: membership denied", {
             agentId: deps.agentId,
             groupId: r.groupId,
             requestedScope
@@ -24448,7 +25137,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
         scopeLabel = `\u7FA4\u300C${r?.groupName ?? targetScope.groupId}\u300D`;
       }
       if (!conversationId) {
-        logger7.info("read_chat_history: no conversation for scope", {
+        logger8.info("read_chat_history: no conversation for scope", {
           agentId: deps.agentId,
           requestedScope,
           scopeLabel
@@ -24462,7 +25151,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
         };
       }
       resolvedScopeLabel = scopeLabel;
-      logger7.info("read_chat_history: resolved target", {
+      logger8.info("read_chat_history: resolved target", {
         agentId: deps.agentId,
         requestedScope,
         conversationId,
@@ -24479,7 +25168,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
         const url2 = `${base}/api/conversations/${encodeURIComponent(conversationId)}/messages?${params.toString()}`;
         const resp = await fetch(url2);
         if (!resp.ok) {
-          logger7.warn("read_chat_history: HTTP error", {
+          logger8.warn("read_chat_history: HTTP error", {
             agentId: deps.agentId,
             status: resp.status,
             conversationId
@@ -24496,7 +25185,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
         const messages = body.messages ?? [];
         const hasMore = body.hasMore === true;
         if (messages.length === 0) {
-          logger7.info("read_chat_history: empty result", {
+          logger8.info("read_chat_history: empty result", {
             agentId: deps.agentId,
             conversationId,
             requestedScope
@@ -24526,7 +25215,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
             `\u7EE7\u7EED\u7FFB\uFF1Aread_chat_history(before="${firstTs}", scope="${requestedScope}")`
           );
         }
-        logger7.info("read_chat_history returned", {
+        logger8.info("read_chat_history returned", {
           agentId: deps.agentId,
           conversationId,
           scopeLabel: resolvedScopeLabel,
@@ -24537,7 +25226,7 @@ action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccont
         });
         return { content: [{ type: "text", text: lines.join("\n") }] };
       } catch (e) {
-        logger7.error("read_chat_history failed", { error: e, agentId: deps.agentId });
+        logger8.error("read_chat_history failed", { error: e, agentId: deps.agentId });
         return {
           content: [{
             type: "text",
@@ -24564,7 +25253,7 @@ Pass either a relative path from the current working directory or an absolute pa
     async (args) => {
       const requestedPath = args.path.trim();
       const maxChars = args.max_chars ?? 12e4;
-      logger7.info("read_document tool called", {
+      logger8.info("read_document tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         path: requestedPath,
@@ -24586,7 +25275,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
           warningText,
           result.markdown
         ].filter((line) => line.length > 0).join("\n");
-        logger7.info("read_document returned", {
+        logger8.info("read_document returned", {
           agentId: deps.agentId,
           scope: currentScopeKey,
           path: result.path,
@@ -24597,7 +25286,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
         return { content: [{ type: "text", text }] };
       } catch (e) {
         const message = e instanceof Error ? e.message : String(e);
-        logger7.error("read_document failed", {
+        logger8.error("read_document failed", {
           agentId: deps.agentId,
           scope: currentScopeKey,
           path: requestedPath,
@@ -24635,7 +25324,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
       if (!resolved.ok) {
         return { content: [{ type: "text", text: resolved.text }], isError: true };
       }
-      logger7.info("create_group_issue tool called", {
+      logger8.info("create_group_issue tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         groupId: resolved.groupId,
@@ -24650,7 +25339,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
           (issue2) => issue2.status === "open" && issue2.title.trim() === title
         );
         if (duplicate) {
-          logger7.info("create_group_issue: duplicate open issue reused", {
+          logger8.info("create_group_issue: duplicate open issue reused", {
             agentId: deps.agentId,
             groupId: resolved.groupId,
             issueId: duplicate.id,
@@ -24679,7 +25368,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("create_group_issue: server rejected", {
+          logger8.warn("create_group_issue: server rejected", {
             agentId: deps.agentId,
             groupId: resolved.groupId,
             status: res.status,
@@ -24691,7 +25380,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
           };
         }
         const payload = await res.json();
-        logger7.info("create_group_issue: created", {
+        logger8.info("create_group_issue: created", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           issueId: payload.issue?.id,
@@ -24704,7 +25393,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
           }]
         };
       } catch (e) {
-        logger7.error("create_group_issue failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId });
+        logger8.error("create_group_issue failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId });
         return {
           content: [{ type: "text", text: `[create_group_issue] \u521B\u5EFA\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -24733,7 +25422,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
       if (!resolved.ok) {
         return { content: [{ type: "text", text: resolved.text }], isError: true };
       }
-      logger7.info("resolve_group_issue tool called", {
+      logger8.info("resolve_group_issue tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         groupId: resolved.groupId,
@@ -24778,7 +25467,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
         );
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("resolve_group_issue: server rejected", {
+          logger8.warn("resolve_group_issue: server rejected", {
             agentId: deps.agentId,
             groupId: resolved.groupId,
             issueId,
@@ -24791,7 +25480,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
           };
         }
         const payload = await res.json();
-        logger7.info("resolve_group_issue: resolved", {
+        logger8.info("resolve_group_issue: resolved", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           issueId: payload.issue?.id ?? issueId
@@ -24803,7 +25492,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
           }]
         };
       } catch (e) {
-        logger7.error("resolve_group_issue failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId, issueId });
+        logger8.error("resolve_group_issue failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId, issueId });
         return {
           content: [{ type: "text", text: `[resolve_group_issue] \u5173\u95ED\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -24826,7 +25515,7 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
       if (!resolved.ok) {
         return { content: [{ type: "text", text: resolved.text }], isError: true };
       }
-      logger7.info("list_group_tasks tool called", {
+      logger8.info("list_group_tasks tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         groupId: resolved.groupId,
@@ -24850,7 +25539,7 @@ ${body}`
           }]
         };
       } catch (e) {
-        logger7.error("list_group_tasks failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId });
+        logger8.error("list_group_tasks failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId });
         return {
           content: [{ type: "text", text: `[list_group_tasks] \u67E5\u8BE2\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -24879,7 +25568,7 @@ ${body}`
       if (!resolved.ok) {
         return { content: [{ type: "text", text: resolved.text }], isError: true };
       }
-      logger7.info("update_group_task tool called", {
+      logger8.info("update_group_task tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         groupId: resolved.groupId,
@@ -24922,7 +25611,7 @@ ${body}`
         );
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("update_group_task: server rejected", {
+          logger8.warn("update_group_task: server rejected", {
             agentId: deps.agentId,
             groupId: resolved.groupId,
             itemId,
@@ -24936,7 +25625,7 @@ ${body}`
           };
         }
         const payload = await res.json();
-        logger7.info("update_group_task: updated", {
+        logger8.info("update_group_task: updated", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           itemId: payload.item?.id ?? itemId,
@@ -24949,7 +25638,7 @@ ${body}`
           }]
         };
       } catch (e) {
-        logger7.error("update_group_task failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId, itemId, status });
+        logger8.error("update_group_task failed", { error: e, agentId: deps.agentId, groupId: resolved.groupId, itemId, status });
         return {
           content: [{ type: "text", text: `[update_group_task] \u66F4\u65B0\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -24964,18 +25653,18 @@ ${body}`
 \u8FD4\u56DE\u7ED3\u6784\u662F\u4E00\u6BB5 Markdown\uFF1A\u6BCF\u4E00\u6761\u542B id / \u540D\u5B57 / \u89D2\u8272 / \u673A\u5668\u5F52\u5C5E\u3002\u4F1A\u6807\u6CE8\u54EA\u4E00\u6761\u662F"\u4F60\u81EA\u5DF1"\uFF0C\u4EE5\u53CA\u4F60\u548C\u54EA\u4E9B Agent \u5DF2\u7ECF\u5171\u5728\u67D0\u4E2A\u7FA4\u91CC\u3002\u4EBA\u7C7B\u7528\u6237\u4F1A\u5E26 (\u4EBA\u7C7B) \u6807\u8BB0\u3002
 \u901A\u5E38\u4F60\u5728\u7528\u6237\u63D0\u5230\u5177\u4F53\u540C\u4E8B\u59D3\u540D\u3001\u6216\u601D\u8003"\u8BE5\u62C9\u8C01\u8FDB\u7FA4\u534F\u4F5C"\u65F6\u8C03\u4E00\u6B21\uFF1B\u4E0D\u8981\u6BCF\u8F6E\u90FD\u67E5\u3002
 \u652F\u6301 filter\uFF08\u6309\u540D\u5B57\u6216\u89D2\u8272\u6A21\u7CCA\u641C\u7D22\uFF09\u548C limit\uFF08\u9650\u5236\u8FD4\u56DE\u6761\u6570\uFF09\u53C2\u6570\u3002
-Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\u53C2\u8003"\u53EF\u7528\u673A\u5668"\u91CC\u7684 bridgeKey\uFF0C\u7ED9 create_agent / update_agent_profile \u4F20 machine_bridge_key\uFF1B\u7701\u7565\u5219\u4F7F\u7528\u5F53\u524D Bridge \u6216\u4FDD\u7559\u539F\u504F\u597D\u3002
+Smith \u521B\u5EFA Agent \u65F6\u9ED8\u8BA4\u4E0D\u8981\u4F20 machine_bridge_key\uFF1B\u7701\u7565\u5373\u4F7F\u7528\u5F53\u524D Bridge\u3002\u53EA\u6709\u7528\u6237\u660E\u786E\u6307\u5B9A\u67D0\u53F0\u673A\u5668\u65F6\uFF0C\u624D\u53C2\u8003"\u53EF\u7528\u673A\u5668"\u91CC\u7684 bridgeKey\uFF0C\u5E76\u4F18\u5148\u901A\u8FC7 update_agent_profile \u5207\u6362\u3002
 \u8981\u628A\u4EBA\u7C7B\u62C9\u8FDB\u7FA4\uFF1A\u5728 create_group / add_to_group \u7684 member_ids / agent_ids \u91CC\u5E26\u4E0A**\u8BF7\u6C42\u8005\u7684\u4EBA\u7C7B id**\uFF08\u5373\u5217\u8868\u91CC\u5E26"(\u4EBA\u7C7B)"\u6807\u8BB0\u7684\u90A3\u4E00\u6761\uFF1B\u591A\u7528\u6237\u6A21\u5F0F\u4E0B\u6BCF\u4E2A\u7528\u6237\u90FD\u6709\u81EA\u5DF1\u72EC\u7ACB\u7684 id\uFF0C\u4F8B\u5982 agt_usr_XXX\uFF1B\u8001\u7684\u5355\u7528\u6237\u6A21\u5F0F\u4E0B\u662F agt_usr_self\uFF09\u3002\u4E0D\u8981\u786C\u7F16\u7801 agt_usr_self\u2014\u2014\u4EE5 list_contacts \u5B9E\u9645\u8FD4\u56DE\u7684 id \u4E3A\u51C6\u3002`,
     {
       filter: external_exports.string().optional().describe("\u53EF\u9009\u3002\u6309\u540D\u5B57\u6216\u89D2\u8272\u6A21\u7CCA\u8FC7\u6EE4\uFF08\u4E0D\u533A\u5206\u5927\u5C0F\u5199\uFF09\u3002"),
       limit: external_exports.number().int().min(1).max(200).optional().describe("\u6700\u591A\u8FD4\u56DE\u591A\u5C11\u6761\uFF0C\u9ED8\u8BA4\u4E0D\u9650\u3002")
     },
     async (args) => {
-      logger7.info("list_contacts tool called", { agentId: deps.agentId, scope: currentScopeKey });
+      logger8.info("list_contacts tool called", { agentId: deps.agentId, scope: currentScopeKey });
       try {
         await deps.agentRegistry.refresh();
       } catch (e) {
-        logger7.warn("list_contacts: registry refresh failed, using cache", {
+        logger8.warn("list_contacts: registry refresh failed, using cache", {
           agentId: deps.agentId,
           error: e
         });
@@ -25022,16 +25711,16 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
       const onlineMachines = machines.filter((machine) => machine.status === "online");
       const offlineMachines = machines.filter((machine) => machine.status !== "online");
       const machineSection = machines.length > 0 ? [
-        "\u5728\u7EBF\u673A\u5668\uFF08\u63A8\u8350\uFF1Bcreate_agent / update_agent_profile \u53EA\u80FD\u4F20\u8FD9\u4E9B machine_bridge_key\uFF1B\u7701\u7565\u5219\u4F7F\u7528\u5F53\u524D Bridge \u6216\u4FDD\u7559\u539F\u504F\u597D\uFF09\uFF1A",
+        "\u53EF\u7528\u673A\u5668\uFF08\u4EC5\u5728\u7528\u6237\u660E\u786E\u6307\u5B9A\u8FD0\u884C\u7535\u8111\u65F6\u4F7F\u7528\uFF1B\u666E\u901A create_agent \u4E0D\u8981\u4F20 machine_bridge_key\uFF0C\u7701\u7565\u5373\u5F53\u524D\u673A\u5668\uFF09\uFF1A",
         ...onlineMachines.length > 0 ? onlineMachines.map(formatMachineOptionLine) : ["- \u5F53\u524D\u6CA1\u6709\u5728\u7EBF\u673A\u5668\uFF1B\u53EF\u7701\u7565 machine_bridge_key\uFF0C\u8BA9\u5F53\u524D Bridge \u515C\u5E95\u3002"],
         ...offlineMachines.length > 0 ? [
           "",
           "\u79BB\u7EBF/\u4E0D\u53EF\u76F4\u63A5\u7528\u4E8E\u65B0\u5EFA\u7684\u673A\u5668\uFF08\u4E0D\u8981\u628A\u8FD9\u4E9B bridgeKey \u4F20\u7ED9 create_agent\uFF1B\u5426\u5219\u4EFB\u52A1\u4F1A Bridge offline\uFF09\uFF1A",
           ...offlineMachines.map(formatMachineOptionLine)
         ] : []
-      ].join("\n") : "\u53EF\u7528\u673A\u5668\uFF1A\u5F53\u524D Bridge\uFF08create_agent \u7701\u7565 machine_bridge_key \u5373\u4F7F\u7528\u5F53\u524D Bridge\uFF1Bupdate_agent_profile \u7701\u7565\u5373\u4FDD\u7559\u539F\u504F\u597D\uFF09\u3002";
+      ].join("\n") : "\u53EF\u7528\u673A\u5668\uFF1A\u5F53\u524D Bridge\uFF08\u666E\u901A create_agent \u7701\u7565 machine_bridge_key \u5373\u4F7F\u7528\u5F53\u524D\u673A\u5668\uFF1Bupdate_agent_profile \u7701\u7565\u5373\u4FDD\u7559\u539F\u504F\u597D\uFF09\u3002";
       const text = shown === 0 ? q ? `\u672A\u627E\u5230\u4E0E "${args?.filter}" \u5339\u914D\u7684\u8054\u7CFB\u4EBA\u3002` : "\u5F53\u524D\u7CFB\u7EDF\u91CC\u8FD8\u6CA1\u6709\u4EFB\u4F55 Agent\u3002" : [header, "", machineSection, "", ...lines].join("\n");
-      logger7.info("list_contacts returned", {
+      logger8.info("list_contacts returned", {
         agentId: deps.agentId,
         count: all.length,
         humanCount,
@@ -25094,7 +25783,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
       }
       const initialMessage = typeof args.initial_message === "string" ? args.initial_message.trim().replaceAll(USR_SELF_ID, resolveMyHuman(deps.agentRegistry, deps.agentId)) : "";
       const hasInitial = initialMessage.length > 0;
-      logger7.info("create_group tool called", {
+      logger8.info("create_group tool called", {
         agentId: deps.agentId,
         name: trimmedName,
         memberCount: dedup.length,
@@ -25125,7 +25814,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("create_group: server rejected", { status: res.status, errText });
+          logger8.warn("create_group: server rejected", { status: res.status, errText });
           return {
             content: [{ type: "text", text: `[create_group] \u670D\u52A1\u7AEF\u62D2\u7EDD\uFF08${res.status}\uFF09\uFF1A${errText || "(no body)"}` }],
             isError: true
@@ -25133,7 +25822,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         }
         const group = await res.json();
         const groupScopeKey = `group:${group.id}`;
-        logger7.info("create_group: created", {
+        logger8.info("create_group: created", {
           agentId: deps.agentId,
           groupId: group.id,
           name: group.name,
@@ -25161,7 +25850,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           }]
         };
       } catch (e) {
-        logger7.error("create_group failed", { error: e, name: trimmedName });
+        logger8.error("create_group failed", { error: e, name: trimmedName });
         return {
           content: [{ type: "text", text: `[create_group] \u5EFA\u7FA4\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -25218,7 +25907,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
       const scopeInput = rawGroup.startsWith("group:") ? rawGroup : `group:${rawGroup}`;
       const resolved = await deps.groupRegistry.resolveScope(scopeInput);
       if (!resolved) {
-        logger7.info("add_to_group: group not found", { rawGroup, scopeInput });
+        logger8.info("add_to_group: group not found", { rawGroup, scopeInput });
         return {
           content: [{ type: "text", text: `[add_to_group] \u627E\u4E0D\u5230\u7FA4\u300C${rawGroup}\u300D\u3002\u53EF\u8C03 neural_list_scopes() \u67E5\u770B\u4F60\u7684\u7FA4\u5217\u8868\u3002` }],
           isError: true
@@ -25230,7 +25919,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         cached2 = deps.groupRegistry.getById(resolved.groupId);
       }
       if (!cached2 || !cached2.members.includes(deps.agentId)) {
-        logger7.info("add_to_group: not a member of target group", {
+        logger8.info("add_to_group: not a member of target group", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           groupName: resolved.groupName
@@ -25246,7 +25935,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
       const alreadyIn = agentIds.filter((id) => cached2.members.includes(id));
       const toAdd = agentIds.filter((id) => !cached2.members.includes(id));
       if (toAdd.length === 0) {
-        logger7.info("add_to_group: all agents already in group", {
+        logger8.info("add_to_group: all agents already in group", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           alreadyIn
@@ -25258,7 +25947,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           }]
         };
       }
-      logger7.info("add_to_group tool called", {
+      logger8.info("add_to_group tool called", {
         agentId: deps.agentId,
         groupId: resolved.groupId,
         groupName: resolved.groupName,
@@ -25274,7 +25963,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("add_to_group: server rejected", {
+          logger8.warn("add_to_group: server rejected", {
             status: res.status,
             errText,
             groupId: resolved.groupId,
@@ -25289,7 +25978,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           const a = deps.agentRegistry.getById(id);
           return a ? a.name : id;
         });
-        logger7.info("add_to_group: members added", {
+        logger8.info("add_to_group: members added", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           groupName: resolved.groupName,
@@ -25308,7 +25997,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           }]
         };
       } catch (e) {
-        logger7.error("add_to_group failed", {
+        logger8.error("add_to_group failed", {
           error: e,
           groupId: resolved.groupId,
           toAdd
@@ -25355,13 +26044,13 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         cached2 = deps.groupRegistry.getById(resolved.groupId);
       }
       if (!cached2 || !cached2.members.includes(deps.agentId)) {
-        logger7.info("leave_group: not a member", { agentId: deps.agentId, groupId: resolved.groupId });
+        logger8.info("leave_group: not a member", { agentId: deps.agentId, groupId: resolved.groupId });
         return {
           content: [{ type: "text", text: `[leave_group] \u4F60\u4E0D\u5728\u7FA4\u300C${resolved.groupName}\u300D\u91CC\uFF0C\u65E0\u9700\u9000\u51FA\u3002` }],
           isError: true
         };
       }
-      logger7.info("leave_group tool called", {
+      logger8.info("leave_group tool called", {
         agentId: deps.agentId,
         groupId: resolved.groupId,
         groupName: resolved.groupName
@@ -25374,13 +26063,13 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("leave_group: server rejected", { status: res.status, errText, groupId: resolved.groupId });
+          logger8.warn("leave_group: server rejected", { status: res.status, errText, groupId: resolved.groupId });
           return {
             content: [{ type: "text", text: `[leave_group] \u670D\u52A1\u7AEF\u62D2\u7EDD\uFF08${res.status}\uFF09\uFF1A${errText || "(no body)"}` }],
             isError: true
           };
         }
-        logger7.info("leave_group: succeeded", {
+        logger8.info("leave_group: succeeded", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           groupName: resolved.groupName
@@ -25395,7 +26084,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           }]
         };
       } catch (e) {
-        logger7.error("leave_group failed", { error: e, groupId: resolved.groupId });
+        logger8.error("leave_group failed", { error: e, groupId: resolved.groupId });
         return {
           content: [{ type: "text", text: `[leave_group] \u9000\u7FA4\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -25451,7 +26140,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         };
       }
       if (cached2.createdBy == null) {
-        logger7.info("remove_from_group: ownerless group rejected", { agentId: deps.agentId, groupId: resolved.groupId });
+        logger8.info("remove_from_group: ownerless group rejected", { agentId: deps.agentId, groupId: resolved.groupId });
         return {
           content: [{ type: "text", text: `[remove_from_group] \u7FA4\u300C${resolved.groupName}\u300D\u6CA1\u6709\u7FA4\u4E3B\uFF08\u539F\u7FA4\u4E3B\u5DF2\u9000\u7FA4\uFF09\uFF0C\u6CA1\u4EBA\u80FD\u8E22\u6210\u5458\u3002` }],
           isError: true
@@ -25460,7 +26149,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
       if (cached2.createdBy !== deps.agentId) {
         const ownerInfo = deps.agentRegistry.getById(cached2.createdBy);
         const ownerLabel = ownerInfo ? `${ownerInfo.name} (${cached2.createdBy})` : cached2.createdBy;
-        logger7.info("remove_from_group: not owner", {
+        logger8.info("remove_from_group: not owner", {
           agentId: deps.agentId,
           groupId: resolved.groupId,
           ownerId: cached2.createdBy
@@ -25498,7 +26187,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           }]
         };
       }
-      logger7.info("remove_from_group tool called", {
+      logger8.info("remove_from_group tool called", {
         agentId: deps.agentId,
         groupId: resolved.groupId,
         groupName: resolved.groupName,
@@ -25528,7 +26217,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         const a = deps.agentRegistry.getById(id);
         return a ? a.name : id;
       });
-      logger7.info("remove_from_group: completed", {
+      logger8.info("remove_from_group: completed", {
         agentId: deps.agentId,
         groupId: resolved.groupId,
         removedCount: removed.length,
@@ -25569,7 +26258,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
       }
       const latestReadableSkillNames = currentReadableSkillNames();
       if (!latestReadableSkillNames.includes(name)) {
-        logger7.warn("read_skill: not readable for agent", {
+        logger8.warn("read_skill: not readable for agent", {
           agentId: deps.agentId,
           isSmith: deps.isSmith,
           name,
@@ -25583,7 +26272,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           isError: true
         };
       }
-      logger7.info("read_skill tool called", { agentId: deps.agentId, scope: currentScopeKey, name });
+      logger8.info("read_skill tool called", { agentId: deps.agentId, scope: currentScopeKey, name });
       const content = deps.skillStore.read(name);
       if (!content) {
         return {
@@ -25594,7 +26283,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
           isError: true
         };
       }
-      logger7.info("read_skill returned", { agentId: deps.agentId, name, bytes: content.length });
+      logger8.info("read_skill returned", { agentId: deps.agentId, name, bytes: content.length });
       return { content: [{ type: "text", text: content }] };
     },
     {}
@@ -25603,7 +26292,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
     "list_available_skills",
     `\u5217\u51FA\u5F53\u524D Agent \u6B64\u523B\u53EF\u76F4\u63A5\u6309\u4EFB\u52A1\u4F7F\u7528\u7684 skill\u3002
 \u666E\u901A Agent \u9009\u62E9 skill \u65F6\u5FC5\u987B\u5148\u8C03\u7528\u5B83\uFF1B\u4F18\u5148\u7528\u5B83\u56DE\u7B54"\u6211\u73B0\u5728\u80FD\u7528\u4EC0\u4E48 skill"\u548C\u4EFB\u52A1\u5F00\u59CB\u524D\u7684 skill \u9009\u62E9\u95EE\u9898\u3002
-\u53EA\u8FD4\u56DE\u8F7B\u91CF\u6458\u8981\u3001\u6743\u9650\u3001\u6765\u6E90\u548C\u8FD0\u884C\u72B6\u6001\uFF1B\u4E0D\u8FD4\u56DE\u5B8C\u6574\u65B9\u6CD5\u5B66\u3002\u53EA\u5305\u542B\u5DF2\u7ECF\u843D\u5230\u5F53\u524D\u673A\u5668 runtime cache \u4E14\u5BF9\u5F53\u524D Agent \u53EF\u89C1\u7684 skill\u3002\u59CB\u7EC8\u53EA\u8FD4\u56DE runtimeAvailability=available\uFF1B\u4E0D\u4F1A\u8FD4\u56DE unavailable\u3001planned \u6216 smith_only\u3002include_unavailable \u662F\u65E7\u5BA2\u6237\u7AEF\u517C\u5BB9\u53C2\u6570\uFF0C\u5DF2\u5FFD\u7565\u3002
+\u53EA\u8FD4\u56DE\u8F7B\u91CF\u6458\u8981\u3001\u6743\u9650\u3001\u6765\u6E90\u548C\u8FD0\u884C\u72B6\u6001\uFF1B\u4E0D\u8FD4\u56DE\u5B8C\u6574\u65B9\u6CD5\u5B66\u3002Skill \u662F AHChat \u7684\u65B9\u6CD5\u5B66/\u6D41\u7A0B\u63D0\u793A\uFF0C\u4E0D\u662F\u53EF\u8C03\u7528 SDK \u5DE5\u5177\uFF1B\u4E0D\u8981\u8C03\u7528\u540D\u4E3A Skill \u7684\u901A\u7528\u5DE5\u5177\uFF0C\u4E5F\u4E0D\u8981\u628A\u8FD9\u91CC\u7684 skill \u540D\u79F0\u6216 ID \u586B\u8FDB tool \u53C2\u6570\u3002\u53EA\u5305\u542B\u5DF2\u7ECF\u843D\u5230\u5F53\u524D\u673A\u5668 runtime cache \u4E14\u5BF9\u5F53\u524D Agent \u53EF\u89C1\u7684 skill\u3002\u59CB\u7EC8\u53EA\u8FD4\u56DE runtimeAvailability=available\uFF1B\u4E0D\u4F1A\u8FD4\u56DE unavailable\u3001planned \u6216 smith_only\u3002include_unavailable \u662F\u65E7\u5BA2\u6237\u7AEF\u517C\u5BB9\u53C2\u6570\uFF0C\u5DF2\u5FFD\u7565\u3002
 \u5982\u679C\u8FD9\u91CC\u6CA1\u6709\u5339\u914D\u9879\uFF0C\u624D\u7528 list_skill_index \u67E5\u5019\u9009\u3002\u82E5 list_skill_index \u627E\u5230\u4E86\u5408\u9002\u4F46\u672A\u5206\u914D\u7684\u5019\u9009\uFF0C\u5FC5\u987B\u8C03\u7528 AskUserQuestion \u5DE5\u5177\u8BE2\u95EE\u7528\u6237\u662F\u5426\u8981\u4E3A\u5F53\u524D Agent \u542F\u7528/\u5206\u914D\uFF1B\u95EE\u9898 metadata \u5C3D\u91CF\u5E26\u4E0A skillId/skillName\uFF1B\u4E0D\u8981\u7528\u666E\u901A\u6587\u672C\u63D0\u95EE\uFF0C\u4E5F\u4E0D\u8981\u76F4\u63A5\u5047\u88C5\u8C03\u7528\u3002`,
     {
       query: external_exports.string().optional().describe("\u53EF\u9009\u3002\u6309 skill \u540D\u79F0\u3001\u6458\u8981\u6216\u5173\u952E\u8BCD\u641C\u7D22\u5F53\u524D\u53EF\u7528 skill\u3002"),
@@ -25623,14 +26312,14 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         entries: runtimeEntries,
         runtime: skillRuntimeContext(deps.officeCliRuntime)
       }), visibleSkillIds), availableSkillIds);
-      logger7.info("list_available_skills tool called", {
+      logger8.info("list_available_skills tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         resultCount: entries.length,
         agentScoped: Boolean(availableSkillIds)
       });
       const text = entries.length > 0 ? entries.map((entry, index) => formatSkillEntry(entry, index)).join("\n") : "\u5F53\u524D\u6CA1\u6709\u627E\u5230\u5339\u914D\u7684\u53EF\u7528 skill\u3002";
-      const scopeRule = deps.isSmith ? "\u89C4\u5219\uFF1ASmith \u662F\u7CFB\u7EDF\u7EC4\u7EC7\u8005\uFF0C\u7ED3\u679C\u5305\u542B\u5F53\u524D\u7528\u6237\u53EF\u89C1\u4E14\u5DF2\u5B89\u88C5/\u5DF2\u542F\u7528\u3001\u5DF2\u843D\u5F53\u524D\u673A\u5668 runtime cache \u4E14\u53EF\u8FD0\u884C\u7684\u8F7B\u91CF skill \u6458\u8981\uFF1B\u4E0D\u662F\u5B8C\u6574\u65B9\u6CD5\u5B66\u3002\u53EA\u6709 summary\u3001taskTypes\u3001outputs \u4E0E\u7528\u6237\u76EE\u6807\u5339\u914D\u65F6\u624D\u4F7F\u7528\u3002" : '\u89C4\u5219\uFF1A\u8FD9\u4E9B\u7ED3\u679C\u53EA\u5305\u542B\u5F53\u524D Agent \u5DF2\u5206\u914D/\u672C\u673A Local \u5DF2\u7ED1\u5B9A\u3001\u5DF2\u843D\u5F53\u524D\u673A\u5668 runtime cache \u4E14\u53EF\u8FD0\u884C\u7684\u8F7B\u91CF skill \u6458\u8981\uFF0C\u4E0D\u662F\u5B8C\u6574\u65B9\u6CD5\u5B66\u3002\u53EA\u6709 summary\u3001taskTypes\u3001outputs \u4E0E\u7528\u6237\u76EE\u6807\u5339\u914D\u65F6\u624D\u4F7F\u7528\uFF1B\u5982\u679C\u6CA1\u6709\u5339\u914D\u9879\uFF0C\u5C31\u76F4\u63A5\u5B8C\u6210\u4EFB\u52A1\uFF0C\u6216\u7528 list_skill_index \u641C\u7D22\u5019\u9009\uFF0C\u5E76\u8C03\u7528 AskUserQuestion \u5DE5\u5177\u8BE2\u95EE\u7528\u6237\u662F\u5426\u8981\u4E3A\u5F53\u524D Agent \u542F\u7528/\u5206\u914D\u8BE5 skill\u3002AskUserQuestion \u9009\u9879\u5FC5\u987B\u5305\u542B"\u542F\u7528/\u5206\u914D\u8FD9\u4E2A skill"\u548C"\u5148\u4E0D\u7528\uFF0C\u76F4\u63A5\u5904\u7406"\uFF0Cmetadata \u5C3D\u91CF\u5E26\u4E0A skillId/skillName\u3002\u7528\u6237\u786E\u8BA4\u524D\u4E0D\u8981\u58F0\u79F0\u5DF2\u4F7F\u7528\u672A\u5206\u914D skill\uFF1B\u786E\u8BA4\u540E\u5FC5\u987B\u91CD\u65B0\u67E5\u8BE2\u672C\u5DE5\u5177\uFF0C\u53EA\u6709\u51FA\u73B0\u5728\u8FD9\u91CC\u624D\u7B97\u53EF\u7528\u3002';
+      const scopeRule = deps.isSmith ? "\u89C4\u5219\uFF1ASmith \u662F\u7CFB\u7EDF\u7EC4\u7EC7\u8005\uFF0C\u7ED3\u679C\u5305\u542B\u5F53\u524D\u7528\u6237\u53EF\u89C1\u4E14\u5DF2\u5B89\u88C5/\u5DF2\u542F\u7528\u3001\u5DF2\u843D\u5F53\u524D\u673A\u5668 runtime cache \u4E14\u53EF\u8FD0\u884C\u7684\u8F7B\u91CF skill \u6458\u8981\uFF1B\u4E0D\u662F\u5B8C\u6574\u65B9\u6CD5\u5B66\uFF0C\u4E5F\u4E0D\u662F\u53EF\u8C03\u7528 SDK \u5DE5\u5177\u3002\u53EA\u6709 summary\u3001taskTypes\u3001outputs \u4E0E\u7528\u6237\u76EE\u6807\u5339\u914D\u65F6\u624D\u4F7F\u7528\uFF1B\u4E0D\u8981\u8C03\u7528\u540D\u4E3A Skill \u7684\u901A\u7528\u5DE5\u5177\u3002" : '\u89C4\u5219\uFF1A\u8FD9\u4E9B\u7ED3\u679C\u53EA\u5305\u542B\u5F53\u524D Agent \u5DF2\u5206\u914D/\u672C\u673A Local \u5DF2\u7ED1\u5B9A\u3001\u5DF2\u843D\u5F53\u524D\u673A\u5668 runtime cache \u4E14\u53EF\u8FD0\u884C\u7684\u8F7B\u91CF skill \u6458\u8981\uFF0C\u4E0D\u662F\u5B8C\u6574\u65B9\u6CD5\u5B66\uFF0C\u4E5F\u4E0D\u662F\u53EF\u8C03\u7528 SDK \u5DE5\u5177\uFF1B\u4E0D\u8981\u8C03\u7528\u540D\u4E3A Skill \u7684\u901A\u7528\u5DE5\u5177\u3002\u53EA\u6709 summary\u3001taskTypes\u3001outputs \u4E0E\u7528\u6237\u76EE\u6807\u5339\u914D\u65F6\u624D\u4F7F\u7528\uFF1B\u5982\u679C\u6CA1\u6709\u5339\u914D\u9879\uFF0C\u5C31\u76F4\u63A5\u5B8C\u6210\u4EFB\u52A1\uFF0C\u6216\u7528 list_skill_index \u641C\u7D22\u5019\u9009\uFF0C\u5E76\u8C03\u7528 AskUserQuestion \u5DE5\u5177\u8BE2\u95EE\u7528\u6237\u662F\u5426\u8981\u4E3A\u5F53\u524D Agent \u542F\u7528/\u5206\u914D\u8BE5 skill\u3002AskUserQuestion \u9009\u9879\u5FC5\u987B\u5305\u542B"\u542F\u7528/\u5206\u914D\u8FD9\u4E2A skill"\u548C"\u5148\u4E0D\u7528\uFF0C\u76F4\u63A5\u5904\u7406"\uFF0Cmetadata \u5C3D\u91CF\u5E26\u4E0A skillId/skillName\u3002\u7528\u6237\u786E\u8BA4\u524D\u4E0D\u8981\u58F0\u79F0\u5DF2\u4F7F\u7528\u672A\u5206\u914D skill\uFF1B\u786E\u8BA4\u540E\u5FC5\u987B\u91CD\u65B0\u67E5\u8BE2\u672C\u5DE5\u5177\uFF0C\u53EA\u6709\u51FA\u73B0\u5728\u8FD9\u91CC\u624D\u7B97\u53EF\u7528\u3002';
       return {
         content: [{
           type: "text",
@@ -25659,7 +26348,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
     },
     async (args) => {
       if (!deps.isSmith && deps.getAvailableSkillIds && !availableSkillsChecked) {
-        logger7.info("list_skill_index blocked before list_available_skills", {
+        logger8.info("list_skill_index blocked before list_available_skills", {
           agentId: deps.agentId,
           scope: currentScopeKey
         });
@@ -25685,7 +26374,7 @@ Smith \u521B\u5EFA\u6216\u5207\u6362 Agent \u8FD0\u884C\u673A\u5668\u65F6\u53EF\
         entries: runtimeEntries,
         runtime: skillRuntimeContext(deps.officeCliRuntime)
       }), visibleSkillIds);
-      logger7.info("list_skill_index tool called", {
+      logger8.info("list_skill_index tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         resultCount: entries.length
@@ -25738,7 +26427,7 @@ local_modelscope_* \u662F\u672C\u673A Local Skill\uFF0C\u4E0D\u5199\u5165 Server
           officeCliMessage: deps.officeCliRuntime.message
         } : void 0
       }).filter((rec) => filterRuntimeVisibleSkillEntries([rec.skill], visibleSkillIds).length > 0);
-      logger7.info("recommend_agent_skills tool called", {
+      logger8.info("recommend_agent_skills tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         resultCount: recommendations.length
@@ -25750,7 +26439,8 @@ local_modelscope_* \u662F\u672C\u673A Local Skill\uFF0C\u4E0D\u5199\u5165 Server
             `[recommend_agent_skills] recommended initial skill set (${recommendations.length})`,
             formatSkillRecommendations(recommendations),
             "",
-            "\u8FB9\u754C\uFF1A\u63A8\u8350 != \u5B89\u88C5 != \u8C03\u7528\u3002\u9ED8\u8BA4/\u56E2\u961F\u5DF2\u542F\u7528 skill \u53EF\u6309\u4EFB\u52A1\u4F7F\u7528\uFF1B\u975E\u9ED8\u8BA4\u542F\u7528\u6216\u5199\u6587\u4EF6\u3001\u8DD1\u547D\u4EE4\u3001\u53D1\u5E03\u3001\u5927\u91CF\u8BFB\u53D6\u79C1\u5BC6\u4E0A\u4E0B\u6587\u7B49\u5177\u4F53\u9AD8\u98CE\u9669\u52A8\u4F5C\u524D\u624D\u9700\u8981\u786E\u8BA4\u3002"
+            "\u8FB9\u754C\uFF1A\u63A8\u8350 != \u5B89\u88C5 != \u8C03\u7528\u3002\u9ED8\u8BA4/\u56E2\u961F\u5DF2\u542F\u7528 skill \u53EF\u6309\u4EFB\u52A1\u4F7F\u7528\uFF1B\u975E\u9ED8\u8BA4\u542F\u7528\u6216\u5199\u6587\u4EF6\u3001\u8DD1\u547D\u4EE4\u3001\u53D1\u5E03\u3001\u5927\u91CF\u8BFB\u53D6\u79C1\u5BC6\u4E0A\u4E0B\u6587\u7B49\u5177\u4F53\u9AD8\u98CE\u9669\u52A8\u4F5C\u524D\u624D\u9700\u8981\u786E\u8BA4\u3002",
+            "local_modelscope_* \u662F\u672C\u673A Local Skill \u589E\u5F3A\u5019\u9009\uFF0C\u53EA\u80FD\u5728\u5F53\u524D\u673A\u5668\u7ED1\u5B9A\u5230 Agent\uFF0C\u4E0D\u5199\u5165 Server\uFF0C\u4E5F\u4E0D\u4F1A\u8DE8\u7528\u6237\u6216\u8DE8\u673A\u5668\u751F\u6548\u3002"
           ].join("\n")
         }]
       };
@@ -25776,7 +26466,7 @@ limit \u9ED8\u8BA4 500\uFF0C\u786C\u4E0A\u9650 2000\uFF1B\u652F\u6301 offset \u5
     },
     async (args) => {
       if (!deps.isSmith) {
-        logger7.warn("fetch_logs: permission denied (non-Smith caller)", { agentId: deps.agentId });
+        logger8.warn("fetch_logs: permission denied (non-Smith caller)", { agentId: deps.agentId });
         return {
           content: [{ type: "text", text: "[fetch_logs] \u6743\u9650\u62D2\u7EDD\uFF1A\u53EA\u6709 Smith \u80FD\u8C03\u7528\u3002" }],
           isError: true
@@ -25789,7 +26479,7 @@ limit \u9ED8\u8BA4 500\uFF0C\u786C\u4E0A\u9650 2000\uFF1B\u652F\u6301 offset \u5
           isError: true
         };
       }
-      logger7.info("fetch_logs tool called", {
+      logger8.info("fetch_logs tool called", {
         agentId: deps.agentId,
         source,
         startIso: args.start_iso,
@@ -25822,7 +26512,7 @@ limit \u9ED8\u8BA4 500\uFF0C\u786C\u4E0A\u9650 2000\uFF1B\u652F\u6301 offset \u5
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("fetch_logs: server rejected", { status: res.status, errText });
+          logger8.warn("fetch_logs: server rejected", { status: res.status, errText });
           return {
             content: [{
               type: "text",
@@ -25832,7 +26522,7 @@ limit \u9ED8\u8BA4 500\uFF0C\u786C\u4E0A\u9650 2000\uFF1B\u652F\u6301 offset \u5
           };
         }
         const json2 = await res.json();
-        logger7.info("fetch_logs returned", {
+        logger8.info("fetch_logs returned", {
           source,
           count: json2.entries.length,
           truncated: json2.truncated,
@@ -25858,7 +26548,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         const text = [header, "", ...lines].join("\n");
         return { content: [{ type: "text", text }] };
       } catch (e) {
-        logger7.error("fetch_logs failed", { error: e });
+        logger8.error("fetch_logs failed", { error: e });
         return {
           content: [{ type: "text", text: `[fetch_logs] \u8C03\u7528\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -25872,7 +26562,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
     `\u521B\u9020\u4E00\u4E2A\u65B0\u7684 Agent\u3002\u53EA\u6709\u4F60\uFF08Smith\uFF09\u80FD\u4F7F\u7528\u6B64\u5DE5\u5177\u3002
 \u65B0 Agent \u4F1A\u7ACB\u5373\u51FA\u73B0\u5728\u7CFB\u7EDF\u901A\u8BAF\u5F55\u4E2D\uFF0C\u62E5\u6709\u72EC\u7ACB\u7684 SDK runtime \u548C\u5DE5\u4F5C\u76EE\u5F55\u3002
 \u521B\u5EFA\u540E\u4F60\u53EF\u4EE5\u901A\u8FC7 create_group + add_to_group \u628A\u5B83\u62C9\u8FDB\u7FA4\u3002
-\u521B\u5EFA\u65F6\u53EF\u4EE5\u9009\u62E9\u521D\u59CB\u8FD0\u884C\u673A\u5668\uFF1A\u5148\u7528 list_contacts \u67E5\u770B"\u53EF\u7528\u673A\u5668"\uFF0C\u518D\u4F20 machine_bridge_key\u3002\u540E\u7EED\u53EF\u7528 update_agent_profile \u5207\u6362\uFF1B\u4E0D\u4F20\u5219\u4F7F\u7528\u5F53\u524D Bridge\u3002
+\u521B\u5EFA\u65F6\u9ED8\u8BA4\u4F7F\u7528\u5F53\u524D Bridge\uFF1A\u666E\u901A\u521B\u5EFA\u4E0D\u8981\u4F20 machine_bridge_key\u3002\u53EA\u6709\u7528\u6237\u660E\u786E\u6307\u5B9A\u67D0\u53F0\u8FD0\u884C\u673A\u5668\u65F6\uFF0C\u624D\u5148\u521B\u5EFA Agent\uFF0C\u518D\u7528 update_agent_profile \u5207\u6362\u3002
 
 **\u80FD\u529B\u6863\u4F4D\u9009\u62E9\u6307\u5357\uFF1A**
 - **smart\uFF08\u65D7\u8230\uFF09**\uFF1A\u7F16\u6392\u8005\u3001\u590D\u6742\u63A8\u7406\u3001\u6700\u7EC8\u7EFC\u5408\u3001\u9AD8\u96BE\u5EA6\u89D2\u8272\u3002\u4F7F\u7528\u6700\u5F3A\u6A21\u578B\u3002
@@ -25906,15 +26596,15 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         "\u53EF\u9009\u3002\u8BE5 Agent \u7684\u5DE5\u4F5C\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84\u3002\u4E0D\u4F20\u5219\u7531\u7CFB\u7EDF\u81EA\u52A8\u5206\u914D\u3002"
       ),
       machine_bridge_key: external_exports.string().optional().describe(
-        '\u53EF\u9009\u3002\u8FD0\u884C\u673A\u5668 bridgeKey\uFF0C\u6765\u81EA list_contacts \u7684"\u53EF\u7528\u673A\u5668"\u3002\u4E0D\u4F20\u5219\u4F7F\u7528\u5F53\u524D Bridge\uFF1B\u540E\u7EED\u53EF\u7528 update_agent_profile \u5207\u6362\u3002'
+        "\u53EF\u9009\u3002\u53EA\u5141\u8BB8\u4F20\u5F53\u524D Bridge \u7684 bridgeKey\uFF1B\u666E\u901A\u521B\u5EFA\u8BF7\u7701\u7565\uFF0C\u7CFB\u7EDF\u4F1A\u4F7F\u7528\u5F53\u524D\u673A\u5668\u3002\u8DE8\u673A\u5668\u8FD0\u884C\u8BF7\u521B\u5EFA\u540E\u7528 update_agent_profile \u5207\u6362\u3002"
       ),
       skill_ids: external_exports.array(external_exports.string()).optional().describe(
-        "\u53EF\u9009\u3002\u521B\u5EFA\u540E\u7ACB\u5373\u5206\u914D\u7ED9\u65B0 Agent \u7684\u521D\u59CB skill \u5305\uFF08skill id \u5217\u8868\uFF09\u3002\u9ED8\u8BA4/\u56E2\u961F\u5DF2\u542F\u7528\u63A8\u8350\u53EF\u6309\u89D2\u8272\u76F4\u63A5\u4F20\u5165\uFF1B\u975E\u9ED8\u8BA4/\u672A\u542F\u7528 skill \u9700\u8981\u7528\u6237\u660E\u786E\u8981\u6C42\u6216\u786E\u8BA4\u540E\u518D\u4F20\u3002local_modelscope_* \u5C5E\u4E8E\u672C\u673A Local Skill\uFF0C\u4E0D\u5199\u5165 Server \u5206\u914D\uFF1B\u53EA\u6709\u65B0 Agent \u8FD0\u884C\u5728\u5F53\u524D\u673A\u5668\u65F6\u624D\u4F1A\u5199\u5165\u5F53\u524D\u673A\u5668 allowedAgentIds\u3002\u4E0D\u8981\u8BA9\u7528\u6237\u66FF\u7CFB\u7EDF\u5224\u65AD\u9ED8\u8BA4 skill \u662F\u5426\u53EF\u7528\u3002"
+        "\u53EF\u9009\u3002\u521B\u5EFA\u540E\u7ACB\u5373\u5206\u914D\u7ED9\u65B0 Agent \u7684\u521D\u59CB skill \u5305\uFF08skill id \u5217\u8868\uFF09\u3002\u9ED8\u8BA4/\u56E2\u961F\u5DF2\u542F\u7528\u63A8\u8350\u53EF\u6309\u89D2\u8272\u76F4\u63A5\u4F20\u5165\uFF1B\u975E\u9ED8\u8BA4/\u672A\u542F\u7528 skill \u9700\u8981\u7528\u6237\u660E\u786E\u8981\u6C42\u6216\u786E\u8BA4\u540E\u518D\u4F20\u3002\u9700\u8981\u957F\u8017\u65F6\u5916\u90E8\u4EFB\u52A1\u7684\u5B98\u65B9\u6D41\u7A0B skill \u4F1A\u901A\u8FC7\u53EF\u6269\u5C55\u89C4\u5219\u505A\u4FDD\u5B88\u8865\u9F50\uFF1B\u672C\u673A Local Skill \u53EA\u4F5C\u4E3A\u5F53\u524D\u673A\u5668\u7684\u4EFB\u52A1\u589E\u5F3A\u5019\u9009\u3002local_modelscope_* \u5C5E\u4E8E\u672C\u673A Local Skill\uFF0C\u4E0D\u5199\u5165 Server \u5206\u914D\uFF1B\u53EA\u6709\u65B0 Agent \u8FD0\u884C\u5728\u5F53\u524D\u673A\u5668\u65F6\u624D\u4F1A\u5199\u5165\u5F53\u524D\u673A\u5668 allowedAgentIds\uFF0C\u4E0D\u80FD\u8DE8\u7528\u6237\u6216\u8DE8\u673A\u5668\u751F\u6548\u3002\u4E0D\u8981\u8BA9\u7528\u6237\u66FF\u7CFB\u7EDF\u5224\u65AD\u9ED8\u8BA4 skill \u662F\u5426\u53EF\u7528\u3002"
       )
     },
     async (args) => {
       if (!deps.isSmith) {
-        logger7.warn("create_agent: permission denied (non-Smith caller)", {
+        logger8.warn("create_agent: permission denied (non-Smith caller)", {
           agentId: deps.agentId,
           scope: currentScopeKey
         });
@@ -25939,10 +26629,24 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
       const avatar = args.avatar && String(args.avatar).trim() || "";
       const initialInstruction = args.initial_instruction && String(args.initial_instruction).trim() || "";
       const workingDirectory = args.working_directory && String(args.working_directory).trim() || "";
-      const machineBridgeKey = args.machine_bridge_key && String(args.machine_bridge_key).trim() || "";
+      const requestedMachineBridgeKey = args.machine_bridge_key && String(args.machine_bridge_key).trim() || "";
+      const machineBridgeKey = requestedMachineBridgeKey === "auto" ? "" : requestedMachineBridgeKey;
+      const remoteMachineError = rejectRemoteCreateMachineBridgeKey(machineBridgeKey, deps);
+      if (remoteMachineError) {
+        logger8.warn("create_agent: rejected remote machine_bridge_key on create", {
+          agentId: deps.agentId,
+          scope: currentScopeKey,
+          requestedMachineBridgeKey: machineBridgeKey,
+          currentBridgeKey: deps.currentBridgeKey ?? null
+        });
+        return {
+          content: [{ type: "text", text: remoteMachineError }],
+          isError: true
+        };
+      }
       const machineValidation = await validateOnlineMachineBridgeKey("create_agent", machineBridgeKey, deps);
       if (!machineValidation.ok) {
-        logger7.warn("create_agent: rejected offline or unknown machine_bridge_key", {
+        logger8.warn("create_agent: rejected offline or unknown machine_bridge_key", {
           agentId: deps.agentId,
           scope: currentScopeKey,
           machineBridgeKey
@@ -25971,15 +26675,15 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
                 capabilityTier: tier,
                 subscriptionId: tierConfig.subscriptionId
               });
-              logger7.info("Tier resolved", { tier, subscriptionId: tierConfig.subscriptionId, model: tierConfig.modelName });
+              logger8.info("Tier resolved", { tier, subscriptionId: tierConfig.subscriptionId, model: tierConfig.modelName });
             } else {
-              logger7.warn("Tier not found, using default", { tier, availableTiers: tiers.map((t) => t.tier) });
+              logger8.warn("Tier not found, using default", { tier, availableTiers: tiers.map((t) => t.tier) });
             }
           } else {
-            logger7.warn("Failed to fetch tiers", { status: tierRes.status });
+            logger8.warn("Failed to fetch tiers", { status: tierRes.status });
           }
         } catch (e) {
-          logger7.error("Tier resolution failed", { error: e });
+          logger8.error("Tier resolution failed", { error: e });
         }
       }
       const body = { name, role, systemPrompt, avatar };
@@ -25992,7 +26696,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
       if (machineBridgeKey) {
         body.machineBridgeKey = machineBridgeKey;
       }
-      logger7.info("create_agent tool called", {
+      logger8.info("create_agent tool called", {
         agentId: deps.agentId,
         requestedBy: deps.agentId,
         scope: currentScopeKey,
@@ -26013,7 +26717,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("create_agent: server rejected", { status: res.status, errText, name });
+          logger8.warn("create_agent: server rejected", { status: res.status, errText, name });
           return {
             content: [{
               type: "text",
@@ -26024,7 +26728,44 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         }
         const agent = await res.json();
         const resolvedMachineBridgeKey = agent.machineBridgeKey ?? machineBridgeKey;
+        const skillIntent = {
+          name,
+          role,
+          systemPrompt,
+          initialInstruction,
+          workingDirectory
+        };
         const requestedSkillIds = Array.isArray(args.skill_ids) ? args.skill_ids.map((id) => typeof id === "string" ? id.trim() : "").filter((id) => id.length > 0) : [];
+        const autoAssignedOfficialSkillIds = autoAssignOfficialSkillIds(skillIntent);
+        for (const skillId of autoAssignedOfficialSkillIds) {
+          if (requestedSkillIds.includes(skillId)) continue;
+          requestedSkillIds.push(skillId);
+          logger8.info("create_agent: auto-added official workflow skill", {
+            requestedBy: deps.agentId,
+            newAgentId: agent.id,
+            skillId
+          });
+        }
+        const explicitlyRequestedLocalSkill = requestedSkillIds.some(isLocalSkillId);
+        const localEnhancerTargetBridgeKey = resolvedMachineBridgeKey ?? machineBridgeKey;
+        if (autoAssignedOfficialSkillIds.length > 0 && !explicitlyRequestedLocalSkill && deps.setLocalSkillAgentVisibility && isCurrentMachineLocalTarget(localEnhancerTargetBridgeKey, deps.currentBridgeKey)) {
+          const localEnhancerSkillIds = selectLocalSkillEnhancersForCreateAgent(
+            skillIntent,
+            deps.skillStore,
+            new Set(requestedSkillIds)
+          );
+          for (const skillId of localEnhancerSkillIds) {
+            requestedSkillIds.push(skillId);
+          }
+          if (localEnhancerSkillIds.length > 0) {
+            logger8.info("create_agent: auto-added local skill enhancers", {
+              requestedBy: deps.agentId,
+              newAgentId: agent.id,
+              localEnhancerSkillIds,
+              targetBridgeKey: localEnhancerTargetBridgeKey || "(current-bridge)"
+            });
+          }
+        }
         const skillIds = Array.from(new Set(requestedSkillIds));
         const localSkillIds = skillIds.filter(isLocalSkillId);
         const serverSkillIds = skillIds.filter((id) => !isLocalSkillId(id));
@@ -26043,7 +26784,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
               const assignBody = await assignRes.json();
               const assignedCount = assignBody.assigned?.length ?? 0;
               const skipped = assignBody.skipped ?? [];
-              logger7.info("create_agent: initial skills assigned", {
+              logger8.info("create_agent: initial skills assigned", {
                 requestedBy: deps.agentId,
                 newAgentId: agent.id,
                 assignedCount,
@@ -26052,7 +26793,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
               skillAssignNote = skipped.length > 0 ? `\u5DF2\u5206\u914D ${assignedCount} \u4E2A\u521D\u59CB skill\uFF08${skipped.length} \u4E2A\u65E0\u6548\u5DF2\u8DF3\u8FC7\uFF09\u3002` : `\u5DF2\u5206\u914D ${assignedCount} \u4E2A\u521D\u59CB skill\u3002`;
             } else {
               const errText = await assignRes.text().catch(() => "");
-              logger7.warn("create_agent: initial skill assignment rejected", {
+              logger8.warn("create_agent: initial skill assignment rejected", {
                 newAgentId: agent.id,
                 status: assignRes.status,
                 errText
@@ -26060,18 +26801,18 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
               skillAssignNote = `\u521D\u59CB skill \u5206\u914D\u5931\u8D25\uFF08${assignRes.status}\uFF09\uFF0C\u53EF\u7A0D\u540E\u7528 assign \u6D41\u7A0B\u8865\u914D\u3002`;
             }
           } catch (e) {
-            logger7.error("create_agent: initial skill assignment failed", { error: e, newAgentId: agent.id });
+            logger8.error("create_agent: initial skill assignment failed", { error: e, newAgentId: agent.id });
             skillAssignNote = "\u521D\u59CB skill \u5206\u914D\u5931\u8D25\uFF0C\u53EF\u7A0D\u540E\u8865\u914D\u3002";
           }
         }
         if (localSkillIds.length > 0) {
           const targetBridgeKey = resolvedMachineBridgeKey ?? machineBridgeKey;
-          const localSkillTargetIsCurrentMachine = !targetBridgeKey || deps.currentBridgeKey != null && targetBridgeKey === deps.currentBridgeKey;
+          const localSkillTargetIsCurrentMachine = isCurrentMachineLocalTarget(targetBridgeKey, deps.currentBridgeKey);
           let localAssignedCount = 0;
           const localSkipped = [];
           if (!localSkillTargetIsCurrentMachine) {
             localSkipped.push(...localSkillIds);
-            logger7.warn("create_agent: local skills skipped for remote machine target", {
+            logger8.warn("create_agent: local skills skipped for remote machine target", {
               requestedBy: deps.agentId,
               newAgentId: agent.id,
               localSkillIds,
@@ -26080,7 +26821,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
             });
           } else if (!deps.setLocalSkillAgentVisibility) {
             localSkipped.push(...localSkillIds);
-            logger7.warn("create_agent: local skill binder unavailable", {
+            logger8.warn("create_agent: local skill binder unavailable", {
               requestedBy: deps.agentId,
               newAgentId: agent.id,
               localSkillIds
@@ -26096,7 +26837,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
                 }
               } catch (e) {
                 localSkipped.push(skillId);
-                logger7.error("create_agent: local skill assignment failed", {
+                logger8.error("create_agent: local skill assignment failed", {
                   error: e,
                   requestedBy: deps.agentId,
                   newAgentId: agent.id,
@@ -26108,7 +26849,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
               await deps.onLocalSkillVisibilityChanged?.([agent.id]);
             }
           }
-          logger7.info("create_agent: local skill assignment resolved", {
+          logger8.info("create_agent: local skill assignment resolved", {
             requestedBy: deps.agentId,
             newAgentId: agent.id,
             localSkillIds,
@@ -26118,7 +26859,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           const localSkillNote = localAssignedCount > 0 ? `\u672C\u673A Local Skill \u5DF2\u7ED1\u5B9A ${localAssignedCount} \u4E2A\u5230\u5F53\u524D\u673A\u5668\uFF1B${localSkipped.length > 0 ? `${localSkipped.length} \u4E2A\u672A\u627E\u5230\u6216\u4E0D\u53EF\u7ED1\u5B9A\u3002` : "\u4E0D\u4F1A\u5199\u5165 Server\u3002"}` : `\u672C\u673A Local Skill ${localSkillIds.length} \u4E2A\u672A\u5199\u5165 Server${localSkipped.length > 0 ? "\uFF0C\u4E14\u672A\u7ED1\u5B9A\u5230\u5F53\u524D\u673A\u5668" : ""}\uFF1B\u5982\u679C\u65B0 Agent \u5728\u53E6\u4E00\u53F0\u673A\u5668\u8FD0\u884C\uFF0C\u9700\u8981\u5728\u90A3\u53F0\u673A\u5668\u5B89\u88C5\u5E76\u7ED1\u5B9A\u3002`;
           skillAssignNote = skillAssignNote ? `${skillAssignNote}${localSkillNote}` : localSkillNote;
         }
-        logger7.info("create_agent: created", {
+        logger8.info("create_agent: created", {
           requestedBy: deps.agentId,
           scope: currentScopeKey,
           agentId: agent.id,
@@ -26137,7 +26878,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         });
         if (initialInstruction && deps.onAgentCreatedInitInstruction) {
           try {
-            logger7.info("create_agent: firing initial instruction dispatch", {
+            logger8.info("create_agent: firing initial instruction dispatch", {
               requestedBy: deps.agentId,
               newAgentId: agent.id,
               newAgentName: agent.name,
@@ -26150,7 +26891,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
               requestedBy: deps.agentId
             });
           } catch (e) {
-            logger7.error("create_agent: onAgentCreatedInitInstruction sync threw", {
+            logger8.error("create_agent: onAgentCreatedInitInstruction sync threw", {
               error: e,
               newAgentId: agent.id
             });
@@ -26163,7 +26904,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           content: [{ type: "text", text: reply }]
         };
       } catch (e) {
-        logger7.error("create_agent failed", { error: e, name });
+        logger8.error("create_agent failed", { error: e, name });
         return {
           content: [{ type: "text", text: `[create_agent] \u521B\u5EFA\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26235,7 +26976,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           deps
         );
         if (!machineValidation.ok) {
-          logger7.warn("update_agent_profile: rejected offline or unknown machine_bridge_key", {
+          logger8.warn("update_agent_profile: rejected offline or unknown machine_bridge_key", {
             agentId: deps.agentId,
             targetAgentId: agentId,
             machineBridgeKey: requestedMachineBridgeKey
@@ -26266,11 +27007,11 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
                 subscriptionId: tierConfig.subscriptionId,
                 model: tierConfig.modelName
               });
-              logger7.info("update_agent: tier resolved", { agentId, tier, subscriptionId: tierConfig.subscriptionId });
+              logger8.info("update_agent: tier resolved", { agentId, tier, subscriptionId: tierConfig.subscriptionId });
             }
           }
         } catch (e) {
-          logger7.error("update_agent: tier resolution failed", { error: e });
+          logger8.error("update_agent: tier resolution failed", { error: e });
         }
       }
       const patchBody = {};
@@ -26289,7 +27030,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           isError: true
         };
       }
-      logger7.info("update_agent_profile tool called", {
+      logger8.info("update_agent_profile tool called", {
         agentId: deps.agentId,
         targetAgentId: agentId,
         targetName: existing.name,
@@ -26309,7 +27050,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           };
         }
         const updated = await res.json();
-        logger7.info("update_agent_profile: succeeded", {
+        logger8.info("update_agent_profile: succeeded", {
           agentId: deps.agentId,
           targetAgentId: agentId,
           newName: updated.name
@@ -26321,7 +27062,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           }]
         };
       } catch (e) {
-        logger7.error("update_agent_profile failed", { error: e, agentId });
+        logger8.error("update_agent_profile failed", { error: e, agentId });
         return {
           content: [{ type: "text", text: `[update_agent_profile] \u66F4\u65B0\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26358,7 +27099,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         };
       }
       const base = deps.serverApiUrl.replace(/\/$/, "");
-      logger7.info("archive_conversation tool called", {
+      logger8.info("archive_conversation tool called", {
         agentId: deps.agentId,
         targetAgentId: agentId,
         conversationId
@@ -26379,7 +27120,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
             isError: true
           };
         }
-        logger7.info("archive_conversation: succeeded", {
+        logger8.info("archive_conversation: succeeded", {
           agentId: deps.agentId,
           conversationId
         });
@@ -26390,7 +27131,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           }]
         };
       } catch (e) {
-        logger7.error("archive_conversation failed", { error: e, conversationId });
+        logger8.error("archive_conversation failed", { error: e, conversationId });
         return {
           content: [{ type: "text", text: `[archive_conversation] \u5F52\u6863\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26434,7 +27175,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           isError: true
         };
       }
-      logger7.info("transfer_group_owner tool called", {
+      logger8.info("transfer_group_owner tool called", {
         agentId: deps.agentId,
         fromOwnerId: deps.agentId,
         scope: currentScopeKey,
@@ -26453,7 +27194,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("transfer_group_owner: server rejected", {
+          logger8.warn("transfer_group_owner: server rejected", {
             status: res.status,
             errText,
             groupId: resolved.groupId
@@ -26466,7 +27207,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
             isError: true
           };
         }
-        logger7.info("transfer_group_owner: succeeded", {
+        logger8.info("transfer_group_owner: succeeded", {
           agentId: deps.agentId,
           fromOwnerId: deps.agentId,
           scope: currentScopeKey,
@@ -26480,7 +27221,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           }]
         };
       } catch (e) {
-        logger7.error("transfer_group_owner failed", { error: e, groupId: resolved.groupId });
+        logger8.error("transfer_group_owner failed", { error: e, groupId: resolved.groupId });
         return {
           content: [{
             type: "text",
@@ -26549,7 +27290,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
             }
           }
         }
-        logger7.info("list_friends called", {
+        logger8.info("list_friends called", {
           agentId: deps.agentId,
           friendCount: friends.length
         });
@@ -26557,7 +27298,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           content: [{ type: "text", text: parts.join("\n") }]
         };
       } catch (e) {
-        logger7.error("list_friends failed", { error: e });
+        logger8.error("list_friends failed", { error: e });
         return {
           content: [{ type: "text", text: `[list_friends] \u64CD\u4F5C\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26601,7 +27342,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
             isError: true
           };
         }
-        logger7.info("accept_friend called", {
+        logger8.info("accept_friend called", {
           agentId: deps.agentId,
           requestId,
           action
@@ -26617,7 +27358,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           content: [{ type: "text", text: `[accept_friend] \u5DF2\u62D2\u7EDD\u8BE5\u597D\u53CB\u7533\u8BF7\u3002` }]
         };
       } catch (e) {
-        logger7.error("accept_friend failed", { error: e });
+        logger8.error("accept_friend failed", { error: e });
         return {
           content: [{ type: "text", text: `[accept_friend] \u64CD\u4F5C\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26695,7 +27436,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
             isError: true
           };
         }
-        logger7.info("add_friend: request sent", {
+        logger8.info("add_friend: request sent", {
           agentId: deps.agentId,
           targetUserId: lookup.user.id,
           targetName: lookup.user.name,
@@ -26708,7 +27449,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           }]
         };
       } catch (e) {
-        logger7.error("add_friend failed", { error: e });
+        logger8.error("add_friend failed", { error: e });
         return {
           content: [{ type: "text", text: `[add_friend] \u64CD\u4F5C\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26728,7 +27469,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
     }
     const category = normalizeFeedCategory(args.category);
     const groupId = (args.group_id ?? "").trim() || (deps.scope.kind === "group" ? deps.scope.groupId : void 0);
-    logger7.info(`${toolName} tool called`, {
+    logger8.info(`${toolName} tool called`, {
       agentId: deps.agentId,
       scope: currentScopeKey,
       title,
@@ -26751,7 +27492,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
       });
       if (!res.ok) {
         const errText = await res.text().catch(() => "");
-        logger7.warn(`${toolName}: server rejected`, { status: res.status, errText, title });
+        logger8.warn(`${toolName}: server rejected`, { status: res.status, errText, title });
         return {
           content: [{
             type: "text",
@@ -26761,7 +27502,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         };
       }
       const payload = await res.json();
-      logger7.info(`${toolName}: created`, {
+      logger8.info(`${toolName}: created`, {
         agentId: deps.agentId,
         scope: currentScopeKey,
         postId: payload.post?.id,
@@ -26774,7 +27515,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         }]
       };
     } catch (e) {
-      logger7.error(`${toolName} failed`, { error: e, title });
+      logger8.error(`${toolName} failed`, { error: e, title });
       return {
         content: [{ type: "text", text: `[${toolName}] \u53D1\u5E03\u5931\u8D25\uFF1A${e.message}` }],
         isError: true
@@ -26829,7 +27570,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
       const category = args.category ? normalizeFeedCategory(args.category) : void 0;
       const rawGroupId = (args.group_id ?? "").trim();
       const groupId = rawGroupId === "all" ? void 0 : rawGroupId || (deps.scope.kind === "group" ? deps.scope.groupId : void 0);
-      logger7.info("read_moments tool called", {
+      logger8.info("read_moments tool called", {
         agentId: deps.agentId,
         scope: currentScopeKey,
         limit,
@@ -26846,7 +27587,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         });
         if (!res.ok) {
           const errText = await res.text().catch(() => "");
-          logger7.warn("read_moments: server rejected", { status: res.status, errText });
+          logger8.warn("read_moments: server rejected", { status: res.status, errText });
           return {
             content: [{
               type: "text",
@@ -26857,7 +27598,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
         }
         const payload = await res.json();
         const posts = Array.isArray(payload.posts) ? payload.posts : [];
-        logger7.info("read_moments returned", {
+        logger8.info("read_moments returned", {
           agentId: deps.agentId,
           scope: currentScopeKey,
           count: posts.length,
@@ -26881,7 +27622,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
           }]
         };
       } catch (e) {
-        logger7.error("read_moments failed", { error: e });
+        logger8.error("read_moments failed", { error: e });
         return {
           content: [{ type: "text", text: `[read_moments] \u8BFB\u53D6\u5931\u8D25\uFF1A${e.message}` }],
           isError: true
@@ -26949,7 +27690,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
   if (postToMomentsTool) toolNames.push("post_to_moments");
   if (postToForumTool) toolNames.push("post_to_forum");
   if (readMomentsTool) toolNames.push("read_moments");
-  logger7.info("Neural MCP server created", {
+  logger8.info("Neural MCP server created", {
     agentId: deps.agentId,
     isSmith: deps.isSmith,
     scope: currentScopeKey,
@@ -26959,7 +27700,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
 }
 
 // src/groupDispatchMemory.ts
-var logger8 = createModuleLogger("agent.dispatchMemory");
+var logger9 = createModuleLogger("agent.dispatchMemory");
 var GroupDispatchMemoryStore = class {
   memo = /* @__PURE__ */ new Map();
   getOrCreate(agentId, scope) {
@@ -26980,7 +27721,7 @@ var GroupDispatchMemoryStore = class {
   reset(agentId, scope, reason = "compact_completed") {
     const key = runtimeKey(agentId, scope);
     if (this.memo.delete(key)) {
-      logger8.info("Dispatch memory reset", {
+      logger9.info("Dispatch memory reset", {
         agentId,
         scope: scope.kind === "single" ? "single" : scope.groupId,
         reason
@@ -27183,115 +27924,28 @@ function buildGroupInboxPrompt(entries, opts = {}) {
   return lines.join("\n");
 }
 
-// src/officeRuntime.ts
-import fs4 from "fs";
-import os5 from "os";
-import path9 from "path";
-var OFFICECLI_EXECUTABLE_ENV = "AHCHAT_OFFICECLI_EXECUTABLE";
-var OFFICECLI_BIN_DIR_ENV = "AHCHAT_OFFICECLI_BIN_DIR";
-var logger9 = createModuleLogger("bridge.officeRuntime");
-function sanitizedOfficeCliProbeError(error51) {
-  const rawCode = error51 && typeof error51 === "object" && "code" in error51 ? error51.code : void 0;
-  const code = typeof rawCode === "string" ? rawCode : void 0;
-  const sanitized = new Error(`OfficeCLI executable probe failed${code ? ` (${code})` : ""}`);
-  if (error51 instanceof Error) sanitized.name = error51.name;
-  return sanitized;
-}
-function defaultRuntimeRoot() {
-  if (process.platform === "win32") {
-    return path9.join(process.env.LOCALAPPDATA || path9.join(os5.homedir(), "AppData", "Local"), "AHChat", "runtime", "officecli");
-  }
-  if (process.platform === "darwin") {
-    return path9.join(os5.homedir(), "Library", "Caches", "AHChat", "runtime", "officecli");
-  }
-  return path9.join(process.env.XDG_CACHE_HOME || path9.join(os5.homedir(), ".cache"), "ahchat", "runtime", "officecli");
-}
-function getManagedOfficeCliBinDir(env2 = process.env) {
-  return env2[OFFICECLI_BIN_DIR_ENV] || path9.join(defaultRuntimeRoot(), "bin");
-}
-function getOfficeCliExecutableName() {
-  return process.platform === "win32" ? "officecli.exe" : "officecli";
-}
-function getManagedOfficeCliExecutablePath(env2 = process.env) {
-  return path9.join(getManagedOfficeCliBinDir(env2), getOfficeCliExecutableName());
-}
-function isExecutable(filePath, options = {}) {
-  const logFailure = options.logFailure !== false;
-  try {
-    if (process.platform === "win32") return fs4.existsSync(filePath);
-    fs4.accessSync(filePath, fs4.constants.X_OK);
-    return true;
-  } catch (error51) {
-    if (logFailure) {
-      logger9.error("OfficeCLI executable probe failed", {
-        error: sanitizedOfficeCliProbeError(error51),
-        fileName: path9.basename(filePath)
-      });
-    }
-    return false;
-  }
-}
-function withPrependedPath(env2, entries) {
-  const pathEntries = entries.filter((entry) => entry && fs4.existsSync(entry));
-  if (pathEntries.length === 0) return env2;
-  const current = env2.PATH ?? "";
-  return {
-    ...env2,
-    PATH: [...pathEntries, current].filter(Boolean).join(path9.delimiter)
-  };
-}
-function statusForPath(filePath, source, env2, options = {}) {
-  if (!isExecutable(filePath, { logFailure: options.logProbeFailure })) {
-    return {
-      ok: false,
-      path: filePath,
-      source,
-      message: `officecli not executable at ${filePath}`
-    };
-  }
-  const runtimeEnv = withPrependedPath(env2, [path9.dirname(filePath)]);
-  const version2 = readCommandVersion(filePath, ["--version"], runtimeEnv);
-  if (!version2) {
-    return {
-      ok: false,
-      path: filePath,
-      source,
-      message: `officecli found at ${filePath} but --version failed`
-    };
-  }
-  return { ok: true, path: filePath, source, version: version2 };
-}
-function detectOfficeCliRuntime(env2 = process.env) {
-  const explicitPath = env2[OFFICECLI_EXECUTABLE_ENV]?.trim();
-  if (explicitPath) return statusForPath(explicitPath, "env", env2);
-  const managedPath = getManagedOfficeCliExecutablePath(env2);
-  const managed = statusForPath(managedPath, "managed", env2, { logProbeFailure: false });
-  if (managed.ok) return managed;
-  const resolved = resolveCommand(["officecli"], withPrependedPath(env2, [path9.dirname(managedPath)]));
-  if (!resolved) {
-    return {
-      ok: false,
-      source: "managed",
-      path: managedPath,
-      message: `officecli not found. Run pnpm setup:office-runtime or set ${OFFICECLI_EXECUTABLE_ENV}.`
-    };
-  }
-  return statusForPath(resolved.path, resolved.path === managedPath ? "managed" : "path", env2);
-}
-function withOfficeCliRuntimeEnv(status, env2 = process.env) {
-  if (!status.ok || !status.path) return env2;
-  return {
-    ...withPrependedPath(env2, [path9.dirname(status.path)]),
-    [OFFICECLI_EXECUTABLE_ENV]: status.path
-  };
-}
-
 // src/sdkEventMapper.ts
 var logger10 = createModuleLogger("sdk.mapper");
 var HIGH_WATERMARK_INPUT_TOKENS = 12e4;
 var WARN_THRESHOLD_INPUT_TOKENS = 1e5;
 var LIVE_INPUT_PREVIEW_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit"]);
 var CONTEXT_OVERFLOW_LOCK_MS = 6e4;
+function parseJsonRecord(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isSuccessfulOfficialMediaOutput(toolName, output) {
+  if (!isOfficialMediaGenerationToolName(toolName)) return false;
+  const parsed = parseJsonRecord(output);
+  if (!parsed) return false;
+  const state = typeof parsed.state === "string" ? parsed.state.toLowerCase() : typeof parsed.status === "string" ? parsed.status.toLowerCase() : "";
+  if (!["succeeded", "success", "completed", "done"].includes(state)) return false;
+  return Array.isArray(parsed.images) && parsed.images.length > 0 || typeof parsed.video_url === "string" || typeof parsed.videoUrl === "string";
+}
 function isContextOverflowText(text) {
   const trimmed = text.trim();
   return /^prompt is too long\b/i.test(trimmed) || /context length .* exceed/i.test(trimmed);
@@ -27302,6 +27956,10 @@ function isAuthFailureText(text, sdkError) {
 function isProviderApiErrorText(text) {
   return /^API Error:\s*\d+/i.test(text.trim());
 }
+function isNoReplyText(text) {
+  const normalized = text.trim().replace(/^`+|`+$/g, "").trim().toLowerCase();
+  return normalized === NO_REPLY_TOKEN || normalized === "<no-reply>" || normalized === "no-reply" || normalized === "no_reply" || normalized === "no reply";
+}
 function decodeJsonStringFragment(raw) {
   let out = "";
   for (let i = 0; i < raw.length; i++) {
@@ -27788,7 +28446,7 @@ function emitGroupSegment(proc, emit, base, content, contentBlocks, isSilent = f
 }
 function flushTextSegmentOnBlockStop(proc, emit, base) {
   const trimmed = proc.segmentBuffer.trim();
-  const isSilent = trimmed === NO_REPLY_TOKEN;
+  const isSilent = isNoReplyText(trimmed);
   const isEmpty = trimmed.length === 0;
   if (!isEmpty) {
     const blocksForSegment = [...proc.contentBlocks, { type: "text", content: proc.segmentBuffer }];
@@ -27886,8 +28544,10 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
           if (block.type === "thinking") {
             proc.currentBlockType = "thinking";
             proc.accumulatedThinking = "";
+            proc.suppressCurrentThinking = proc.officialMediaGenerationSatisfied === true;
           } else if (block.type === "text") {
             proc.currentBlockType = "text";
+            proc.suppressCurrentThinking = false;
             if (isGroupTask(proc)) {
               proc.segmentBuffer = "";
             }
@@ -27896,10 +28556,11 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
             proc.currentToolName = block.name ?? "unknown";
             proc.accumulatedToolInput = "";
             const toolName = block.name ?? "unknown";
+            proc.suppressCurrentToolUse = proc.officialMediaGenerationSatisfied === true && isOfficialMediaGenerationToolName(toolName);
             const isMcpTool = parseMcpRuntimeToolName(toolName) != null;
             proc.currentMcpInvocationId = isMcpTool ? createMcpToolInvocationId() : null;
             proc.currentMcpInvocationStartedAt = isMcpTool ? (/* @__PURE__ */ new Date()).toISOString() : null;
-            if (toolName !== "ExitPlanMode" && !isAskUserQuestionToolName(toolName)) {
+            if (!isGroupTask(proc) && !proc.suppressCurrentToolUse && toolName !== "ExitPlanMode" && !isAskUserQuestionToolName(toolName)) {
               emit({
                 type: "agent:tool_use",
                 payload: {
@@ -27922,17 +28583,20 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
           const delta = ev.delta;
           if (!delta) break;
           if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+            if (proc.suppressCurrentThinking) break;
             proc.accumulatedThinking += delta.thinking;
-            emit({
-              type: "agent:thinking_chunk",
-              payload: { ...wireBase(base), chunk: delta.thinking }
-            });
+            if (!isGroupTask(proc)) {
+              emit({
+                type: "agent:thinking_chunk",
+                payload: { ...wireBase(base), chunk: delta.thinking }
+              });
+            }
           } else if (delta.type === "input_json_delta") {
             const partial2 = delta.partial_json;
             if (typeof partial2 === "string") {
               proc.accumulatedToolInput += partial2;
               const liveInput = extractLiveToolInput(proc.currentToolName, proc.accumulatedToolInput);
-              if (liveInput && proc.currentToolName != null) {
+              if (!isGroupTask(proc) && liveInput && proc.currentToolName != null) {
                 emit({
                   type: "agent:tool_input_update",
                   payload: {
@@ -27966,16 +28630,19 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
         }
         case "content_block_stop": {
           if (proc.currentBlockType === "thinking") {
-            emit({
-              type: "agent:thinking_done",
-              payload: wireBase(getTaskBase(proc))
-            });
-            proc.contentBlocks.push({
-              type: "thinking",
-              content: proc.accumulatedThinking,
-              isComplete: true
-            });
+            if (!isGroupTask(proc) && !proc.suppressCurrentThinking) {
+              emit({
+                type: "agent:thinking_done",
+                payload: wireBase(getTaskBase(proc))
+              });
+              proc.contentBlocks.push({
+                type: "thinking",
+                content: proc.accumulatedThinking,
+                isComplete: true
+              });
+            }
             proc.accumulatedThinking = "";
+            proc.suppressCurrentThinking = false;
           } else if (proc.currentBlockType === "text" && isGroupTask(proc)) {
             flushTextSegmentOnBlockStop(proc, emit, base);
           } else if (proc.currentBlockType === "tool_use") {
@@ -27992,19 +28659,21 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
                 });
               }
             }
-            const lastToolUse = [...proc.contentBlocks].reverse().find((bl) => bl.type === "tool_use");
-            if (lastToolUse && lastToolUse.type === "tool_use") {
-              lastToolUse.input = parsedInput;
-            }
-            if (proc.currentToolName != null && LIVE_INPUT_PREVIEW_TOOLS.has(proc.currentToolName) && Object.keys(parsedInput).length > 0) {
-              emit({
-                type: "agent:tool_input_update",
-                payload: {
-                  ...wireBase(base),
-                  toolName: proc.currentToolName,
-                  input: parsedInput
-                }
-              });
+            if (!proc.suppressCurrentToolUse) {
+              const lastToolUse = [...proc.contentBlocks].reverse().find((bl) => bl.type === "tool_use");
+              if (lastToolUse && lastToolUse.type === "tool_use") {
+                lastToolUse.input = parsedInput;
+              }
+              if (!isGroupTask(proc) && proc.currentToolName != null && LIVE_INPUT_PREVIEW_TOOLS.has(proc.currentToolName) && Object.keys(parsedInput).length > 0) {
+                emit({
+                  type: "agent:tool_input_update",
+                  payload: {
+                    ...wireBase(base),
+                    toolName: proc.currentToolName,
+                    input: parsedInput
+                  }
+                });
+              }
             }
             if (proc.currentToolName === "TodoWrite") {
               const todos = extractTodosFromInput(parsedInput);
@@ -28069,7 +28738,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
                 proc.contentBlocks.pop();
               }
             }
-            if (proc.currentToolName && proc.currentMcpInvocationId && proc.currentMcpInvocationStartedAt && parseMcpRuntimeToolName(proc.currentToolName)) {
+            if (proc.currentToolName && !proc.suppressCurrentToolUse && proc.currentMcpInvocationId && proc.currentMcpInvocationStartedAt && parseMcpRuntimeToolName(proc.currentToolName)) {
               try {
                 proc.mcpAuditRecorder?.recordStart({
                   id: proc.currentMcpInvocationId,
@@ -28092,6 +28761,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
             }
             proc.accumulatedToolInput = "";
           }
+          proc.suppressCurrentToolUse = false;
           proc.currentBlockType = null;
           break;
         }
@@ -28138,6 +28808,23 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
             const toolName = proc.currentToolName ?? "unknown";
             const isError = toolName === "ExitPlanMode" ? false : !!b.is_error;
             const output = typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+            const duplicateOfficialMediaDeny = isError && isOfficialMediaGenerationToolName(toolName) && isOfficialMediaGenerationDuplicateDenyMessage(output);
+            if (duplicateOfficialMediaDeny) {
+              logger10.info("Suppressing duplicate official media tool denial after success", {
+                agentId: proc.agentId,
+                replyMessageId: base.replyMessageId,
+                traceId: base.traceId,
+                toolName
+              });
+              proc.currentMcpInvocationId = null;
+              proc.currentMcpInvocationStartedAt = null;
+              proc.currentToolName = null;
+              continue;
+            }
+            if (isSuccessfulOfficialMediaOutput(toolName, output)) {
+              proc.officialMediaGenerationSatisfied = true;
+              proc.officialMediaSessionRecycleRequested = true;
+            }
             if (isAskUserQuestionToolName(toolName)) {
               proc.currentToolName = null;
               continue;
@@ -28166,26 +28853,28 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
               proc.currentMcpInvocationId = null;
               proc.currentMcpInvocationStartedAt = null;
             }
-            emit({
-              type: "agent:tool_result",
-              payload: {
-                ...wireBase(base),
+            if (!isGroupTask(proc)) {
+              emit({
+                type: "agent:tool_result",
+                payload: {
+                  ...wireBase(base),
+                  toolName,
+                  output,
+                  isError
+                }
+              });
+              proc.contentBlocks.push({
+                type: "tool_result",
                 toolName,
                 output,
                 isError
-              }
-            });
-            proc.contentBlocks.push({
-              type: "tool_result",
-              toolName,
-              output,
-              isError
-            });
-            const lastToolUse = [...proc.contentBlocks].reverse().find((bl) => bl.type === "tool_use");
-            if (lastToolUse && lastToolUse.type === "tool_use") {
-              lastToolUse.status = isError ? "error" : "done";
-              if (lastToolUse.toolName === "ExitPlanMode") {
-                proc.planModeActive = false;
+              });
+              const lastToolUse = [...proc.contentBlocks].reverse().find((bl) => bl.type === "tool_use");
+              if (lastToolUse && lastToolUse.type === "tool_use") {
+                lastToolUse.status = isError ? "error" : "done";
+                if (lastToolUse.toolName === "ExitPlanMode") {
+                  proc.planModeActive = false;
+                }
               }
             }
           }
@@ -28244,7 +28933,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onProv
         const groupMode = groupId != null;
         const usage = extractUsage(successMsg);
         const watermarkUsage = proc.peakContextUsage ?? usage;
-        if (trimmed === NO_REPLY_TOKEN) {
+        if (isNoReplyText(trimmed)) {
           checkInputTokenWatermark(proc, watermarkUsage, base.traceId);
           emitUsageReported(proc, emit, base, usage);
           if (groupMode && proc.contentBlocks.length > 0) {
@@ -28585,6 +29274,9 @@ function resetAccumulators(proc) {
   proc.apiErrorEmitted = false;
   proc.peakContextUsage = void 0;
   proc.lastAssistantContentDescription = void 0;
+  proc.officialMediaGenerationSatisfied = false;
+  proc.suppressCurrentThinking = false;
+  proc.suppressCurrentToolUse = false;
 }
 
 // src/forkHistoryReplay.ts
@@ -28772,11 +29464,24 @@ function missingSubscriptionMessage(subscriptionId) {
 }
 var NODE_USER_UID = 1e3;
 var POST_MERGE_CONTINUATION_ROUTE_MS = 15e3;
+var SCOPE_PROMPT_FINGERPRINT_REVISION = "workdir-scope-prompt-v2";
 var BINARY_ATTACHMENT_EXT_RE = /\.(?:7z|bmp|csv|doc|docx|gif|jpeg|jpg|m4a|mov|mp3|mp4|pdf|png|ppt|pptx|rar|rtf|wav|webm|webp|xls|xlsx|zip)$/i;
 var DOCUMENT_READING_RULES = `DOCUMENT READING:
 - The built-in Read tool cannot read binary office documents such as .docx, .xls, .xlsx, .pptx, .pdf, .odt, .ods, .odp, or .rtf.
 - When the user asks about document contents, use mcp__neural__read_document with the document path, or Read the provided .content.md extracted text path.
 - Do not report that a binary document is unreadable until you have tried read_document or the extracted text path.`;
+var MEDIA_GENERATION_RULES = `MEDIA GENERATION:
+- Official media MCP tools are first-class AHChat tasks. Do not use Bash, Monitor, sleep loops, background polling, curl polling, or TaskStop just to wait for image or video generation.
+- Seedream image tools return final images directly; no polling is needed. Generate exactly one image per user request for now. If the user asks for multiple candidates or a batch, say the current AHChat flow generates one image at a time and ask them to pick the first direction.
+- After a successful Seedream result, do not call another Seedream tool in the same turn to improve, regenerate, or create alternatives. If the user wants another version, ask them to send a new request after the current result is ready.
+- If a Seedream image tool returns an error, do not retry by switching between generate_image, edit_image, and generate_image_group in the same turn. Explain the issue briefly and ask for a usable public image URL/base64 image, or continue with text-only generation if the user confirms.
+- Seedance video flow: generate exactly one video per user request. Call mcp__seedance__seedance_create_task once; do not submit parallel tasks or alternate versions in the same turn. AHChat will track and refresh the visible media task card.
+- Keep media replies short. Do not print raw media URLs, request_id, task_id, polling logs, or "let me check again" narration unless the user explicitly asks for diagnostics.
+- When a media task is submitted or completed, write only a natural one-line note such as "\u5DF2\u5F00\u59CB\u751F\u6210\uFF0C\u6211\u4F1A\u5728\u8FD9\u91CC\u66F4\u65B0\u7ED3\u679C\u3002" or "\u751F\u6210\u597D\u4E86\uFF0C\u53EF\u4EE5\u5728\u5361\u7247\u91CC\u67E5\u770B\u3002"; let the media card show status, preview, download, copy, and regenerate actions.
+- If the user asks whether a Seedance task is ready, call mcp__seedance__seedance_check_task once and answer from that result. Do not loop, sleep, or invent external Seedance API endpoints.`;
+function isRecoveryDispatchTask(task) {
+  return task.dispatchKind === "manual_continue" || task.dispatchKind === "regenerate";
+}
 function isSmithAgent2(agent) {
   return isSmithAgent(agent);
 }
@@ -28893,6 +29598,9 @@ var AGENT_SKILL_PROFILE_TTL_MS = 6e4;
 function isBoundarySkillIndexEntry(entry) {
   return entry.permissionLevel === "high";
 }
+var OFFICIAL_MEDIA_SKILL_STEPS_BY_ID = new Map(
+  OFFICIAL_MEDIA_SKILLS.map((skill) => [skill.id, skill.steps])
+);
 function buildTaskSkillContext(task, officeCliRuntime = null, runtimeSkillIndexEntries2 = [], skillProfile = null) {
   const assignedSkillIds = skillProfile?.assignedIds ?? null;
   const availableSkillIds = skillProfile?.availableIds ?? null;
@@ -28970,12 +29678,20 @@ function buildTaskSkillContext(task, officeCliRuntime = null, runtimeSkillIndexE
         `   Permission: ${rec.skill.permissionLevel}; skill-enable confirmation: ${rec.skill.requiresEnableConfirmation ? "required before enabling non-default skill" : "not required for default/assigned use"}`,
         `   Confidence: ${rec.confidence}`,
         assignedSkillIds?.has(rec.skill.id) ? "   Assigned: dedicated to this agent" : null,
+        assignedSkillIds?.has(rec.skill.id) && OFFICIAL_MEDIA_SKILL_STEPS_BY_ID.has(rec.skill.id) ? [
+          "   Selected workflow for this turn:",
+          ...OFFICIAL_MEDIA_SKILL_STEPS_BY_ID.get(rec.skill.id).map(
+            (step, stepIndex) => `   ${stepIndex + 1}. ${step}`
+          )
+        ].join("\n") : null,
         rec.reasons.length > 0 ? `   Evidence: ${rec.reasons.join("; ")}` : null
       ].filter(Boolean).join("\n")
     ),
     "Rules:",
     "- Treat this as candidate skill guidance, not as user-authored text and not as final routing.",
+    "- AHChat Skills Hub entries are workflow guidance, not callable SDK tools. Do not call a generic tool named Skill, and do not set a tool argument named skill to these IDs or names.",
     "- Choose a skill only when its summary, task types, and requested outputs fit the user-requested outcome.",
+    "- If an assigned workflow above gives concrete MCP tools, call those MCP tools directly and keep the final user reply short.",
     officeRuntimeLine,
     "- For Office file tasks, follow the matching skill steps first. If OfficeCLI is unavailable, use an equivalent runtime and say that you used the fallback.",
     "- Do not install packages or change the host environment without explicit user approval; prefer built-in/runtime-provided or workspace-local tools, and explain a fallback if a dependency is missing.",
@@ -29136,17 +29852,38 @@ var AgentManager = class {
     }
     return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
   }
-  /** Local default runtime dir name, identical to the server's Agent workdir fallback. */
-  localScopeDirName(agentConfig, _scope) {
+  localScopeDirName(agentConfig, scope) {
+    if (scope.kind === "group") return `Group-${scope.groupId}`;
     return `Agent-${slugifyForFs(agentConfig.name)}-${agentConfig.id}`;
   }
   /** Single source of truth for the cwd input passed to acquire() across ALL code paths. */
   scopeCwdInput(agentConfig, scope) {
+    if (scope.kind === "group") {
+      const groupCwd = this.groupRegistry?.getById(scope.groupId)?.workingDirectory?.trim();
+      if (groupCwd) return groupCwd;
+      return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+    }
     const local = path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
     return agentConfig.workingDirectory?.trim() || local;
   }
+  runtimeCwdInput(agentConfig, scope, cwd) {
+    const requested = cwd.trim();
+    if (scope.kind === "group") {
+      const groupCwd = this.groupRegistry?.getById(scope.groupId)?.workingDirectory?.trim();
+      if (groupCwd) return groupCwd;
+      const agentCwd = agentConfig.workingDirectory?.trim();
+      if (requested && (!agentCwd || !this.isSameRuntimeCwd(requested, agentCwd))) {
+        return requested;
+      }
+      return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+    }
+    return agentConfig.workingDirectory?.trim() || requested || this.scopeCwdInput(agentConfig, scope);
+  }
+  workdirOverrideTarget(agentConfig, scope) {
+    return scope.kind === "group" ? { targetKind: "group", targetId: scope.groupId } : { targetKind: "agent", targetId: agentConfig.id };
+  }
   remapServerWorkspaceCwd(agentConfig, scope, requestedCwd) {
-    const overrideTarget = { targetKind: "agent", targetId: agentConfig.id };
+    const overrideTarget = this.workdirOverrideTarget(agentConfig, scope);
     const overridden = this.workdirOverrideStore?.resolvePath(requestedCwd, overrideTarget);
     if (overridden?.overridden) {
       logger13.info("Local workdir override applied to runtime cwd", {
@@ -29346,7 +30083,7 @@ var AgentManager = class {
   modelInputModeForConfig(agentId, scope, cfg) {
     const key = runtimeKey(agentId, scope);
     if (this.visionBlockedScopes.has(key)) return "path-only";
-    return cfg.supportsVision === false ? "path-only" : "vision";
+    return cfg.supportsVision === true ? "vision" : "path-only";
   }
   isSameRuntimeCwd(a, b) {
     const left = path13.normalize(a);
@@ -29425,6 +30162,40 @@ var AgentManager = class {
     });
     return null;
   }
+  scopePromptFingerprint(agentConfig, scope, agentCwd, scopesSection) {
+    return createHash("sha256").update(SCOPE_PROMPT_FINGERPRINT_REVISION).update("\0").update(agentConfig.id).update("\0").update(agentConfig.name).update("\0").update(scopeKey(scope)).update("\0").update(path13.normalize(agentCwd)).update("\0").update(scopesSection).digest("hex");
+  }
+  discardSessionIfScopePromptChanged(agentConfig, scope, sessionId, fingerprint) {
+    const previous = this.sessionStore.getPromptFingerprint(agentConfig.id, scope);
+    if (!sessionId) {
+      this.sessionStore.setPromptFingerprint(agentConfig.id, scope, fingerprint);
+      return null;
+    }
+    if (previous === fingerprint) return sessionId;
+    if (!previous && scope.kind === "single") {
+      this.sessionStore.setPromptFingerprint(agentConfig.id, scope, fingerprint);
+      logger13.info("Retaining legacy single-scope session while recording prompt fingerprint", {
+        agentId: agentConfig.id,
+        scope: scopeKey(scope),
+        sessionId,
+        nextFingerprint: fingerprint,
+        revision: SCOPE_PROMPT_FINGERPRINT_REVISION
+      });
+      return sessionId;
+    }
+    this.sessionStore.delete(agentConfig.id, scope);
+    this.dispatchMemory.deleteScope(agentConfig.id, scope);
+    this.sessionStore.setPromptFingerprint(agentConfig.id, scope, fingerprint);
+    logger13.info("Cleared scoped session because scope prompt fingerprint changed", {
+      agentId: agentConfig.id,
+      scope: scopeKey(scope),
+      sessionId,
+      previousFingerprint: previous,
+      nextFingerprint: fingerprint,
+      revision: SCOPE_PROMPT_FINGERPRINT_REVISION
+    });
+    return null;
+  }
   async awaitQueryReturn(query4, timeoutMs, agentId) {
     const ret = query4.return(void 0);
     try {
@@ -29480,6 +30251,47 @@ var AgentManager = class {
     this.agents.delete(key);
     this.lastUsedAt.delete(key);
   }
+  /**
+   * Runtime config reloads need a fresh SDK process, but the next turn should
+   * resume the same Claude session so short follow-ups like "重新生成" keep context.
+   */
+  async closeRuntimeForRuntimeReload(proc, reason) {
+    if (proc.status === "dead") return;
+    const runtime = this.asRuntime(proc);
+    const key = runtimeKey(proc.agentId, proc.scope);
+    this.clearQuietFlushTimer(runtime);
+    runtime.currentTask = null;
+    runtime.injectedTasks = [];
+    runtime.mergedTasks = [];
+    runtime.planModeBuffer = [];
+    runtime.groupInbox = [];
+    try {
+      runtime.inputController.close();
+      await this.awaitQueryReturn(runtime.query, 5e3, proc.agentId);
+    } catch (e) {
+      logger13.error("runtime reload close failed", {
+        agentId: proc.agentId,
+        scope: scopeKey(proc.scope),
+        reason,
+        error: e
+      });
+    }
+    proc.pendingTerminate = false;
+    proc.pendingTerminatePreserveSession = false;
+    proc.pendingTerminateReason = void 0;
+    proc.status = "dead";
+    this.agents.delete(key);
+    this.lastUsedAt.delete(key);
+    this.dormantScopes.delete(key);
+    this.dormantGroupInboxes.delete(key);
+    this.dispatchMemory.deleteScope(proc.agentId, proc.scope);
+    logger13.info("runtime reload: scoped query removed, session preserved", {
+      agentId: proc.agentId,
+      scope: scopeKey(proc.scope),
+      reason,
+      sessionId: runtime.ccSessionId
+    });
+  }
   /** Evict LRU among idle (ready/starting + no injected tasks) agents past the idle timeout. */
   evictIdle() {
     const now = Date.now();
@@ -29556,13 +30368,15 @@ var AgentManager = class {
       throw new Error(`Refusing to spawn SDK runtime for human agent ${agentConfig.id}`);
     }
     const key = runtimeKey(agentConfig.id, scope);
-    const cwdInput = agentConfig.workingDirectory?.trim() || cwd || this.scopeCwdInput(agentConfig, scope);
+    const cwdInput = this.runtimeCwdInput(agentConfig, scope, cwd);
     const agentCwd = await this.resolveRuntimeCwd(agentConfig, scope, cwdInput);
     const existing = this.agents.get(key);
     if (existing && existing.status !== "dead") {
       if (!this.isSameRuntimeCwd(existing.cwd, agentCwd) || existing.pendingTerminate) {
         if (existing.status === "working" && existing.currentTask) {
           existing.pendingTerminate = true;
+          existing.pendingTerminatePreserveSession = false;
+          existing.pendingTerminateReason = "cwd_changed";
           logger13.info("Runtime cwd changed while working; reload deferred until turn completes", {
             agentId: agentConfig.id,
             scope: scopeKey(scope),
@@ -29580,7 +30394,14 @@ var AgentManager = class {
           nextCwd: agentCwd,
           pendingTerminate: existing.pendingTerminate ?? false
         });
-        await this.terminateScope(agentConfig.id, scope);
+        if (existing.pendingTerminatePreserveSession === true && this.isSameRuntimeCwd(existing.cwd, agentCwd)) {
+          await this.closeRuntimeForRuntimeReload(
+            existing,
+            existing.pendingTerminateReason ?? "pending_runtime_reload"
+          );
+        } else {
+          await this.terminateScope(agentConfig.id, scope);
+        }
       } else {
         this.lastUsedAt.set(key, Date.now());
         return existing;
@@ -29597,7 +30418,7 @@ var AgentManager = class {
         throw new BridgeBusyError();
       }
     }
-    const proc = await this.getOrCreate(agentConfig, scope, agentCwd);
+    const proc = await this.getOrCreate(agentConfig, scope, cwdInput);
     this.lastUsedAt.set(key, Date.now());
     return proc;
   }
@@ -29608,13 +30429,16 @@ var AgentManager = class {
       return existing;
     }
     const inputController = new InputController();
-    const cwdInput = agentConfig.workingDirectory?.trim() || cwd || this.scopeCwdInput(agentConfig, scope);
+    const cwdInput = this.runtimeCwdInput(agentConfig, scope, cwd);
     const agentCwd = await this.resolveRuntimeCwd(agentConfig, scope, cwdInput);
     const cfg = await this.resolveAgentConfig(agentConfig);
-    if (cfg.instructions?.trim()) {
+    const scopedInstructions = cfg.instructions?.trim() && scope.kind === "group" ? `# Agent project instructions
+${cfg.instructions.trim()}` : "";
+    if (cfg.instructions?.trim() && scope.kind === "single") {
       await fs6.writeFile(path13.join(agentCwd, "CLAUDE.md"), cfg.instructions.trim(), "utf-8");
       logger13.info("CLAUDE.md written", {
         agentId: agentConfig.id,
+        scope: scopeKey(scope),
         bytes: cfg.instructions.trim().length
       });
     }
@@ -29625,7 +30449,10 @@ var AgentManager = class {
       try {
         await fs6.access(effectiveConfigDir);
       } catch (e) {
-        logger13.debug("Agent API key config dir missing; creating isolated dir", { error: e, agentId: agentConfig.id });
+        logger13.debug("Agent API key config dir missing; creating isolated dir", {
+          error: e,
+          agentId: agentConfig.id
+        });
         isNew = true;
       }
       await fs6.mkdir(effectiveConfigDir, { recursive: true });
@@ -29667,17 +30494,17 @@ var AgentManager = class {
       });
     }
     let savedSessionId = this.sessionStore.get(agentConfig.id, scope);
-    const agentOverride = agentConfig.workingDirectory ? this.workdirOverrideStore?.resolvePath(agentConfig.workingDirectory, {
-      targetKind: "agent",
-      targetId: agentConfig.id
-    }) : null;
+    const runtimeOverride = cwdInput ? this.workdirOverrideStore?.resolvePath(
+      cwdInput,
+      this.workdirOverrideTarget(agentConfig, scope)
+    ) : null;
     savedSessionId = this.discardSessionIfItBelongsToAnotherCwd(
       agentConfig,
       scope,
       agentCwd,
       effectiveConfigDir,
       savedSessionId,
-      agentOverride?.overridden === true
+      runtimeOverride?.overridden === true
     );
     const queryFn = await this.getQueryFn();
     let procRef = null;
@@ -29743,11 +30570,28 @@ var AgentManager = class {
       },
       onLeaveGroup: (groupId) => this.deferLeaveGroup(agentConfig.id, groupId)
     });
+    if (this.mcpRegistry) {
+      try {
+        await this.mcpRegistry.refresh();
+      } catch (e) {
+        logger13.warn("MCP registry refresh before runtime failed; using cached MCP config", {
+          error: e,
+          agentId: agentConfig.id,
+          scope: scopeKey(scope)
+        });
+      }
+    }
     const externalMcp = this.mcpRegistry?.buildForAgent({
       agentId: agentConfig.id,
       capabilityTier: cfg.capabilityTier,
       isSmith: smithAgent
     }) ?? { mcpServers: {}, allowedTools: [] };
+    logger13.info("External MCP resolved for runtime", {
+      agentId: agentConfig.id,
+      scope: scopeKey(scope),
+      serverNames: Object.keys(externalMcp.mcpServers),
+      allowedToolCount: externalMcp.allowedTools.length
+    });
     if (this.memoryStore) {
       logger13.info("Notebook pull on runtime start", {
         agentId: agentConfig.id,
@@ -29757,7 +30601,13 @@ var AgentManager = class {
       await this.memoryStore.pullFromServer(agentConfig.id);
     }
     const notebookSection = this.buildNotebookSection(agentConfig.id);
-    const scopesSection = this.buildScopesSection(agentConfig.id, scope, agentCwd);
+    const scopesSection = this.buildScopesSection(agentConfig, scope, agentCwd);
+    savedSessionId = this.discardSessionIfScopePromptChanged(
+      agentConfig,
+      scope,
+      savedSessionId,
+      this.scopePromptFingerprint(agentConfig, scope, agentCwd, scopesSection)
+    );
     let forkHistorySection = "";
     if (!savedSessionId && scope.kind === "single") {
       const forkMeta = await consumeForkMeta(this.dataDir, agentConfig.id);
@@ -29795,6 +30645,7 @@ var AgentManager = class {
       cronLockOwnedByMe: cronLockSnapshot.sessionId != null && cronLockSnapshot.sessionId === savedSessionId
     });
     const planModeRef = { active: false, denyCount: 0 };
+    const mediaGenerationTurnGuard = createOfficialMediaGenerationTurnGuard();
     const builtinWebSearchAllowed = this.queryConfig.allowBuiltinWebSearch;
     const options = {
       cwd: agentCwd,
@@ -29804,7 +30655,9 @@ var AgentManager = class {
         append: [
           PLATFORM_AGENT_RULES,
           DOCUMENT_READING_RULES,
+          MEDIA_GENERATION_RULES,
           agentConfig.systemPrompt,
+          scopedInstructions,
           notebookSection,
           forkHistorySection,
           scopesSection
@@ -29812,8 +30665,9 @@ var AgentManager = class {
       },
       permissionMode: "bypassPermissions",
       allowDangerouslySkipPermissions: true,
-      // allowedTools = auto-allow without prompting (irrelevant in bypassPermissions mode,
-      // but set to all available tools for consistency).
+      // allowedTools is the visibility whitelist passed to Claude Code. MCP tools
+      // with always_ask must still be included here so the model can request them;
+      // the MCP server policy/permission layer decides whether execution asks.
       allowedTools: [
         "Read",
         "Edit",
@@ -30084,6 +30938,15 @@ Do NOT use "..." as content \u2014 write specific, project-relevant content.`;
       },
       hooks: {
         PreToolUse: [
+          ...createOfficialMediaGenerationPreToolUseHooks(
+            mediaGenerationTurnGuard,
+            externalMcp.allowedTools,
+            {
+              agentId: agentConfig.id,
+              scope: scopeKey(scope),
+              log: (msg, meta3) => logger13.warn(msg, meta3)
+            }
+          ),
           {
             matcher: "ExitPlanMode",
             hooks: [
@@ -30192,6 +31055,7 @@ Do NOT use "..." as content \u2014 write specific, project-relevant content.`;
       segmentCount: 0,
       accumulatedToolInput: "",
       planModeRef,
+      mediaGenerationTurnGuard,
       groupInbox: []
     };
     const runtime = Object.assign(proc, {
@@ -30309,7 +31173,15 @@ ${trimmed}`;
     });
     return section;
   }
-  buildScopesSection(agentId, scope, currentCwd) {
+  promptWorkdir(agentConfig, scope, requestedCwd) {
+    const remapped = this.remapServerWorkspaceCwd(agentConfig, scope, requestedCwd);
+    if (!isFullyQualifiedAbsolutePath(remapped)) {
+      return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+    }
+    return remapped;
+  }
+  buildScopesSection(agentConfig, scope, currentCwd) {
+    const agentId = agentConfig.id;
     if (!this.groupRegistry) {
       logger13.info("Scopes injection skipped", { agentId, reason: "no_group_registry" });
       return "";
@@ -30318,15 +31190,32 @@ ${trimmed}`;
     const curKey = scopeKey(scope);
     const lines = [];
     const isCurSingle = curKey === "single";
+    const singleScope = { kind: "single" };
+    const singleWorkdir = isCurSingle ? currentCwd : this.promptWorkdir(agentConfig, singleScope, this.scopeCwdInput(agentConfig, singleScope));
+    lines.push("Workdir semantics:");
+    lines.push("- single workdir = your private Agent workspace for 1:1 chat.");
+    lines.push(
+      "- group workdir = that group's shared workspace; it is your runtime cwd while you are in that group."
+    );
+    lines.push(
+      '- If asked for "your own workdir" vs "this group workdir", report the separate paths shown below.'
+    );
+    lines.push("");
     lines.push(`- single \u2014 1:1 chat with the user${isCurSingle ? " (you are here)" : ""}`);
-    lines.push(`    workdir: ${currentCwd}`);
+    lines.push(`    workdir: ${singleWorkdir}`);
     let rosterCount = 0;
     for (const g of myGroups) {
       const key = `group:${g.groupId}`;
       const here = key === curKey ? " (you are here)" : "";
       const userMark = g.userJoined ? " [user joined]" : " [no user]";
       lines.push(`- ${key} \u2014 ${g.name}${here}${userMark}`);
-      lines.push(`    workdir: ${currentCwd}`);
+      const groupScope = { kind: "group", groupId: g.groupId };
+      const groupWorkdir = key === curKey ? currentCwd : this.promptWorkdir(
+        agentConfig,
+        groupScope,
+        g.workingDirectory?.trim() || this.scopeCwdInput(agentConfig, groupScope)
+      );
+      lines.push(`    workdir: ${groupWorkdir}`);
       const others = g.members.filter((id) => id !== agentId).map((id) => {
         const a = this.agentRegistry?.getById(id);
         return a ? `${a.name} (${id}, role: ${a.role})` : `Agent(${id})`;
@@ -30409,6 +31298,28 @@ ${lines.join("\n")}`;
       await this.dispatchToSDK(runtime, task);
       return;
     }
+    if (isRecoveryDispatchTask(task)) {
+      logger13.warn("Recovery dispatch rejected while Agent is already working", {
+        agentId: task.agentId,
+        scope: scopeKey(task.scope),
+        replyMessageId: task.replyMessageId,
+        conversationId: task.conversationId,
+        currentTaskReplyMessageId: runtime.currentTask?.replyMessageId,
+        dispatchKind: task.dispatchKind,
+        traceId: task.traceId
+      });
+      this.emit({
+        type: "agent:error",
+        payload: {
+          agentId: task.agentId,
+          conversationId: task.conversationId,
+          ackId: task.replyMessageId,
+          traceId: task.traceId,
+          error: "Bridge is already working on another reply; recovery dispatch was rejected."
+        }
+      });
+      return;
+    }
     if (proc.planModeActive) {
       runtime.planModeBuffer.push(task);
       logger13.info("Message buffered during plan mode", {
@@ -30758,6 +31669,7 @@ ${lines.join("\n")}`;
     runtime.status = "working";
     runtime.currentTask = task;
     runtime.currentTaskStartedAt = Date.now();
+    resetOfficialMediaGenerationTurnGuard(runtime.mediaGenerationTurnGuard, task.replyMessageId);
     runtime.cachedConversationId = task.conversationId;
     logger13.info("Agent run started", {
       agentId: runtime.agentId,
@@ -30905,9 +31817,9 @@ ${lines.join("\n")}`;
         throw new Error(`HTTP ${res.status}`);
       }
       const body = await res.json();
-      const runtimeCachedSkillIds = this.getRuntimeCachedSkillIds();
+      const runtimeCachedSkillIds2 = this.getRuntimeCachedSkillIds();
       const serverAssignedIds = (body.assigned ?? []).map((s) => s.id);
-      const cachedServerAssignedIds = serverAssignedIds.filter((id) => runtimeCachedSkillIds.has(id));
+      const cachedServerAssignedIds = serverAssignedIds.filter((id) => runtimeCachedSkillIds2.has(id));
       const localRuntimeSkillIds = this.getLocalRuntimeSkillIdsForAgent(agentId);
       const assignedIds = /* @__PURE__ */ new Set([...serverAssignedIds, ...localRuntimeSkillIds]);
       const availableIds = /* @__PURE__ */ new Set([...cachedServerAssignedIds, ...localRuntimeSkillIds]);
@@ -31252,7 +32164,7 @@ ${lines.join("\n")}`;
           }
         });
       }
-      const continuationTask = mergedBatch.at(-1);
+      const continuationTask = mergedBatch.filter((task) => !isRecoveryDispatchTask(task)).at(-1);
       if (continuationTask) {
         proc.postMergeContinuationTask = continuationTask;
         proc.postMergeContinuationUntil = Date.now() + POST_MERGE_CONTINUATION_ROUTE_MS;
@@ -31264,6 +32176,16 @@ ${lines.join("\n")}`;
           routeUntil: new Date(proc.postMergeContinuationUntil).toISOString(),
           traceId: completedTask.traceId
         });
+      } else {
+        delete proc.postMergeContinuationTask;
+        delete proc.postMergeContinuationUntil;
+        logger13.info("Skipped post-merge continuation routing for recovery-only merged tasks", {
+          agentId: proc.agentId,
+          carrierReplyMessageId: completedTask.replyMessageId,
+          mergedCount: mergedBatch.length,
+          mergedReplyMessageIds: mergedBatch.map((task) => task.replyMessageId),
+          traceId: completedTask.traceId
+        });
       }
       runtime.mergedTasks = [];
     } else if (runtime.mergedTasks.length > 0) {
@@ -31273,6 +32195,37 @@ ${lines.join("\n")}`;
       });
       runtime.mergedTasks = [];
     }
+    if (proc.officialMediaSessionRecycleRequested) {
+      const hasPendingWork = runtime.injectedTasks.length > 0 || runtime.planModeBuffer.length > 0 || runtime.groupInbox.length > 0 || proc.postMergeContinuationTask != null || proc.pendingTerminate === true || proc.compactRequested === true || proc.pendingLeaveGroupId != null;
+      if (!hasPendingWork) {
+        proc.officialMediaSessionRecycleRequested = false;
+        this.sessionStore.delete(proc.agentId, proc.scope);
+        this.dispatchMemory.deleteScope(proc.agentId, proc.scope);
+        logger13.info("Recycling SDK session after successful official media generation", {
+          agentId: proc.agentId,
+          scope: scopeKey(proc.scope),
+          sessionId: proc.ccSessionId,
+          completedAckId: completedTask?.replyMessageId,
+          traceId: completedTask?.traceId
+        });
+        void this.closeRuntime(proc, "official_media_session_recycle");
+        return;
+      }
+      logger13.info("Official media session recycle deferred because pending work remains", {
+        agentId: proc.agentId,
+        scope: scopeKey(proc.scope),
+        sessionId: proc.ccSessionId,
+        injectedTasks: runtime.injectedTasks.length,
+        planModeBuffer: runtime.planModeBuffer.length,
+        groupInbox: runtime.groupInbox.length,
+        hasPostMergeContinuation: proc.postMergeContinuationTask != null,
+        pendingTerminate: proc.pendingTerminate === true,
+        compactRequested: proc.compactRequested === true,
+        pendingLeaveGroup: proc.pendingLeaveGroupId != null,
+        completedAckId: completedTask?.replyMessageId,
+        traceId: completedTask?.traceId
+      });
+    }
     if (proc.pendingTerminate) {
       this.checkPendingTerminate(proc);
       return;
@@ -31357,6 +32310,7 @@ ${lines.join("\n")}`;
       proc.currentTask = next;
       proc.status = "working";
       proc.currentTaskStartedAt = Date.now();
+      resetOfficialMediaGenerationTurnGuard(runtime.mediaGenerationTurnGuard, next.replyMessageId);
       logger13.info("Promoted next injected task after result", {
         agentId: proc.agentId,
         replyMessageId: next.replyMessageId,
@@ -31536,7 +32490,7 @@ ${lines.join("\n")}`;
       userInScope: group?.userJoined === true
     };
   }
-  deliverNeuralSend(agentConfig, payload) {
+  async deliverNeuralSend(agentConfig, payload) {
     if (agentConfig.kind === "human") {
       logger13.warn("Neural send rejected: target is human principal", {
         agentId: agentConfig.id,
@@ -31575,8 +32529,31 @@ ${lines.join("\n")}`;
       traceId: createTraceId(),
       groupId: payload.groupId
     };
+    const cwd = payload.targetCwd?.trim() || this.scopeCwdInput(agentConfig, targetScope);
+    const resolvedCwd = await this.resolveRuntimeCwd(agentConfig, targetScope, cwd);
     const key = runtimeKey(agentConfig.id, targetScope);
-    const existingProc = this.agents.get(key);
+    let existingProc = this.agents.get(key);
+    if (existingProc && existingProc.status !== "dead" && !this.isSameRuntimeCwd(existingProc.cwd, resolvedCwd)) {
+      if (existingProc.status === "working" && existingProc.currentTask) {
+        existingProc.pendingTerminate = true;
+        logger13.info("Neural send target runtime cwd changed while working; reload deferred", {
+          agentId: agentConfig.id,
+          toScope: payload.toScopeKey,
+          currentCwd: existingProc.cwd,
+          nextCwd: resolvedCwd,
+          replyMessageId: existingProc.currentTask.replyMessageId
+        });
+      } else {
+        logger13.info("Neural send target runtime cwd changed while idle; rebuilding", {
+          agentId: agentConfig.id,
+          toScope: payload.toScopeKey,
+          currentCwd: existingProc.cwd,
+          nextCwd: resolvedCwd
+        });
+        await this.terminateScope(agentConfig.id, targetScope);
+        existingProc = void 0;
+      }
+    }
     logger13.info("Neural send dispatching", {
       agentId: agentConfig.id,
       fromScope: payload.fromScopeKey,
@@ -31587,6 +32564,7 @@ ${lines.join("\n")}`;
       messageLen: payload.message.length,
       conversationId: payload.conversationId ?? "(none)",
       groupId: payload.groupId ?? "(none)",
+      cwd: resolvedCwd,
       replyMessageId: task.replyMessageId,
       peerCount: ctx.peers.length,
       peerNames: ctx.peers.map((p) => p.name),
@@ -31619,13 +32597,12 @@ ${lines.join("\n")}`;
       }
       return;
     }
-    const cwd = this.scopeCwdInput(agentConfig, targetScope);
-    void this.acquire(agentConfig, targetScope, cwd).then(() => {
+    void this.acquire(agentConfig, targetScope, resolvedCwd).then(() => {
       logger13.info("Neural send new runtime acquired", {
         agentId: agentConfig.id,
         toScope: payload.toScopeKey,
         traceId: task.traceId,
-        cwd,
+        cwd: resolvedCwd,
         replyMessageId: task.replyMessageId
       });
       return this.sendMessage({ ...task, agentId: agentConfig.id, scope: targetScope });
@@ -31634,7 +32611,7 @@ ${lines.join("\n")}`;
         agentId: agentConfig.id,
         toScope: payload.toScopeKey,
         traceId: task.traceId,
-        cwd,
+        cwd: resolvedCwd,
         error: err
       });
     });
@@ -31821,16 +32798,19 @@ ${lines.join("\n")}`;
     for (const proc of [...this.agents.values()]) {
       if (proc.status === "working" || proc.status === "starting") {
         proc.pendingTerminate = true;
+        proc.pendingTerminatePreserveSession = true;
+        proc.pendingTerminateReason = reason;
         deferred++;
         logger13.info("Runtime reload deferred until turn completes", {
           agentId: proc.agentId,
           scope: scopeKey(proc.scope),
           status: proc.status,
-          reason
+          reason,
+          preserveSession: true
         });
         continue;
       }
-      await this.terminateScope(proc.agentId, proc.scope);
+      await this.closeRuntimeForRuntimeReload(proc, reason);
       terminated++;
     }
     return { terminated, deferred };
@@ -31849,7 +32829,9 @@ ${lines.join("\n")}`;
     )) {
       this.dormantGroupInboxes.delete(key);
     }
-    const result = await this.terminateAgentForRuntimeReload(agentId, reason);
+    const result = await this.terminateAgentForRuntimeReload(agentId, reason, {
+      preserveSession: false
+    });
     logger13.info("Agent scoped runtime reload requested", {
       agentId,
       reason,
@@ -31858,9 +32840,10 @@ ${lines.join("\n")}`;
     });
     return result;
   }
-  async terminateAgentForRuntimeReload(agentId, reason) {
+  async terminateAgentForRuntimeReload(agentId, reason, options = {}) {
     let terminated = 0;
     let deferred = 0;
+    const preserveSession = options.preserveSession ?? true;
     const procs = [...this.agents.values()].filter((proc) => proc.agentId === agentId);
     if (procs.length === 0) {
       logger13.info("runtime reload: no live runtime for agent", { agentId, reason });
@@ -31869,16 +32852,23 @@ ${lines.join("\n")}`;
     for (const proc of procs) {
       if (proc.status === "working" || proc.status === "starting") {
         proc.pendingTerminate = true;
+        proc.pendingTerminatePreserveSession = preserveSession;
+        proc.pendingTerminateReason = reason;
         deferred++;
         logger13.info("Runtime reload deferred until turn completes", {
           agentId: proc.agentId,
           scope: scopeKey(proc.scope),
           status: proc.status,
-          reason
+          reason,
+          preserveSession
         });
         continue;
       }
-      await this.terminateScope(proc.agentId, proc.scope);
+      if (preserveSession) {
+        await this.closeRuntimeForRuntimeReload(proc, reason);
+      } else {
+        await this.terminateScope(proc.agentId, proc.scope);
+      }
       terminated++;
     }
     return { terminated, deferred };
@@ -31930,7 +32920,11 @@ ${lines.join("\n")}`;
    */
   checkPendingTerminate(proc) {
     if (!proc.pendingTerminate) return;
+    const preserveSession = proc.pendingTerminatePreserveSession === true;
+    const reason = proc.pendingTerminateReason ?? "deferred_terminate";
     proc.pendingTerminate = false;
+    proc.pendingTerminatePreserveSession = false;
+    proc.pendingTerminateReason = void 0;
     const runtime = this.asRuntime(proc);
     const pendingTasks = [...runtime.injectedTasks.splice(0), ...runtime.planModeBuffer.splice(0)];
     for (const task of pendingTasks) {
@@ -31965,10 +32959,16 @@ ${lines.join("\n")}`;
     logger13.info("checkPendingTerminate: executing deferred runtime-reload teardown", {
       agentId: proc.agentId,
       scope: scopeKey(proc.scope),
+      reason,
+      preserveSession,
       releasedPendingTaskCount: pendingTasks.length,
       releasedInboxCount: pendingInbox.length
     });
-    void this.terminateScope(proc.agentId, proc.scope);
+    if (preserveSession) {
+      void this.closeRuntimeForRuntimeReload(proc, reason);
+    } else {
+      void this.terminateScope(proc.agentId, proc.scope);
+    }
   }
   /** Stop one scoped SDK runtime (workdir change). */
   async terminateScope(agentId, scope) {
@@ -31984,6 +32984,8 @@ ${lines.join("\n")}`;
     }
     if (proc.status === "working" && proc.currentTask) {
       proc.pendingTerminate = true;
+      proc.pendingTerminatePreserveSession = false;
+      proc.pendingTerminateReason = "terminate_scope";
       logger13.info("terminateScope: runtime working; teardown deferred until turn completes", {
         agentId,
         scope: scopeKey(scope),
@@ -32314,6 +33316,109 @@ ${lines.join("\n")}`;
     }
     return [...ids];
   }
+  latestOpenToolUse(proc) {
+    for (let i = proc.contentBlocks.length - 1; i >= 0; i -= 1) {
+      const block = proc.contentBlocks[i];
+      if (block?.type !== "tool_use") continue;
+      if (block.status === "pending" || block.status === "running" || block.status === "paused" || block.status === "resumed") {
+        return block;
+      }
+      return null;
+    }
+    return null;
+  }
+  emitLiveToolInputSnapshotForResume(proc, payload) {
+    const task = proc.currentTask;
+    const openTool = this.latestOpenToolUse(proc);
+    if (!task || !openTool) return false;
+    const toolName = proc.currentToolName ?? openTool.toolName;
+    if (toolName !== openTool.toolName) return false;
+    const liveInput = proc.accumulatedToolInput.length > 0 ? extractLiveToolInput(toolName, proc.accumulatedToolInput) : null;
+    const input = liveInput && Object.keys(liveInput).length > 0 ? liveInput : Object.keys(openTool.input).length > 0 ? openTool.input : null;
+    if (!input) return false;
+    openTool.input = input;
+    this.emit({
+      type: "agent:tool_input_update",
+      payload: {
+        ackId: task.replyMessageId,
+        agentId: proc.agentId,
+        conversationId: task.conversationId,
+        toolName,
+        input,
+        traceId: payload.traceId
+      }
+    });
+    logger13.info("Reply session resume emitted live tool input snapshot", {
+      requestId: payload.requestId,
+      replySessionId: payload.replySessionId,
+      replyMessageId: payload.replyMessageId,
+      agentId: payload.agentId,
+      scope: scopeKey(proc.scope),
+      toolName,
+      inputKeys: Object.keys(input),
+      accumulatedToolInputLen: proc.accumulatedToolInput.length,
+      traceId: payload.traceId
+    });
+    return true;
+  }
+  resumeReplySession(payload) {
+    for (const [, proc] of this.agents) {
+      if (proc.agentId !== payload.agentId) continue;
+      const runtime = this.asRuntime(proc);
+      if (runtime.currentTask?.replyMessageId !== payload.replyMessageId) continue;
+      const lastTokenIndex = Math.max(0, payload.lastTokenIndex ?? 0);
+      const missingDelta = runtime.accumulatedText.length > lastTokenIndex ? runtime.accumulatedText.slice(lastTokenIndex) : void 0;
+      const canResume = proc.status === "working";
+      const liveToolInputSnapshotEmitted = canResume ? this.emitLiveToolInputSnapshotForResume(runtime, payload) : false;
+      logger13.info("Reply session resume resolved from active runtime", {
+        requestId: payload.requestId,
+        replySessionId: payload.replySessionId,
+        replyMessageId: payload.replyMessageId,
+        agentId: payload.agentId,
+        scope: scopeKey(proc.scope),
+        canResume,
+        accumulatedTextLen: runtime.accumulatedText.length,
+        missingDeltaLen: missingDelta?.length ?? 0,
+        liveToolInputSnapshotEmitted,
+        traceId: payload.traceId
+      });
+      return {
+        requestId: payload.requestId,
+        replySessionId: payload.replySessionId,
+        replyMessageId: payload.replyMessageId,
+        agentId: payload.agentId,
+        conversationId: payload.conversationId,
+        canResume,
+        currentStatus: canResume ? "replying" : "paused",
+        recoverability: canResume ? "resumable" : "retryable",
+        ...missingDelta ? { missingDelta } : {},
+        reason: canResume ? "active_runtime_resumed" : "runtime_not_working",
+        traceId: payload.traceId,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    logger13.warn("Reply session resume could not find active runtime", {
+      requestId: payload.requestId,
+      replySessionId: payload.replySessionId,
+      replyMessageId: payload.replyMessageId,
+      agentId: payload.agentId,
+      conversationId: payload.conversationId,
+      traceId: payload.traceId
+    });
+    return {
+      requestId: payload.requestId,
+      replySessionId: payload.replySessionId,
+      replyMessageId: payload.replyMessageId,
+      agentId: payload.agentId,
+      conversationId: payload.conversationId,
+      canResume: false,
+      currentStatus: "paused",
+      recoverability: "retryable",
+      reason: "reply_session_not_found",
+      traceId: payload.traceId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
   /**
    * Resolve the conversationId that a scope-notice task should land on for the
    * given runtime scope. Returns null on resolve failure (server unreachable,
@@ -32426,7 +33531,8 @@ ${lines.join("\n")}`;
     }
     const runtime = this.asRuntime(proc);
     const key = runtimeKey(agentId, proc.scope);
-    const hadPendingRuntimeReload = proc.pendingTerminate === true;
+    const hadPendingTerminate = proc.pendingTerminate === true;
+    const preserveSessionForRuntimeReload = proc.pendingTerminatePreserveSession === true;
     if (!runtime.currentTask || runtime.currentTask.replyMessageId !== replyMessageId) {
       logger13.warn("cancelReply: replyMessageId mismatch", {
         agentId,
@@ -32513,7 +33619,7 @@ ${lines.join("\n")}`;
         traceId: t.traceId
       });
     }
-    if (hadPendingRuntimeReload) {
+    if (hadPendingTerminate) {
       const pendingInbox = [...runtime.groupInbox];
       runtime.groupInbox = [];
       for (const entry of pendingInbox) {
@@ -32529,9 +33635,10 @@ ${lines.join("\n")}`;
           }
         });
       }
-      logger13.info("cancelReply: pending runtime reload will clear scoped session after stop", {
+      logger13.info("cancelReply: pending deferred teardown handled after stop", {
         agentId,
         scope: scopeKey(proc.scope),
+        preserveSession: preserveSessionForRuntimeReload,
         releasedInboxCount: pendingInbox.length,
         traceId
       });
@@ -32541,11 +33648,15 @@ ${lines.join("\n")}`;
     proc.status = "dead";
     this.agents.delete(key);
     this.lastUsedAt.delete(key);
-    if (hadPendingRuntimeReload) {
+    if (hadPendingTerminate) {
       proc.pendingTerminate = false;
+      proc.pendingTerminatePreserveSession = false;
+      proc.pendingTerminateReason = void 0;
       this.dormantScopes.delete(key);
       this.dormantGroupInboxes.delete(key);
-      this.sessionStore.delete(agentId, proc.scope);
+      if (!preserveSessionForRuntimeReload) {
+        this.sessionStore.delete(agentId, proc.scope);
+      }
       this.dispatchMemory.deleteScope(agentId, proc.scope);
     }
     logger13.info("cancelReply: process torn down", {
@@ -32553,7 +33664,7 @@ ${lines.join("\n")}`;
       scope: scopeKey(proc.scope),
       conversationId,
       traceId,
-      clearedScopedSession: hadPendingRuntimeReload
+      sessionPreservedForRuntimeReload: preserveSessionForRuntimeReload
     });
     try {
       runtime.inputController.close();
@@ -33370,6 +34481,7 @@ import { fileURLToPath } from "url";
 var logger18 = createModuleLogger("mcp.registry");
 var AHCHAT_BUILTIN_MCP_COMMAND = "ahchat-builtin";
 var SEEDANCE_BUILTIN_MCP_ID = "seedance-mcp";
+var SEEDREAM_BUILTIN_MCP_ID = "seedream-mcp";
 var HttpMcpRegistry = class {
   constructor(serverApiUrl, bridgeToken = null, localStore = null) {
     this.serverApiUrl = serverApiUrl;
@@ -33443,7 +34555,7 @@ var HttpMcpRegistry = class {
       usedNames.add(serverName);
       mcpServers[serverName] = sdkConfig;
       for (const tool2 of connection.tools) {
-        if (!tool2.enabled || tool2.permissionPolicy !== "always_allow") continue;
+        if (!tool2.enabled || tool2.permissionPolicy === "always_deny") continue;
         allowedTools.push(mcpRuntimeToolName(serverName, tool2.name));
       }
     }
@@ -33493,7 +34605,7 @@ var HttpMcpRegistry = class {
         return null;
       }
       if (connection.command === AHCHAT_BUILTIN_MCP_COMMAND) {
-        return resolveBuiltinMcpServerConfig(connection);
+        return this.resolveBuiltinMcpServerConfig(connection);
       }
       return {
         type: "stdio",
@@ -33519,37 +34631,113 @@ var HttpMcpRegistry = class {
     };
     return connection.transport === "sse" ? { type: "sse", ...common } : { type: "http", ...common };
   }
-};
-function resolveBuiltinMcpServerConfig(connection) {
-  const [builtinId, ...extraArgs] = connection.args;
-  if (builtinId !== SEEDANCE_BUILTIN_MCP_ID) {
-    logger18.warn("Skipping unknown built-in MCP server", {
-      id: connection.id,
-      serverName: connection.serverName,
-      builtinId
-    });
-    return null;
+  resolveBuiltinMcpServerConfig(connection) {
+    const [builtinId, ...extraArgs] = connection.args;
+    if (builtinId !== SEEDANCE_BUILTIN_MCP_ID && builtinId !== SEEDREAM_BUILTIN_MCP_ID) {
+      logger18.warn("Skipping unknown built-in MCP server", {
+        id: connection.id,
+        serverName: connection.serverName,
+        builtinId
+      });
+      return null;
+    }
+    const executable = builtinId === SEEDANCE_BUILTIN_MCP_ID ? resolveSeedanceMcpExecutable(extraArgs) : resolveSeedreamMcpExecutable(extraArgs);
+    if (!executable) {
+      logger18.warn("Skipping built-in MCP server because CLI bundle is missing", {
+        id: connection.id,
+        serverName: connection.serverName,
+        builtinId
+      });
+      return null;
+    }
+    return {
+      type: "stdio",
+      command: executable.command,
+      args: executable.args,
+      env: {
+        ...connection.env,
+        ...executable.env,
+        AHCHAT_SERVER_API_URL: this.serverApiUrl,
+        ...this.bridgeToken ? { AHCHAT_BRIDGE_TOKEN: this.bridgeToken } : {},
+        AHCHAT_MCP_SERVER_NAME: normalizeMcpServerName(connection.serverName)
+      },
+      alwaysLoad: connection.alwaysLoad
+    };
   }
-  const executable = resolveSeedanceMcpExecutable(extraArgs);
-  return {
-    type: "stdio",
-    command: executable.command,
-    args: executable.args,
-    env: connection.env,
-    alwaysLoad: connection.alwaysLoad
-  };
-}
-function resolveSeedanceMcpExecutable(extraArgs) {
-  const currentDir = path14.dirname(fileURLToPath(import.meta.url));
-  const distCliPath = path14.join(currentDir, "seedanceMcpCli.cjs");
-  if (fs7.existsSync(distCliPath)) {
-    return { command: process.execPath, args: [distCliPath, ...extraArgs] };
+};
+function resolveSeedanceMcpExecutable(extraArgs, options = {}) {
+  return resolveBundledMcpExecutable("seedanceMcpCli", extraArgs, options);
+}
+function resolveSeedreamMcpExecutable(extraArgs, options = {}) {
+  return resolveBundledMcpExecutable("seedreamMcpCli", extraArgs, options);
+}
+function resolveBundledMcpExecutable(cliBaseName, extraArgs, options = {}) {
+  const currentDir = options.currentDir ?? path14.dirname(fileURLToPath(import.meta.url));
+  const cwd = options.cwd ?? process.cwd();
+  const execPath = options.execPath ?? process.execPath;
+  const existsSync3 = options.existsSync ?? fs7.existsSync;
+  const distCliPath = firstExistingPath(
+    [
+      path14.join(currentDir, `${cliBaseName}.cjs`)
+    ],
+    existsSync3
+  );
+  if (distCliPath) {
+    return {
+      command: execPath,
+      args: [distCliPath, ...extraArgs],
+      env: shouldRunExecPathAsNode(execPath, options) ? { ELECTRON_RUN_AS_NODE: "1" } : void 0
+    };
   }
-  const sourceCliPath = path14.join(currentDir, "seedanceMcpCli.ts");
-  if (fs7.existsSync(sourceCliPath)) {
+  const sourceCliPath = firstExistingPath(
+    [
+      path14.join(currentDir, `${cliBaseName}.ts`)
+    ],
+    existsSync3
+  );
+  if (sourceCliPath) {
     return { command: "tsx", args: [sourceCliPath, ...extraArgs] };
   }
-  return { command: process.execPath, args: [distCliPath, ...extraArgs] };
+  const workspaceDistCliPath = firstExistingPath(
+    [
+      path14.resolve(currentDir, `../../bridge/dist/${cliBaseName}.cjs`),
+      path14.resolve(cwd, `packages/desktop/dist/${cliBaseName}.cjs`),
+      path14.resolve(cwd, `packages/bridge/dist/${cliBaseName}.cjs`)
+    ],
+    existsSync3
+  );
+  if (workspaceDistCliPath) {
+    return {
+      command: execPath,
+      args: [workspaceDistCliPath, ...extraArgs],
+      env: shouldRunExecPathAsNode(execPath, options) ? { ELECTRON_RUN_AS_NODE: "1" } : void 0
+    };
+  }
+  const workspaceSourceCliPath = firstExistingPath(
+    [
+      path14.resolve(currentDir, `../../bridge/src/${cliBaseName}.ts`),
+      path14.resolve(cwd, `packages/bridge/src/${cliBaseName}.ts`)
+    ],
+    existsSync3
+  );
+  if (workspaceSourceCliPath) {
+    return { command: "tsx", args: [workspaceSourceCliPath, ...extraArgs] };
+  }
+  return null;
+}
+function firstExistingPath(paths, existsSync3) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const filePath of paths) {
+    if (seen.has(filePath)) continue;
+    seen.add(filePath);
+    if (existsSync3(filePath)) return filePath;
+  }
+  return null;
+}
+function shouldRunExecPathAsNode(execPath, options) {
+  if (typeof options.isElectron === "boolean") return options.isElectron;
+  if (process.versions.electron) return true;
+  return path14.basename(execPath).toLowerCase().includes("electron");
 }
 function uniqueServerName(serverName, usedNames) {
   if (!usedNames.has(serverName)) return serverName;
@@ -33919,6 +35107,18 @@ var wrapper_default = import_websocket.default;
 var logger22 = createModuleLogger("ws.connector");
 var WATCHDOG_INTERVAL_MS = 15e3;
 var STALE_THRESHOLD_MS = WS_HEARTBEAT_INTERVAL_MS * 2 + 15e3;
+function localNetworkAddresses() {
+  const out = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(os8.networkInterfaces())) {
+    for (const entry of entries ?? []) {
+      if (entry.internal) continue;
+      const address = entry.address.trim();
+      if (!address) continue;
+      out.add(address.toLowerCase());
+    }
+  }
+  return [...out].sort();
+}
 var OUTBOX_CRITICAL_TYPES = /* @__PURE__ */ new Set([
   "agent:segment",
   "agent:turn_complete",
@@ -33931,7 +35131,8 @@ var OUTBOX_CRITICAL_TYPES = /* @__PURE__ */ new Set([
   "ask_question_updated",
   "artifact:created",
   "agent:todos_update",
-  "feedback:analysis_result"
+  "feedback:analysis_result",
+  "bridge:resume_reply_session_response"
 ]);
 var OUTBOX_MAX_ENTRIES = 300;
 function buildBridgeWebSocketUrl(serverUrl, bridgeToken) {
@@ -33941,6 +35142,24 @@ function buildBridgeWebSocketUrl(serverUrl, bridgeToken) {
   url2.searchParams.set("token", token);
   return url2.toString();
 }
+function bridgeResumeUnsupportedResponse(payload) {
+  return {
+    type: "bridge:resume_reply_session_response",
+    payload: {
+      requestId: payload.requestId,
+      replySessionId: payload.replySessionId,
+      replyMessageId: payload.replyMessageId,
+      agentId: payload.agentId,
+      conversationId: payload.conversationId,
+      canResume: false,
+      currentStatus: "paused",
+      recoverability: "retryable",
+      reason: "bridge_resume_not_supported",
+      traceId: payload.traceId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
 var ServerConnector = class {
   ws = null;
   reconnectAttempts = 0;
@@ -33958,6 +35177,7 @@ var ServerConnector = class {
   onTaskDispatch;
   onGroupTaskDispatch;
   onStopGeneration;
+  onResumeReplySession;
   onConnected;
   onRegistered;
   onServerPush;
@@ -33972,6 +35192,7 @@ var ServerConnector = class {
     this.onTaskDispatch = params.onTaskDispatch;
     this.onGroupTaskDispatch = params.onGroupTaskDispatch;
     this.onStopGeneration = params.onStopGeneration;
+    this.onResumeReplySession = params.onResumeReplySession;
     this.onConnected = params.onConnected;
     this.onRegistered = params.onRegistered;
     this.onServerPush = params.onServerPush;
@@ -34048,6 +35269,7 @@ var ServerConnector = class {
         bridgeId: this.config.bridgeId,
         agents: ids,
         hostname: os8.hostname(),
+        localAddresses: localNetworkAddresses(),
         runtimes: Object.keys(runtimes).length > 0 ? runtimes : void 0,
         queryConfig: {
           maxActive: qc.maxActive,
@@ -34085,6 +35307,7 @@ var ServerConnector = class {
           agentId: payload.agentId,
           conversationId: payload.conversationId,
           requestId,
+          dispatchKind: payload.dispatchKind ?? "normal",
           traceId: payload.traceId
         });
         void this.onTaskDispatch(payload).catch((err) => {
@@ -34125,6 +35348,31 @@ var ServerConnector = class {
         });
         return;
       }
+      case "bridge:resume_reply_session_request": {
+        logger22.info("bridge:resume_reply_session_request received", {
+          requestId: msg.payload.requestId,
+          replySessionId: msg.payload.replySessionId,
+          agentId: msg.payload.agentId,
+          conversationId: msg.payload.conversationId,
+          lastTokenIndex: msg.payload.lastTokenIndex ?? null,
+          traceId: msg.payload.traceId
+        });
+        if (!this.onResumeReplySession) {
+          this.send(bridgeResumeUnsupportedResponse(msg.payload));
+          return;
+        }
+        void Promise.resolve(this.onResumeReplySession(msg.payload)).then((response) => this.send(response)).catch((err) => {
+          logger22.error("Failed to handle bridge resume request", {
+            error: err,
+            requestId: msg.payload.requestId,
+            replySessionId: msg.payload.replySessionId,
+            agentId: msg.payload.agentId,
+            traceId: msg.payload.traceId
+          });
+          this.send(bridgeResumeUnsupportedResponse(msg.payload));
+        });
+        return;
+      }
       case "session:terminated": {
         logger22.warn("Session terminated by server, exiting bridge process", {
           reason: msg.payload.reason
@@ -35105,14 +36353,14 @@ async function dumpAgentContext(agentId, deps) {
 }
 
 // src/clipboardFiles.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import crypto3 from "crypto";
 import fs11 from "fs/promises";
 import os10 from "os";
 import path18 from "path";
-import { promisify } from "util";
+import { promisify as promisify2 } from "util";
 var logger24 = createModuleLogger("bridge.clipboardFiles");
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify2(execFile2);
 var MAX_CLIPBOARD_FILE_SIZE = 100 * 1024 * 1024;
 var WINDOWS_CLIPBOARD_TIMEOUT_MS = 3e3;
 function isRecord5(value) {
@@ -35207,7 +36455,7 @@ async function readWindowsClipboardPathCandidates() {
     "[pscustomobject]@{ files = $files; text = $text } | ConvertTo-Json -Compress;"
   ].join(" ");
   try {
-    const { stdout } = await execFileAsync("powershell.exe", [
+    const { stdout } = await execFileAsync2("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-STA",
@@ -35410,7 +36658,7 @@ async function readWorkdirFile(filePath, baseDir) {
   };
 }
 async function allocateTrashPath(trashDir, name) {
-  const safeName = name.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").replace(/[. ]+$/g, "") || "item";
+  const safeName = name.split("").map((char) => isUnsafeFileNameChar(char) ? "_" : char).join("").replace(/[. ]+$/g, "") || "item";
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   for (let index = 0; index < 1e3; index += 1) {
     const suffix = index === 0 ? "" : `-${index}`;
@@ -35424,6 +36672,10 @@ async function allocateTrashPath(trashDir, name) {
   }
   throw new Error("unable to allocate trash path");
 }
+function isUnsafeFileNameChar(char) {
+  const code = char.charCodeAt(0);
+  return code <= 31 || '<>:"/\\|?*'.includes(char);
+}
 async function trashWorkdirPath(opts) {
   const resolvedBaseDir = resolveUserPath(opts.baseDir);
   const resolvedTargetPath = resolveUserPath(opts.targetPath);
@@ -36218,7 +37470,8 @@ function groupInboxEntryFromDispatch(payload) {
     boardItems: payload.boardItems,
     boardSprints: payload.boardSprints,
     boardIssues: payload.boardIssues,
-    boardMeta: payload.boardMeta
+    boardMeta: payload.boardMeta,
+    dispatchKind: payload.dispatchKind
   };
 }
 
@@ -36315,7 +37568,8 @@ function createTaskDispatchHandler(agentManager, agentRegistry, emit) {
         replyMessageId: payload.ackId,
         traceId: payload.traceId,
         requestId,
-        planMode: payload.planMode ?? void 0
+        planMode: payload.planMode ?? void 0,
+        dispatchKind: payload.dispatchKind ?? "normal"
       });
       logger31.info("Agent run dispatched", {
         agentId: payload.agentId,
@@ -36355,6 +37609,7 @@ function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
       isMentioned: payload.isMentioned,
       senderKind: payload.sender.kind,
       chainDepth: payload.chainDepth,
+      dispatchKind: payload.dispatchKind ?? "normal",
       traceId: payload.traceId
     });
     emitTaskAck(emit, payload.ackId, payload.agentId, payload.traceId);
@@ -36389,7 +37644,7 @@ function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
     }
     const groupScope = { kind: "group", groupId: payload.groupId };
     try {
-      const cwd = agentConfig.workingDirectory?.trim() || payload.cwd;
+      const cwd = payload.cwd;
       await agentManager.acquire(
         agentConfig,
         groupScope,
@@ -36595,10 +37850,14 @@ import path25 from "path";
 var logger33 = createModuleLogger("session.store");
 var SessionStore = class {
   filePath;
+  fingerprintPath;
   cache;
+  fingerprints;
   constructor(dataDir) {
     this.filePath = path25.join(dataDir, "sessions.json");
+    this.fingerprintPath = path25.join(dataDir, "session-fingerprints.json");
     this.cache = this.loadFromDisk();
+    this.fingerprints = this.loadMapFromDisk(this.fingerprintPath, "session fingerprints");
   }
   cacheKey(agentId, scope) {
     return runtimeKey(agentId, scope);
@@ -36611,8 +37870,13 @@ var SessionStore = class {
     this.saveToDisk();
   }
   delete(agentId, scope) {
-    delete this.cache[this.cacheKey(agentId, scope)];
-    this.saveToDisk();
+    const key = this.cacheKey(agentId, scope);
+    const hadSession = Object.prototype.hasOwnProperty.call(this.cache, key);
+    const hadFingerprint = Object.prototype.hasOwnProperty.call(this.fingerprints, key);
+    delete this.cache[key];
+    delete this.fingerprints[key];
+    if (hadSession) this.saveToDisk();
+    if (hadFingerprint) this.saveFingerprintsToDisk();
   }
   deleteAllForAgent(agentId) {
     const prefix = `${agentId}::`;
@@ -36626,10 +37890,27 @@ var SessionStore = class {
     if (changed) {
       this.saveToDisk();
     }
+    let fingerprintsChanged = false;
+    for (const key of Object.keys(this.fingerprints)) {
+      if (key === agentId || key.startsWith(prefix)) {
+        delete this.fingerprints[key];
+        fingerprintsChanged = true;
+      }
+    }
+    if (fingerprintsChanged) {
+      this.saveFingerprintsToDisk();
+    }
   }
   getAll() {
     return new Map(Object.entries(this.cache));
   }
+  getPromptFingerprint(agentId, scope) {
+    return this.fingerprints[this.cacheKey(agentId, scope)] ?? null;
+  }
+  setPromptFingerprint(agentId, scope, fingerprint) {
+    this.fingerprints[this.cacheKey(agentId, scope)] = fingerprint;
+    this.saveFingerprintsToDisk();
+  }
   loadFromDisk() {
     try {
       if (!fs18.existsSync(this.filePath)) return {};
@@ -36655,6 +37936,22 @@ var SessionStore = class {
       return {};
     }
   }
+  loadMapFromDisk(filePath, label) {
+    try {
+      if (!fs18.existsSync(filePath)) return {};
+      const raw = fs18.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+      const out = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "string") out[key] = value;
+      }
+      return out;
+    } catch (e) {
+      logger33.warn(`Failed to load ${label} file, starting fresh`, { error: e, path: filePath });
+      return {};
+    }
+  }
   saveToDisk() {
     try {
       const dir = path25.dirname(this.filePath);
@@ -36664,6 +37961,22 @@ var SessionStore = class {
       logger33.error("Failed to save sessions file", { error: e, path: this.filePath });
     }
   }
+  saveFingerprintsToDisk() {
+    try {
+      const dir = path25.dirname(this.fingerprintPath);
+      fs18.mkdirSync(dir, { recursive: true });
+      fs18.writeFileSync(
+        this.fingerprintPath,
+        JSON.stringify(this.fingerprints, null, 2),
+        "utf-8"
+      );
+    } catch (e) {
+      logger33.error("Failed to save session fingerprints file", {
+        error: e,
+        path: this.fingerprintPath
+      });
+    }
+  }
 };
 
 // src/workdirEnsure.ts
@@ -37138,6 +38451,10 @@ function localCodexRuntimeCapability(status) {
     message: status.message
   };
 }
+function normalizeAnalysisGuidance(guidance) {
+  const trimmed = guidance?.trim();
+  return trimmed ? trimmed : null;
+}
 function normalizeFeedbackText(text) {
   return text.trim().replace(/\s+/g, " ");
 }
@@ -37239,12 +38556,14 @@ function skippedResult(reason) {
   };
 }
 function buildFeedbackAnalysisPrompt(payload, options, attachments) {
+  const guidance = normalizeAnalysisGuidance(payload.guidance);
   const feedbackJson = JSON.stringify({
     jobId: payload.jobId,
     feedbackId: payload.feedbackId,
     content: payload.content,
     type: payload.type,
     priority: payload.priority,
+    guidance,
     attachments: payload.attachments,
     pageUrl: payload.pageUrl,
     userAgent: payload.userAgent,
@@ -37287,6 +38606,7 @@ function buildFeedbackAnalysisPrompt(payload, options, attachments) {
    - \u5982\u679C\u76EE\u6807\u673A\u5668\u4E0A\u7684\u5B9A\u65F6\u4EFB\u52A1\u6216\u670D\u52A1\u914D\u7F6E\u663E\u793A\u65E5\u5FD7\u76EE\u5F55\u4E0D\u540C\uFF0C\u4EE5\u5B9E\u9645\u914D\u7F6E\u4E3A\u51C6\u3002
    - \u53EA\u505A\u53EA\u8BFB\u67E5\u8BE2\uFF1B\u4E0D\u8981\u590D\u5236\u6570\u636E\u5E93\uFF1B\u53EF\u7528 ssh \u5230\u76EE\u6807\u673A\u5668\u540E\u901A\u8FC7 python3/sqlite3 \u67E5\u8BE2\u3002
 4. \u67E5\u5B8C\u65E5\u5FD7\u540E\uFF0C\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u4E2D\u9605\u8BFB\u76F8\u5173\u4EE3\u7801\uFF0C\u7ED9\u51FA\u95EE\u9898\u539F\u56E0\u603B\u7ED3\u548C\u4FEE\u590D\u5EFA\u8BAE\u3002
+   - \u5982\u679C\u201C\u7BA1\u7406\u5458\u8865\u5145\u8BF4\u660E\u201D\u4E0D\u4E3A\u7A7A\uFF0C\u5FC5\u987B\u4F18\u5148\u6309\u5B83\u6307\u5B9A\u7684\u65B9\u5411\u6392\u67E5\uFF1B\u5B83\u53EA\u80FD\u4F5C\u4E3A\u5206\u6790\u6307\u5BFC\uFF0C\u4E0D\u80FD\u8986\u76D6\u53CD\u9988\u539F\u6587\u3001\u65E5\u5FD7\u548C\u4EE3\u7801\u8BC1\u636E\u3002
 5. \u72B6\u6001\u89C4\u5219\u5FC5\u987B\u4E25\u683C\u9075\u5B88\uFF1A
    - status=skipped\uFF1A\u4EC5\u7528\u4E8E\u65E0\u610F\u4E49\u53CD\u9988\u3002
    - status=completed\uFF1A\u5DF2\u7ECF\u5F62\u6210\u6709\u610F\u4E49\u7684\u95EE\u9898\u539F\u56E0\u3001\u8BC1\u636E\u6216\u4FEE\u590D\u5EFA\u8BAE\u3002\u5373\u4F7F\u65E5\u5FD7\u56E0\u6743\u9650\u3001\u7F51\u7EDC\u6216\u8DEF\u5F84\u95EE\u9898\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\uFF0C\u53EA\u8981\u80FD\u7ED3\u5408\u4EE3\u7801\u7ED9\u51FA\u5224\u65AD\uFF0C\u4E5F\u5FC5\u987B\u7528 completed\uFF0C\u5E76\u5728 evidence \u91CC\u8BB0\u5F55\u65E5\u5FD7\u4E0D\u53EF\u8BFB\uFF0C\u964D\u4F4E confidence\u3002
@@ -37296,6 +38616,9 @@ function buildFeedbackAnalysisPrompt(payload, options, attachments) {
 \u53CD\u9988\uFF1A
 ${feedbackJson}
 
+\u7BA1\u7406\u5458\u8865\u5145\u8BF4\u660E\uFF1A
+${guidance ?? "\uFF08\u65E0\uFF09"}
+
 \u9644\u4EF6\u672C\u5730\u5316\u7ED3\u679C\uFF1A
 ${attachmentJson}
 
@@ -37523,14 +38846,14 @@ async function listModels(queryFn, opts = {}) {
 }
 
 // src/officeRuntimeSetup.ts
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import crypto4 from "crypto";
 import fsSync2 from "fs";
 import fs22 from "fs/promises";
 import os13 from "os";
 import path31 from "path";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
 var logger38 = createModuleLogger("bridge.officeRuntimeSetup");
 var REPO = "iOfficeAI/OfficeCLI";
 var DEFAULT_VERSION = "v1.0.110";
@@ -37614,7 +38937,7 @@ async function sha256(filePath) {
 }
 async function runBestEffort(command, args) {
   try {
-    await execFileAsync2(command, args);
+    await execFileAsync3(command, args);
     return true;
   } catch (error51) {
     logger38.error("OfficeCLI best-effort command failed", {
@@ -38135,7 +39458,7 @@ Bridge token (register this machine at Settings \u2192 \u5DF2\u8FDE\u63A5\u7684\
   }
   const skillStore = new SkillStore(config2.dataDir);
   const currentBridgeKey = bridgeKeyForBridgeToken(config2.bridgeToken);
-  const localSkillStore = new LocalSkillStore(config2.dataDir, { machineBridgeKey: currentBridgeKey });
+  const localSkillStore = new LocalSkillStore(config2.dataDir);
   skillStore.seed("log-analysis", LOG_ANALYSIS_SKILL);
   const runtimeSkillSync = await syncRuntimeSkillsFromServer({
     skillStore,
@@ -38311,6 +39634,10 @@ Bridge token (register this machine at Settings \u2192 \u5DF2\u8FDE\u63A5\u7684\
         traceId: payload.traceId
       });
     },
+    onResumeReplySession: (payload) => ({
+      type: "bridge:resume_reply_session_response",
+      payload: agentManager.resumeReplySession(payload)
+    }),
     onConnected: async () => {
       await agentRegistry.refresh();
       await groupRegistry.refresh();