duclaw-cli 3.0.0 → 3.0.1

package/dist/sdk/duclaw.js

@@ -39840,11 +39840,13 @@ var init_langsmith = __esm({
 // src/sdk/duclaw.ts
 var duclaw_exports = {};
 __export(duclaw_exports, {
+  createAgent: () => createAgent,
   createDefaultToolHookPlugins: () => createDefaultToolHookPlugins,
   createDefaultTools: () => createDefaultTools,
   createDuclawTools: () => createDuclawTools,
   duclawPreset: () => duclawPreset,
-  getDefaultAgentConfig: () => getDefaultAgentConfig
+  getDefaultAgentConfig: () => getDefaultAgentConfig,
+  getDefaultDuclawAgentConfig: () => getDefaultAgentConfig
 });
 module.exports = __toCommonJS(duclaw_exports);
 
@@ -50431,6 +50433,11 @@ var imageBase64 = (data, mediaType = "image/png") => ({
     data
   }
 });
+var toolResult = (toolUseId, content) => ({
+  type: "tool_result",
+  tool_use_id: toolUseId,
+  content
+});
 var userMessage = (...content) => ({
   role: "user",
   content: content.map((block) => {
@@ -50440,9 +50447,14 @@ var userMessage = (...content) => ({
     return block;
   })
 });
+var assistantMessage = (...content) => ({
+  role: "assistant",
+  content
+});
 
 // src/types/guards.ts
 var isTextBlock = (block) => block.type === `text`;
+var isToolUseBlock = (block) => block.type === "tool_use";
 var extractText = (blocks) => blocks.filter(isTextBlock).map((b) => b.text).join("\n");
 
 // src/tools/tools/ImageUnderstandMetering.ts
@@ -51719,6 +51731,46 @@ var recordAgentEvent = (input) => {
     `).get(input.type, input.source, input.sourceId);
   return rowToEvent(row);
 };
+var listPendingAgentEvents = (userId, limit = 10) => {
+  const db2 = createSqliteDB();
+  const rows = db2.prepare(`
+        SELECT
+            id,
+            user_id as userId,
+            type,
+            source,
+            source_id as sourceId,
+            status,
+            payload_json as payloadJson,
+            created_at as createdAt,
+            injected_at as injectedAt,
+            handled_at as handledAt,
+            updated_at as updatedAt
+        FROM agent_events
+        WHERE user_id = ?
+          AND status IN ('pending', 'processing')
+        ORDER BY created_at ASC
+        LIMIT ?
+    `).all(userId, limit);
+  return rows.map(rowToEvent);
+};
+var markAgentEventsInjected = (eventIds) => {
+  if (eventIds.length === 0) return;
+  const db2 = createSqliteDB();
+  const now = Date.now();
+  const stmt = db2.prepare(`
+        UPDATE agent_events
+        SET status = CASE WHEN status = 'pending' THEN 'processing' ELSE status END,
+            injected_at = COALESCE(injected_at, ?),
+            updated_at = ?
+        WHERE id = ?
+          AND status IN ('pending', 'processing')
+    `);
+  const tx = db2.transaction((ids) => {
+    for (const id of ids) stmt.run(now, now, id);
+  });
+  tx(eventIds);
+};
 var markAgentEventsHandled = (eventIds, status = "handled") => {
   if (eventIds.length === 0) return;
   const db2 = createSqliteDB();
@@ -51757,6 +51809,42 @@ var listAgentEventsByIds = (eventIds) => {
     `);
   return eventIds.map((id) => stmt.get(id)).filter((row) => Boolean(row)).map(rowToEvent);
 };
+var renderAgentEventReminder = (events) => {
+  if (events.length === 0) return "";
+  const lines = events.map((event) => {
+    const owner = typeof event.payload.ownerMailboxId === "string" ? event.payload.ownerMailboxId : void 0;
+    const mailboxMessageId = typeof event.payload.mailboxMessageId === "string" ? event.payload.mailboxMessageId : event.sourceId;
+    const summary = typeof event.payload.summary === "string" ? event.payload.summary : typeof event.payload.contentPreview === "string" ? event.payload.contentPreview : "";
+    return [
+      `- eventId=${event.id}`,
+      `type=${event.type}`,
+      owner ? `owner=${owner}` : "",
+      mailboxMessageId ? `mailboxMessageId=${mailboxMessageId}` : "",
+      summary ? `summary=${summary}` : ""
+    ].filter(Boolean).join(" ");
+  }).join("\n");
+  const hasCeoFollowup = events.some((event) => event.type === "ceo.followup_required");
+  const ceoFollowupInstruction = hasCeoFollowup ? [
+    ``,
+    `\u5176\u4E2D type=ceo.followup_required \u7684\u4E8B\u4EF6\uFF0C\u662F\u56E2\u961F\u5DF2\u7ECF\u628A\u7ED3\u679C\u56DE\u5230\u4E86\u4F60\u8FD9\u91CC\u2014\u2014\u8001\u677F\u8FD8\u5728\u7B49\u4F60\u628A\u8FD9\u4E9B\u7ED3\u679C\u8F6C\u8FBE\u7ED9\u4ED6\u3002`,
+    `\u8BFB\u4E00\u904D\uFF0C\u7528\u4F60\u81EA\u5DF1\u7684\u8BDD\u7ED9\u8001\u677F\u6C47\u62A5\u4E00\u6B21\uFF1A\u6709\u591A\u6761\u5C31\u5408\u5E76\u6210\u4E00\u6761\u8BF4\u6E05\u695A\uFF0C\u522B\u4E00\u6761\u4E8B\u4EF6\u56DE\u4E00\u53E5\u3001\u628A\u540C\u4E00\u4EF6\u4E8B\u91CD\u590D\u53D1\u7ED9\u8001\u677F\u3002`,
+    `\u5982\u679C\u7ED3\u679C\u8BF4\u660E\u4E8B\u60C5\u8FD8\u6CA1\u505A\u5B8C\u6216\u5361\u4F4F\u4E86\uFF0C\u5C31\u5982\u5B9E\u8FD9\u4E48\u8BB2\uFF0C\u800C\u4E0D\u662F\u542B\u7CCA\u5730\u201C\u7A0D\u540E\u540C\u6B65\u201D\u3002`
+  ].join("\n") : "";
+  const hasManagerMailboxMessage = events.some((event) => event.type === "manager.mailbox_message");
+  const managerMailboxInstruction = hasManagerMailboxMessage ? [
+    ``,
+    `\u5176\u4E2D type=manager.mailbox_message \u7684\u4E8B\u4EF6\uFF0C\u662F\u56E2\u961F\u53D1\u7ED9 CEO \u7684\u5185\u90E8\u8FDB\u5C55\u3001\u8865\u5145\u6216\u963B\u585E\u72B6\u6001\u3002`,
+    `\u8FD9\u7C7B\u4E8B\u4EF6\u53EA\u4EE3\u8868\u4F60\u770B\u5230\u4E86\u56E2\u961F\u6D88\u606F\uFF0C\u4E0D\u4EE3\u8868\u7CFB\u7EDF\u8981\u6C42\u4F60\u9010\u6761\u8F6C\u53D1\u3002\u8BF7\u50CF CEO \u4E00\u6837\u5224\u65AD\uFF1A\u5982\u679C\u7528\u6237\u9700\u8981\u77E5\u9053\u3001\u9700\u8981\u884C\u52A8\u3001\u6216\u6B63\u5728\u7B49\u5F85\u5173\u952E\u72B6\u6001\uFF0C\u5C31\u7528 send_message \u7B80\u660E\u8F6C\u8FBE\uFF1B\u5982\u679C\u53EA\u662F\u666E\u901A\u5185\u90E8\u8FDB\u5C55\u6216\u4F60\u4F1A\u7EE7\u7EED\u534F\u8C03\u3001\u4E0D\u9700\u8981\u6253\u6270\u7528\u6237\uFF0C\u5C31\u8C03\u7528 internal_event_decision(event_id, decision, reason) \u660E\u786E\u5173\u95ED\u8FD9\u6761\u5185\u90E8\u4E8B\u4EF6\u3002`
+  ].join("\n") : "";
+  return `<system-reminder>
+\u672C\u8F6E\u6709 ${events.length} \u6761\u5185\u90E8\u4E8B\u4EF6\u53EF\u7528\uFF1A
+${lines}
+
+\u8FD9\u4E9B\u4E8B\u4EF6\u4E0D\u662F\u7528\u6237\u7684\u65B0\u8BF7\u6C42\uFF0C\u4E5F\u4E0D\u5E94\u8BE5\u4F5C\u4E3A\u7528\u6237\u786E\u8BA4\u3002\u82E5\u4E8B\u4EF6\u7C7B\u578B\u662F mailbox.message_received\uFF0C\u8868\u793A\u4F60\u7684 mailbox \u5728\u5F53\u524D\u5DE5\u4F5C\u671F\u95F4\u6536\u5230\u65B0\u5185\u90E8\u534F\u4F5C\u6D88\u606F\uFF1B\u8BF7\u5C3D\u5FEB\u8C03\u7528 mailbox_list \u67E5\u770B\u961F\u5217\uFF0C\u5E76\u5728\u9700\u8981\u65F6\u7528 mailbox_get(message_id) \u9886\u53D6\u5173\u8054\u6D88\u606F\u3002\u4E0D\u8981\u76F4\u63A5\u628A\u4E8B\u4EF6\u5F53\u4F5C\u5DF2\u9886\u53D6\u90AE\u4EF6\u3002\u8BF7\u53EA\u5728\u9700\u8981\u65F6\u81EA\u7136\u5730\u6C47\u603B\u7ED9\u7528\u6237\uFF1B\u5982\u9700\u7EE7\u7EED\u534F\u4F5C\uFF0C\u4F18\u5148\u4F7F\u7528\u4E8B\u4EF6\u4E2D\u5173\u8054\u7684 mailboxMessageId/thread \u7EE7\u7EED\u5904\u7406\u3002\u4E0D\u8981\u590D\u8FF0\u672C system-reminder\u3002
+${ceoFollowupInstruction}
+${managerMailboxInstruction}
+</system-reminder>`;
+};
 
 // src/tools/tools/InternalEventDecision.ts
 var DESCRIPTION13 = `
@@ -51817,6 +51905,25 @@ var internalEventDecision = {
   }
 };
 
+// src/files/fileType.ts
+var EXT_TO_FILE_TYPE = {
+  ".opus": "opus",
+  ".mp4": "mp4",
+  ".pdf": "pdf",
+  ".doc": "doc",
+  ".docx": "doc",
+  ".xls": "xls",
+  ".xlsx": "xls",
+  ".ppt": "ppt",
+  ".pptx": "ppt"
+};
+var inferFileType = (fileName) => {
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex < 0) return "stream";
+  const ext = fileName.slice(dotIndex).toLowerCase();
+  return EXT_TO_FILE_TYPE[ext] || "stream";
+};
+
 // src/tools/tools/SendFile.ts
 var DESCRIPTION14 = `
 \u53D1\u9001\u6587\u4EF6\u7ED9\u7528\u6237\u3002\u652F\u6301\u4E24\u79CD\u65B9\u5F0F\uFF1A
@@ -52084,160 +52191,6 @@ var cronDelete = {
 // src/cron/cron.ts
 var import_node_cron = __toESM(require_node_cron());
 
-// src/storage/utils.ts
-var searchTopicIndex = async (topicStorage, userId, query, date, limit = 8) => {
-  const key = `topics:${userId}`;
-  const data = await topicStorage.get(key) || [];
-  let candidates = date ? data.filter((e) => e.d === date) : data;
-  const tokens = query.toLowerCase().split(/[\s,，。！？!?、:：]+/).filter((t) => t.length > 0);
-  const scored = candidates.map((entry) => {
-    const text2 = entry.s.toLowerCase();
-    const score = tokens.reduce((acc, token) => acc + (text2.includes(token) ? 1 : 0), 0);
-    return { entry, score };
-  }).filter((s) => s.score > 0);
-  scored.sort((a, b) => b.score - a.score || data.indexOf(b.entry) - data.indexOf(a.entry));
-  return {
-    entries: scored.slice(0, Math.min(limit, 15)).map((s) => s.entry),
-    total: data.length
-  };
-};
-var searchChatHistory = async (messageStorage, topicStorage, userId, query, date, limit = 8, contextRadius = 2) => {
-  const { entries: matches, total } = await searchTopicIndex(
-    topicStorage,
-    userId,
-    query,
-    date,
-    limit
-  );
-  if (matches.length === 0) {
-    return { matches: [], total, matchCount: 0 };
-  }
-  const keyCache = /* @__PURE__ */ new Map();
-  const buildKey2 = (d, c) => {
-    let k = `mem:${userId}:${d}`;
-    if (c) k += `:${c}`;
-    return k;
-  };
-  const loadMessages = async (d, c) => {
-    const k = buildKey2(d, c);
-    if (keyCache.has(k)) return keyCache.get(k);
-    const msgs = await messageStorage.get(k);
-    keyCache.set(k, msgs);
-    return msgs;
-  };
-  const results = [];
-  for (const match of matches) {
-    const messages = await loadMessages(match.d, match.c);
-    if (!messages) continue;
-    const from = Math.max(0, match.i - contextRadius);
-    const to = Math.min(messages.length - 1, match.i + contextRadius);
-    const snippets = [];
-    for (let j = from; j <= to; j++) {
-      const msg = messages[j];
-      if (!msg) continue;
-      const textContent = msg.content.filter((b) => b.type === "text").map((b) => b.text).join(" ").slice(0, 200);
-      if (textContent) {
-        snippets.push({
-          index: j,
-          role: msg.role,
-          text: textContent,
-          isMatch: j === match.i
-        });
-      }
-    }
-    if (snippets.length > 0) {
-      results.push({
-        date: match.d,
-        cronTitle: match.c,
-        snippets
-      });
-    }
-  }
-  return { matches: results, total, matchCount: matches.length };
-};
-
-// src/agent/interruptRegistry.ts
-var registry = /* @__PURE__ */ new Map();
-var hasRunningAgent = (userId) => {
-  return registry.has(userId);
-};
-var queueInterrupt = (userId, message) => {
-  const entry = registry.get(userId);
-  if (!entry) return false;
-  const interruptMessage = typeof message === "string" ? { content: message } : message;
-  entry.messages.push(interruptMessage);
-  console.log(`[interrupt] \u7528\u6237 ${userId} \u65B0\u6D88\u606F\u5DF2\u5165\u961F\uFF0C\u5F53\u524D\u961F\u5217\u957F\u5EA6: ${entry.messages.length}`);
-  for (const listener of entry.listeners) {
-    try {
-      listener();
-    } catch (err) {
-      console.warn(`[interrupt] \u7528\u6237 ${userId} \u4E2D\u65AD\u76D1\u542C\u5668\u6267\u884C\u5931\u8D25: ${err.message}`);
-    }
-  }
-  return true;
-};
-
-// src/recall/recallIndex.ts
-var buildRecallIndexKey = (userId) => `recall:index:${userId}`;
-var normalize = (value) => value.toLowerCase();
-var tokenizeRecallText = (value) => normalize(value).split(/[\s,，。！？!?、:：;；()[\]{}<>'"`/\\|+=*_#@~-]+/).map((token) => token.trim()).filter((token) => token.length > 0);
-var extractRecallKeywords = (value, limit = 12) => {
-  const seen = /* @__PURE__ */ new Set();
-  const keywords = [];
-  for (const token of tokenizeRecallText(value)) {
-    if (seen.has(token)) continue;
-    seen.add(token);
-    keywords.push(token);
-    if (keywords.length >= limit) break;
-  }
-  return keywords;
-};
-var upsertRecallIndexEntry = async (storage, entry) => {
-  const key = buildRecallIndexKey(entry.userId);
-  const entries = await storage.get(key) || [];
-  const index = entries.findIndex((item) => item.id === entry.id && item.type === entry.type);
-  if (index >= 0) {
-    entries[index] = entry;
-  } else {
-    entries.push(entry);
-  }
-  await storage.set(key, entries);
-};
-var removeRecallIndexEntry = async (storage, userId, type, id) => {
-  const key = buildRecallIndexKey(userId);
-  const entries = await storage.get(key) || [];
-  const next = entries.filter((entry) => !(entry.type === type && entry.id === id));
-  await storage.set(key, next);
-};
-var searchRecallIndex = async (storage, userId, query, date, limit = 8) => {
-  const entries = await storage.get(buildRecallIndexKey(userId)) || [];
-  const candidates = date ? entries.filter((entry) => entry.date === date) : entries;
-  const tokens = tokenizeRecallText(query);
-  const scored = candidates.map((entry) => {
-    const haystack = normalize([
-      entry.type,
-      entry.title,
-      entry.summary,
-      entry.keywords.join(" "),
-      entry.date
-    ].join("\n"));
-    const score = tokens.reduce((acc, token) => {
-      if (!token) return acc;
-      if (entry.keywords.some((keyword) => normalize(keyword) === token)) return acc + 3;
-      if (haystack.includes(token)) return acc + 1;
-      return acc;
-    }, 0);
-    return { entry, score };
-  }).filter((match) => match.score > 0);
-  scored.sort(
-    (a, b) => b.score - a.score || b.entry.createdAt - a.entry.createdAt
-  );
-  return {
-    matches: scored.slice(0, Math.min(limit, 15)),
-    total: entries.length
-  };
-};
-
 // src/tasks/goal.ts
 var import_dayjs2 = __toESM(require_dayjs_min());
 var import_utc2 = __toESM(require_utc());
@@ -52389,13 +52342,13 @@ var updateGoal = (id, goal) => {
       (t) => t.status === "pending" || t.status === "in_progress"
     );
     if (unfinished.length > 0) {
-      const preview = unfinished.slice(0, 5).map((t) => `  - [${t.status}] ${t.id} ${t.subject}`).join("\n");
+      const preview2 = unfinished.slice(0, 5).map((t) => `  - [${t.status}] ${t.id} ${t.subject}`).join("\n");
       const more = unfinished.length > 5 ? `
   ... \u8FD8\u6709 ${unfinished.length - 5} \u4E2A\u672A\u5217\u51FA` : "";
       throw new GoalCompletionBlockedError(
         `[UpdateGoal] \u65E0\u6CD5\u5C06 goal=${id} \u7F6E\u4E3A completed\uFF1A\u4ECD\u6709 ${unfinished.length} \u4E2A\u5B50\u4EFB\u52A1\u5904\u4E8E pending/in_progress\u3002\u8BF7\u5148\u901A\u8FC7 task_update \u5C06\u5B83\u4EEC\u6807\u8BB0\u4E3A completed \u6216 failed\uFF0C\u518D\u5173\u95ED goal\u3002
 \u672A\u5B8C\u6210\u5B50\u4EFB\u52A1\uFF1A
-${preview}${more}`
+${preview2}${more}`
       );
     }
   }
@@ -52822,6 +52775,58 @@ ${replies}`;
 // src/department/mailbox/mailbox.ts
 var import_node_crypto11 = require("node:crypto");
 
+// src/agent/interruptRegistry.ts
+var registry = /* @__PURE__ */ new Map();
+var markRunning = (userId) => {
+  const current = registry.get(userId);
+  if (current) {
+    current.startedAt = Date.now();
+    current.cancelled = false;
+    return;
+  }
+  registry.set(userId, { messages: [], startedAt: Date.now(), cancelled: false, listeners: /* @__PURE__ */ new Set() });
+};
+var markDone = (userId) => {
+  registry.delete(userId);
+};
+var hasRunningAgent = (userId) => {
+  return registry.has(userId);
+};
+var isCancellationRequested = (userId) => {
+  return registry.get(userId)?.cancelled === true;
+};
+var queueInterrupt = (userId, message) => {
+  const entry = registry.get(userId);
+  if (!entry) return false;
+  const interruptMessage = typeof message === "string" ? { content: message } : message;
+  entry.messages.push(interruptMessage);
+  console.log(`[interrupt] \u7528\u6237 ${userId} \u65B0\u6D88\u606F\u5DF2\u5165\u961F\uFF0C\u5F53\u524D\u961F\u5217\u957F\u5EA6: ${entry.messages.length}`);
+  for (const listener of entry.listeners) {
+    try {
+      listener();
+    } catch (err) {
+      console.warn(`[interrupt] \u7528\u6237 ${userId} \u4E2D\u65AD\u76D1\u542C\u5668\u6267\u884C\u5931\u8D25: ${err.message}`);
+    }
+  }
+  return true;
+};
+var registerInterruptListener = (userId, listener) => {
+  const entry = registry.get(userId);
+  if (!entry) return () => void 0;
+  entry.listeners.add(listener);
+  return () => {
+    entry.listeners.delete(listener);
+  };
+};
+var drainInterrupts = (userId) => {
+  const entry = registry.get(userId);
+  if (!entry || entry.messages.length === 0) return [];
+  const messages = [...entry.messages];
+  entry.messages.length = 0;
+  console.log(`[interrupt] \u7528\u6237 ${userId} drain ${messages.length} \u6761\u4E2D\u65AD\u6D88\u606F`);
+  return messages;
+};
+
 // src/department/mailbox/events.ts
 var import_node_crypto9 = require("node:crypto");
 var recordMailboxEvent = (input) => {
@@ -55000,36 +55005,405 @@ var createDuclawTools = (bg, options = []) => {
 };
 var createDefaultTools = createDuclawTools;
 
-// src/tools/tools/RecallChatHistory.ts
-var DESCRIPTION34 = `\u641C\u7D22\u7528\u6237\u7684\u5386\u53F2\u804A\u5929\u8BB0\u5F55\u3001compact \u6458\u8981\u3001dream \u957F\u671F\u8BB0\u5FC6\u548C\u663E\u5F0F\u957F\u671F memory\u3002\u5F53\u7528\u6237\u63D0\u5230\u8FC7\u53BB\u7684\u5BF9\u8BDD\u3001\u4E4B\u524D\u7684\u8BF7\u6C42\u3001\u4E0A\u6B21\u4EFB\u52A1\u3001\u6216\u4F60\u9700\u8981\u56DE\u5FC6\u65E9\u671F\u4EA4\u4E92\u5185\u5BB9\u65F6\u4F7F\u7528\u3002
-
-\u4F7F\u7528\u6307\u5357\uFF1A
-- query \u5FC5\u987B\u5177\u4F53\uFF0C\u5305\u542B\u5173\u952E\u8BCD\uFF08\u5982\u6587\u4EF6\u540D\u3001\u529F\u80FD\u540D\u3001\u4E3B\u9898\u8BCD\uFF09
-- \u901A\u5E38\u53EA\u9700\u8C03\u7528 1 \u6B21\u5373\u53EF\u627E\u5230\u76EE\u6807\uFF0C\u907F\u514D\u53CD\u590D\u8C03\u7528\u6D6A\u8D39\u4E0A\u4E0B\u6587
-- \u5982\u679C\u77E5\u9053\u5927\u6982\u65E5\u671F\uFF0C\u8BF7\u63D0\u4F9B date \u53C2\u6570\u7F29\u5C0F\u8303\u56F4
-- \u8FD4\u56DE\u7684\u662F\u5339\u914D\u6458\u8981\u548C\u4E0A\u4E0B\u6587\u7247\u6BB5\uFF0C\u4E0D\u662F\u5B8C\u6574\u5BF9\u8BDD
-`;
-var OUTPUT_LIMIT = 3e3;
-var formatRecallResult = (result, indexResult) => {
-  const indexMatches = indexResult?.matches ?? [];
-  if (result.matchCount === 0 && indexMatches.length === 0) {
-    const indexTotal = indexResult?.total ?? 0;
-    return `\u672A\u627E\u5230\u5339\u914D\u7ED3\u679C\uFF08topic \u7D22\u5F15 ${result.total} \u6761\uFF0Csummary \u7D22\u5F15 ${indexTotal} \u6761\uFF09\u3002\u5C1D\u8BD5\u4F7F\u7528\u4E0D\u540C\u7684\u5173\u952E\u8BCD\u3002`;
+// src/storage/utils.ts
+var buildMessageKey = (userId, date, cronTitle) => {
+  let key = `mem:${userId}`;
+  if (date) {
+    key = key + `:${date}`;
+  }
+  if (cronTitle) {
+    key = key + `:${cronTitle}`;
+  }
+  return key;
+};
+var getMessages = async (storage, userId, limit = 300, date, cronTitle) => {
+  const key = buildMessageKey(userId, date, cronTitle);
+  const data = await storage.get(key);
+  if (!data) return [];
+  const repair = sanitizeMessagesWithReport(data, {
+    mergeAdjacentNonProtocolMessages: false
+  });
+  const repairedData = repair.messages;
+  if (repair.report.changed) {
+    await storage.set(key, repairedData);
+    logSanitizeRepair(repair.report);
+  }
+  if (repairedData.length === 0) return [];
+  let start = Math.max(0, repairedData.length - limit);
+  if (repairedData[start].role !== "user") {
+    let earlier = start - 1;
+    while (earlier >= 0 && repairedData[earlier].role !== "user") earlier--;
+    if (earlier >= 0) {
+      start = earlier;
+    } else {
+      let later = start + 1;
+      while (later < repairedData.length && repairedData[later].role !== "user") later++;
+      if (later >= repairedData.length) return [];
+      start = later;
+    }
+  }
+  return sanitizeMessages(repairedData.slice(start));
+};
+var isInjectedMemoryContextMessage = (msg) => {
+  if (msg.role !== "user" || msg.content.length === 0) return false;
+  if (!msg.content.every((block) => block.type === "text")) return false;
+  const textContent2 = msg.content.map((block) => block.type === "text" ? block.text : "").join("\n").trim();
+  return textContent2.startsWith("<memory-context>") && textContent2.endsWith("</memory-context>");
+};
+var hasProtocolBlock = (msg) => {
+  return msg.content.some((block) => block.type === "tool_use" || block.type === "tool_result");
+};
+var createSanitizeReport = () => ({
+  changed: false,
+  removedToolUses: 0,
+  removedToolResults: 0,
+  removedEmptyMessages: 0,
+  removedMemoryContextMessages: 0,
+  droppedMessages: 0,
+  shiftedLeadingMessages: 0,
+  mergedAdjacentMessages: 0
+});
+var markSanitizeChanged = (report, index) => {
+  report.changed = true;
+  if (report.firstChangedIndex === void 0 || index < report.firstChangedIndex) {
+    report.firstChangedIndex = index;
+  }
+};
+var mergeSanitizeReport = (target, source) => {
+  if (!source.changed) return;
+  target.changed = true;
+  if (source.firstChangedIndex !== void 0 && (target.firstChangedIndex === void 0 || source.firstChangedIndex < target.firstChangedIndex)) {
+    target.firstChangedIndex = source.firstChangedIndex;
+  }
+  target.removedToolUses += source.removedToolUses;
+  target.removedToolResults += source.removedToolResults;
+  target.removedEmptyMessages += source.removedEmptyMessages;
+  target.removedMemoryContextMessages += source.removedMemoryContextMessages;
+  target.droppedMessages += source.droppedMessages;
+  target.shiftedLeadingMessages += source.shiftedLeadingMessages;
+  target.mergedAdjacentMessages += source.mergedAdjacentMessages;
+};
+var stripToolResultBlocks = (msg, report, index) => {
+  const removed = msg.content.filter((block) => block.type === "tool_result").length;
+  const content = msg.content.filter((block) => block.type !== "tool_result");
+  if (report && removed > 0 && index !== void 0) {
+    report.removedToolResults += removed;
+    markSanitizeChanged(report, index);
   }
-  let output = `\u5339\u914D ${result.matchCount + indexMatches.length} \u6761\u7ED3\u679C\uFF08topic \u7D22\u5F15 ${result.total} \u6761\uFF0Csummary \u7D22\u5F15 ${indexResult?.total ?? 0} \u6761\uFF09:
-`;
-  for (const match of indexMatches) {
-    if (output.length >= OUTPUT_LIMIT) {
-      output += `
-...(\u5DF2\u8FBE\u8F93\u51FA\u4E0A\u9650\uFF0C\u5269\u4F59\u7ED3\u679C\u7701\u7565)`;
-      break;
-    }
-    const entry = match.entry;
-    output += `
---- ${entry.type} ${entry.date} score=${match.score} ---
-`;
-    output += `\u6807\u9898\uFF1A${entry.title}
-`;
+  if (content.length === 0) return null;
+  if (content.every((b) => b.type === "text" && !b.text?.trim())) return null;
+  return { ...msg, content };
+};
+var stripToolUseBlocks = (msg, report, index) => {
+  const removed = msg.content.filter((block) => block.type === "tool_use").length;
+  const content = msg.content.filter((block) => block.type !== "tool_use");
+  if (report && removed > 0 && index !== void 0) {
+    report.removedToolUses += removed;
+    markSanitizeChanged(report, index);
+  }
+  if (content.length === 0) return null;
+  if (content.every((b) => b.type === "text" && !b.text?.trim())) return null;
+  return { ...msg, content };
+};
+var recordDroppedMessage = (report, index) => {
+  report.droppedMessages++;
+  markSanitizeChanged(report, index);
+};
+var logSanitizeRepair = (report) => {
+  console.warn(
+    `[sanitize] repaired message history removedToolUses=${report.removedToolUses} removedToolResults=${report.removedToolResults} droppedMessages=${report.droppedMessages} emptyMessages=${report.removedEmptyMessages} memoryContextMessages=${report.removedMemoryContextMessages} shiftedLeadingMessages=${report.shiftedLeadingMessages} firstIndex=${report.firstChangedIndex ?? -1}`
+  );
+};
+var sanitizeMessagesWithReport = (messages, options = {}) => {
+  const report = createSanitizeReport();
+  const mergeAdjacentNonProtocolMessages2 = options.mergeAdjacentNonProtocolMessages ?? true;
+  if (messages.length === 0) {
+    return { messages, report };
+  }
+  const result = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (isInjectedMemoryContextMessage(msg)) {
+      report.removedMemoryContextMessages++;
+      recordDroppedMessage(report, i);
+      continue;
+    }
+    if (!msg.content || msg.content.length === 0) {
+      report.removedEmptyMessages++;
+      recordDroppedMessage(report, i);
+      continue;
+    }
+    if (msg.content.every((b) => b.type === "text" && !b.text?.trim())) {
+      report.removedEmptyMessages++;
+      recordDroppedMessage(report, i);
+      continue;
+    }
+    let nextMsg = msg;
+    if (msg.role === "assistant") {
+      const toolUses = msg.content.filter((b) => b.type === "tool_use");
+      if (toolUses.length > 0) {
+        const next = messages[i + 1];
+        if (!next || next.role !== "user") {
+          nextMsg = stripToolUseBlocks(msg, report, i);
+          if (!nextMsg) {
+            recordDroppedMessage(report, i);
+            continue;
+          }
+        } else {
+          const resultIds = new Set(
+            next.content.filter((b) => b.type === "tool_result").map((b) => b.tool_use_id)
+          );
+          const allMatched = toolUses.every((tu) => resultIds.has(tu.id));
+          if (!allMatched) {
+            nextMsg = stripToolUseBlocks(msg, report, i);
+            if (!nextMsg) {
+              recordDroppedMessage(report, i);
+              continue;
+            }
+          }
+        }
+      }
+    }
+    if (nextMsg.role === "user") {
+      const toolResults = nextMsg.content.filter((b) => b.type === "tool_result");
+      if (toolResults.length > 0) {
+        const prev2 = result[result.length - 1];
+        const prevToolUseIds = new Set(
+          prev2?.role === "assistant" ? prev2.content.filter((b) => b.type === "tool_use").map((b) => b.id) : []
+        );
+        const allResultsMatched = toolResults.every((tr) => prevToolUseIds.has(tr.tool_use_id));
+        if (!prev2 || prev2.role !== "assistant" || prevToolUseIds.size === 0 || !allResultsMatched) {
+          nextMsg = stripToolResultBlocks(nextMsg, report, i);
+          if (!nextMsg) {
+            recordDroppedMessage(report, i);
+            continue;
+          }
+        }
+      }
+    }
+    const prev = result[result.length - 1];
+    if (mergeAdjacentNonProtocolMessages2 && prev && prev.role === nextMsg.role && !hasProtocolBlock(prev) && !hasProtocolBlock(nextMsg)) {
+      prev.content = [...prev.content, ...nextMsg.content];
+      report.mergedAdjacentMessages++;
+      markSanitizeChanged(report, i);
+    } else {
+      result.push({ ...nextMsg, content: [...nextMsg.content] });
+    }
+  }
+  while (result.length > 0 && result[0].role !== "user") {
+    result.shift();
+    report.shiftedLeadingMessages++;
+    markSanitizeChanged(report, 0);
+  }
+  if (report.shiftedLeadingMessages > 0) {
+    const revalidated = sanitizeMessagesWithReport(result, options);
+    if (revalidated.report.changed) {
+      mergeSanitizeReport(report, revalidated.report);
+      return { messages: revalidated.messages, report };
+    }
+  }
+  return { messages: result, report };
+};
+var sanitizeMessages = (messages) => {
+  return sanitizeMessagesWithReport(messages).messages;
+};
+var addMessage = async (storage, userId, message, date, cronTitle) => {
+  const key = buildMessageKey(userId, date, cronTitle);
+  const data = await storage.get(key) || [];
+  data.push(message);
+  await storage.set(key, data);
+  return data.length - 1;
+};
+var addTopicIndex = async (storage, userId, date, messageIndex, snippet, cronTitle) => {
+  const key = `topics:${userId}`;
+  const data = await storage.get(key) || [];
+  data.push({
+    d: date,
+    i: messageIndex,
+    s: snippet.slice(0, 80),
+    ...cronTitle ? { c: cronTitle } : {}
+  });
+  await storage.set(key, data);
+};
+var updateTopicSummary = async (storage, userId, date, summary, cronTitle) => {
+  const key = `topics:${userId}`;
+  const data = await storage.get(key);
+  if (!data || data.length === 0) return;
+  for (let i = data.length - 1; i >= 0; i--) {
+    const entry = data[i];
+    if (entry.d === date && (entry.c || void 0) === (cronTitle || void 0)) {
+      entry.s = summary.slice(0, 80);
+      await storage.set(key, data);
+      return;
+    }
+  }
+};
+var searchTopicIndex = async (topicStorage, userId, query, date, limit = 8) => {
+  const key = `topics:${userId}`;
+  const data = await topicStorage.get(key) || [];
+  let candidates = date ? data.filter((e) => e.d === date) : data;
+  const tokens = query.toLowerCase().split(/[\s,，。！？!?、:：]+/).filter((t) => t.length > 0);
+  const scored = candidates.map((entry) => {
+    const text2 = entry.s.toLowerCase();
+    const score = tokens.reduce((acc, token) => acc + (text2.includes(token) ? 1 : 0), 0);
+    return { entry, score };
+  }).filter((s) => s.score > 0);
+  scored.sort((a, b) => b.score - a.score || data.indexOf(b.entry) - data.indexOf(a.entry));
+  return {
+    entries: scored.slice(0, Math.min(limit, 15)).map((s) => s.entry),
+    total: data.length
+  };
+};
+var searchChatHistory = async (messageStorage, topicStorage, userId, query, date, limit = 8, contextRadius = 2) => {
+  const { entries: matches, total } = await searchTopicIndex(
+    topicStorage,
+    userId,
+    query,
+    date,
+    limit
+  );
+  if (matches.length === 0) {
+    return { matches: [], total, matchCount: 0 };
+  }
+  const keyCache = /* @__PURE__ */ new Map();
+  const buildKey2 = (d, c) => {
+    let k = `mem:${userId}:${d}`;
+    if (c) k += `:${c}`;
+    return k;
+  };
+  const loadMessages = async (d, c) => {
+    const k = buildKey2(d, c);
+    if (keyCache.has(k)) return keyCache.get(k);
+    const msgs = await messageStorage.get(k);
+    keyCache.set(k, msgs);
+    return msgs;
+  };
+  const results = [];
+  for (const match of matches) {
+    const messages = await loadMessages(match.d, match.c);
+    if (!messages) continue;
+    const from = Math.max(0, match.i - contextRadius);
+    const to = Math.min(messages.length - 1, match.i + contextRadius);
+    const snippets = [];
+    for (let j = from; j <= to; j++) {
+      const msg = messages[j];
+      if (!msg) continue;
+      const textContent2 = msg.content.filter((b) => b.type === "text").map((b) => b.text).join(" ").slice(0, 200);
+      if (textContent2) {
+        snippets.push({
+          index: j,
+          role: msg.role,
+          text: textContent2,
+          isMatch: j === match.i
+        });
+      }
+    }
+    if (snippets.length > 0) {
+      results.push({
+        date: match.d,
+        cronTitle: match.c,
+        snippets
+      });
+    }
+  }
+  return { matches: results, total, matchCount: matches.length };
+};
+var clearMessages = async (storage, userId, date, cronTitle) => {
+  const key = buildMessageKey(userId, date, cronTitle);
+  await storage.del(key);
+};
+
+// src/recall/recallIndex.ts
+var buildRecallIndexKey = (userId) => `recall:index:${userId}`;
+var normalize = (value) => value.toLowerCase();
+var tokenizeRecallText = (value) => normalize(value).split(/[\s,，。！？!?、:：;；()[\]{}<>'"`/\\|+=*_#@~-]+/).map((token) => token.trim()).filter((token) => token.length > 0);
+var extractRecallKeywords = (value, limit = 12) => {
+  const seen = /* @__PURE__ */ new Set();
+  const keywords = [];
+  for (const token of tokenizeRecallText(value)) {
+    if (seen.has(token)) continue;
+    seen.add(token);
+    keywords.push(token);
+    if (keywords.length >= limit) break;
+  }
+  return keywords;
+};
+var upsertRecallIndexEntry = async (storage, entry) => {
+  const key = buildRecallIndexKey(entry.userId);
+  const entries = await storage.get(key) || [];
+  const index = entries.findIndex((item) => item.id === entry.id && item.type === entry.type);
+  if (index >= 0) {
+    entries[index] = entry;
+  } else {
+    entries.push(entry);
+  }
+  await storage.set(key, entries);
+};
+var removeRecallIndexEntry = async (storage, userId, type, id) => {
+  const key = buildRecallIndexKey(userId);
+  const entries = await storage.get(key) || [];
+  const next = entries.filter((entry) => !(entry.type === type && entry.id === id));
+  await storage.set(key, next);
+};
+var searchRecallIndex = async (storage, userId, query, date, limit = 8) => {
+  const entries = await storage.get(buildRecallIndexKey(userId)) || [];
+  const candidates = date ? entries.filter((entry) => entry.date === date) : entries;
+  const tokens = tokenizeRecallText(query);
+  const scored = candidates.map((entry) => {
+    const haystack = normalize([
+      entry.type,
+      entry.title,
+      entry.summary,
+      entry.keywords.join(" "),
+      entry.date
+    ].join("\n"));
+    const score = tokens.reduce((acc, token) => {
+      if (!token) return acc;
+      if (entry.keywords.some((keyword) => normalize(keyword) === token)) return acc + 3;
+      if (haystack.includes(token)) return acc + 1;
+      return acc;
+    }, 0);
+    return { entry, score };
+  }).filter((match) => match.score > 0);
+  scored.sort(
+    (a, b) => b.score - a.score || b.entry.createdAt - a.entry.createdAt
+  );
+  return {
+    matches: scored.slice(0, Math.min(limit, 15)),
+    total: entries.length
+  };
+};
+
+// src/tools/tools/RecallChatHistory.ts
+var DESCRIPTION34 = `\u641C\u7D22\u7528\u6237\u7684\u5386\u53F2\u804A\u5929\u8BB0\u5F55\u3001compact \u6458\u8981\u3001dream \u957F\u671F\u8BB0\u5FC6\u548C\u663E\u5F0F\u957F\u671F memory\u3002\u5F53\u7528\u6237\u63D0\u5230\u8FC7\u53BB\u7684\u5BF9\u8BDD\u3001\u4E4B\u524D\u7684\u8BF7\u6C42\u3001\u4E0A\u6B21\u4EFB\u52A1\u3001\u6216\u4F60\u9700\u8981\u56DE\u5FC6\u65E9\u671F\u4EA4\u4E92\u5185\u5BB9\u65F6\u4F7F\u7528\u3002
+
+\u4F7F\u7528\u6307\u5357\uFF1A
+- query \u5FC5\u987B\u5177\u4F53\uFF0C\u5305\u542B\u5173\u952E\u8BCD\uFF08\u5982\u6587\u4EF6\u540D\u3001\u529F\u80FD\u540D\u3001\u4E3B\u9898\u8BCD\uFF09
+- \u901A\u5E38\u53EA\u9700\u8C03\u7528 1 \u6B21\u5373\u53EF\u627E\u5230\u76EE\u6807\uFF0C\u907F\u514D\u53CD\u590D\u8C03\u7528\u6D6A\u8D39\u4E0A\u4E0B\u6587
+- \u5982\u679C\u77E5\u9053\u5927\u6982\u65E5\u671F\uFF0C\u8BF7\u63D0\u4F9B date \u53C2\u6570\u7F29\u5C0F\u8303\u56F4
+- \u8FD4\u56DE\u7684\u662F\u5339\u914D\u6458\u8981\u548C\u4E0A\u4E0B\u6587\u7247\u6BB5\uFF0C\u4E0D\u662F\u5B8C\u6574\u5BF9\u8BDD
+`;
+var OUTPUT_LIMIT = 3e3;
+var formatRecallResult = (result, indexResult) => {
+  const indexMatches = indexResult?.matches ?? [];
+  if (result.matchCount === 0 && indexMatches.length === 0) {
+    const indexTotal = indexResult?.total ?? 0;
+    return `\u672A\u627E\u5230\u5339\u914D\u7ED3\u679C\uFF08topic \u7D22\u5F15 ${result.total} \u6761\uFF0Csummary \u7D22\u5F15 ${indexTotal} \u6761\uFF09\u3002\u5C1D\u8BD5\u4F7F\u7528\u4E0D\u540C\u7684\u5173\u952E\u8BCD\u3002`;
+  }
+  let output = `\u5339\u914D ${result.matchCount + indexMatches.length} \u6761\u7ED3\u679C\uFF08topic \u7D22\u5F15 ${result.total} \u6761\uFF0Csummary \u7D22\u5F15 ${indexResult?.total ?? 0} \u6761\uFF09:
+`;
+  for (const match of indexMatches) {
+    if (output.length >= OUTPUT_LIMIT) {
+      output += `
+...(\u5DF2\u8FBE\u8F93\u51FA\u4E0A\u9650\uFF0C\u5269\u4F59\u7ED3\u679C\u7701\u7565)`;
+      break;
+    }
+    const entry = match.entry;
+    output += `
+--- ${entry.type} ${entry.date} score=${match.score} ---
+`;
+    output += `\u6807\u9898\uFF1A${entry.title}
+`;
     output += `\u6458\u8981\uFF1A${entry.summary.slice(0, 800)}
 `;
     if (entry.keywords.length > 0) {
@@ -56881,11 +57255,1290 @@ var duclawPreset = () => {
     hooks: config2.hooks
   };
 };
+
+// src/agent/createAgentCore.ts
+var import_node_crypto18 = require("node:crypto");
+
+// src/compact/config.ts
+var readNumber = (name, fallback) => {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var readBoolean = (name, fallback) => {
+  const raw = process.env[name];
+  if (raw === void 0) return fallback;
+  return !["0", "false", "no", "off"].includes(raw.trim().toLowerCase());
+};
+var getCompactConfig = () => ({
+  enabled: readBoolean("COMPACT_ENABLED", true),
+  contextWindowTokens: readNumber("COMPACT_CONTEXT_WINDOW_TOKENS", 2e5),
+  outputReserveTokens: readNumber("COMPACT_OUTPUT_RESERVE_TOKENS", 2e4),
+  bufferTokens: readNumber("COMPACT_BUFFER_TOKENS", 0),
+  warningBufferTokens: readNumber("COMPACT_WARNING_BUFFER_TOKENS", 2e4),
+  hotTailMessages: readNumber("COMPACT_HOT_TAIL_MESSAGES", 24),
+  compactUserMessageMaxTokens: readNumber("COMPACT_USER_MESSAGE_MAX_TOKENS", 2e4),
+  maxFailures: readNumber("COMPACT_MAX_FAILURES", 3),
+  microCompactKeepToolResults: readNumber("MICRO_COMPACT_KEEP_TOOL_RESULTS", 5),
+  microCompactToolResultChars: readNumber("MICRO_COMPACT_TOOL_RESULT_CHARS", 1200)
+});
+var getEffectiveContextWindow = (config2) => Math.max(1, config2.contextWindowTokens - config2.outputReserveTokens);
+var getCompactThreshold = (config2) => Math.max(1, getEffectiveContextWindow(config2) - config2.bufferTokens);
+var getWarningThreshold = (config2) => Math.max(1, getEffectiveContextWindow(config2) - config2.warningBufferTokens);
+var calculateCompactTokenState = (currentContextTokens, config2) => {
+  const warningThreshold = getWarningThreshold(config2);
+  const compactThreshold = getCompactThreshold(config2);
+  return {
+    currentContextTokens,
+    warningThreshold,
+    compactThreshold,
+    isAboveWarningThreshold: currentContextTokens >= warningThreshold,
+    isAboveCompactThreshold: currentContextTokens >= compactThreshold
+  };
+};
+
+// src/compact/errors.ts
+var PROMPT_TOO_LONG_PATTERNS = [
+  "prompt_too_long",
+  "context_length_exceeded",
+  "context window",
+  "context_window",
+  "maximum context length",
+  "max context length",
+  "model_context_window_exceeded",
+  "too many tokens",
+  "input is too long"
+];
+var collectErrorText = (error) => {
+  const err = error;
+  const parts = [
+    err?.message,
+    err?.status ? String(err.status) : "",
+    err?.error ? JSON.stringify(err.error) : "",
+    err?.response ? JSON.stringify(err.response) : ""
+  ];
+  return parts.filter(Boolean).join("\n").toLowerCase();
+};
+var isPromptTooLongError = (error) => {
+  const text2 = collectErrorText(error);
+  if (!text2) return false;
+  return PROMPT_TOO_LONG_PATTERNS.some((pattern) => text2.includes(pattern));
+};
+
+// src/compact/tokenEstimate.ts
+var IMAGE_MAX_TOKEN_SIZE = 2e3;
+var roughTokenEstimateText = (content, bytesPerToken = 4) => {
+  if (!content) return 0;
+  return Math.ceil(content.length / bytesPerToken);
+};
+var stringify = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+};
+var tokenCountFromUsage = (usage) => usage.inputTokens + usage.outputTokens + (usage.cacheCreationInputTokens ?? 0) + (usage.cacheReadInputTokens ?? 0);
+var roughTokenEstimateBlock = (block) => {
+  switch (block.type) {
+    case "text":
+      return roughTokenEstimateText(block.text);
+    case "tool_result":
+      return roughTokenEstimateText(block.content);
+    case "tool_use": {
+      const toolUse = block;
+      return roughTokenEstimateText(toolUse.name + stringify(toolUse.input ?? {}));
+    }
+    case "image":
+      return IMAGE_MAX_TOKEN_SIZE;
+    case "thinking":
+      return roughTokenEstimateText(block.thinking);
+    default:
+      return roughTokenEstimateText(stringify(block));
+  }
+};
+var roughTokenEstimateMessages = (messages) => {
+  let total = 0;
+  for (const message of messages) {
+    for (const block of message.content) {
+      total += roughTokenEstimateBlock(block);
+    }
+  }
+  return Math.ceil(total * (4 / 3));
+};
+var findLastAssistantUsageAnchor = (messages) => {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role === "assistant" && message.usage) {
+      let anchorIndex = i;
+      if (message.providerResponseId) {
+        for (let j = i - 1; j >= 0; j--) {
+          const prior = messages[j];
+          if (prior?.role === "assistant" && prior.providerResponseId === message.providerResponseId) {
+            anchorIndex = j;
+            continue;
+          }
+          if (prior?.role === "assistant" && prior.providerResponseId && prior.providerResponseId !== message.providerResponseId) {
+            break;
+          }
+        }
+      }
+      return { index: anchorIndex, usage: message.usage };
+    }
+  }
+  return null;
+};
+var tokenCountWithEstimation = (messages, systemPrompt = "") => {
+  const anchor = findLastAssistantUsageAnchor(messages);
+  if (!anchor) {
+    return {
+      tokens: roughTokenEstimateMessages(messages) + roughTokenEstimateText(systemPrompt),
+      source: "rough_fallback"
+    };
+  }
+  return {
+    tokens: tokenCountFromUsage(anchor.usage) + roughTokenEstimateMessages(messages.slice(anchor.index + 1)),
+    source: "api_usage_plus_delta"
+  };
+};
+
+// src/compact/compactPrompt.ts
+var COMPACT_SUMMARIZATION_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
+
+The summary must be concise, factual, and directly useful for continuing the work. Do not invent missing details. Clearly separate confirmed facts from assumptions or items that still need verification.
+
+Use this exact schema:
+
+<compact-summary>
+1. \u7528\u6237\u6700\u65B0\u76EE\u6807:
+2. \u7528\u6237\u786C\u6027\u7EA6\u675F:
+3. \u5F53\u524D\u4E8B\u5B9E\u72B6\u6001:
+4. \u5DF2\u5B8C\u6210\u52A8\u4F5C:
+5. \u6587\u4EF6/\u547D\u4EE4/\u8BC1\u636E:
+6. mailbox/department \u7EBF\u7A0B:
+7. \u7528\u6237\u53EF\u89C1\u627F\u8BFA:
+8. \u672A\u5B8C\u6210\u4E8B\u9879:
+9. \u5F53\u524D\u963B\u585E\u4E0E\u7B49\u5F85\u5BF9\u8C61:
+10. \u4E0B\u4E00\u6B65\u5FC5\u987B\u52A8\u4F5C:
+11. \u4E0D\u786E\u5B9A/\u5F85\u786E\u8BA4:
+12. \u5DF2\u4E22\u5F03\u4FE1\u606F:
+</compact-summary>
+
+Field guidance:
+- \u7528\u6237\u6700\u65B0\u76EE\u6807: the latest user intent, not stale earlier goals.
+- \u7528\u6237\u786C\u6027\u7EA6\u675F: explicit user constraints, safety boundaries, deployment/data-persistence constraints, style preferences, or "do not" instructions.
+- \u5F53\u524D\u4E8B\u5B9E\u72B6\u6001: verified state only. Say "\u65E0" if there is no verified fact.
+- \u5DF2\u5B8C\u6210\u52A8\u4F5C: concrete actions already performed by the agent or team.
+- \u6587\u4EF6/\u547D\u4EE4/\u8BC1\u636E: important paths, commands, test results, errors, URLs, versions, sandbox IDs, mailbox IDs, and other evidence required to continue.
+- mailbox/department \u7EBF\u7A0B: responsible owner, mailbox thread/message IDs, CEO followups, department head/executor status, who owes a reply to whom, and whether the user-visible closure is complete.
+- \u7528\u6237\u53EF\u89C1\u627F\u8BFA: what the user has been told or promised, including pending follow-ups.
+- \u672A\u5B8C\u6210\u4E8B\u9879: work still not done.
+- \u5F53\u524D\u963B\u585E\u4E0E\u7B49\u5F85\u5BF9\u8C61: blockers, external waits, running commands, pending approvals, or a named agent/person/system being waited on.
+- \u4E0B\u4E00\u6B65\u5FC5\u987B\u52A8\u4F5C: the minimal next actions the next LLM should take, in order.
+- \u4E0D\u786E\u5B9A/\u5F85\u786E\u8BA4: assumptions, ambiguous facts, or things that must be re-checked.
+- \u5DF2\u4E22\u5F03\u4FE1\u606F: categories of old details intentionally omitted, such as long logs, obsolete failed attempts, or completed transient steps.
+
+If a field does not apply, write "\u65E0".`;
+var COMPACT_SUMMARY_PREFIX = `Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:`;
+var COMPACT_SYSTEM_PROMPT = `You are Duclaw's context compaction worker. Produce only the requested handoff summary. Do not call tools and do not chat with the user.`;
+var buildCompactUserPrompt = (_messages, reason) => `${COMPACT_SUMMARIZATION_PROMPT}
+
+Compaction trigger: ${reason}`;
+
+// src/compact/CompactEngine.ts
+var buildCompactSummaryKey = (userId, date, cronTitle) => `compact:summary:${userId}:${date}${cronTitle ? `:${cronTitle}` : ""}`;
+var extractSummaryText = (message) => message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+var stripAssistantUsage = (message) => {
+  if (message.role !== "assistant") return { ...message, content: [...message.content] };
+  return {
+    role: "assistant",
+    content: [...message.content]
+  };
+};
+var textContent = (message) => message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+var isSummaryUserMessage = (message) => message.role === "user" && textContent(message).startsWith(COMPACT_SUMMARY_PREFIX);
+var isRawTextUserMessage = (message) => message.role === "user" && message.content.length > 0 && message.content.every((block) => block.type === "text") && !isSummaryUserMessage(message);
+var collectRecentUserMessages = (messages, maxTokens) => {
+  if (maxTokens <= 0) return [];
+  const selected = [];
+  let usedTokens = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || !isRawTextUserMessage(message)) continue;
+    const messageTokens = roughTokenEstimateText(textContent(message));
+    if (selected.length > 0 && usedTokens + messageTokens > maxTokens) break;
+    if (messageTokens > maxTokens && selected.length === 0) continue;
+    selected.push({ role: "user", content: [...message.content] });
+    usedTokens += messageTokens;
+  }
+  return selected.reverse();
+};
+var buildCompactionRequestMessages = (messages, reason) => sanitizeMessagesWithReport([
+  ...messages.map(stripAssistantUsage),
+  userMessage(text(buildCompactUserPrompt(messages, reason)))
+], { mergeAdjacentNonProtocolMessages: false }).messages;
+var CompactEngine = class {
+  storage;
+  summaryStorage;
+  recallIndexStorage;
+  llm;
+  config;
+  constructor(options) {
+    this.storage = options.storage;
+    this.summaryStorage = options.summaryStorage;
+    this.recallIndexStorage = options.recallIndexStorage;
+    this.llm = options.llm;
+    this.config = options.config;
+  }
+  async compact(input) {
+    const sourceMessages = sanitizeMessages(input.messages);
+    if (sourceMessages.length === 0) {
+      throw new Error("[compact] \u6CA1\u6709\u53EF\u538B\u7F29\u7684\u6D88\u606F\u5386\u53F2");
+    }
+    const tokenCountBefore = tokenCountWithEstimation(sourceMessages, input.systemPrompt);
+    const response = await this.llm.chat(
+      buildCompactionRequestMessages(sourceMessages, input.reason),
+      COMPACT_SYSTEM_PROMPT,
+      []
+    );
+    const rawSummary = extractSummaryText(response);
+    if (!rawSummary) {
+      throw new Error("[compact] compact LLM \u6CA1\u6709\u8FD4\u56DE\u6458\u8981\u6587\u672C");
+    }
+    const summary = `${COMPACT_SUMMARY_PREFIX}
+${rawSummary}`.trim();
+    const recentUserMessages = collectRecentUserMessages(sourceMessages, this.config.compactUserMessageMaxTokens);
+    const compactedMessages = sanitizeMessagesWithReport([
+      ...recentUserMessages,
+      userMessage(text(summary))
+    ], { mergeAdjacentNonProtocolMessages: false }).messages;
+    if (compactedMessages.length === 0) {
+      throw new Error("[compact] compact \u540E\u6CA1\u6709\u53EF\u5199\u56DE\u7684\u5408\u6CD5\u6D88\u606F");
+    }
+    const record2 = {
+      id: `compact_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+      userId: input.userId,
+      date: input.date,
+      ...input.cronTitle ? { cronTitle: input.cronTitle } : {},
+      ...input.threadId ? { threadId: input.threadId } : {},
+      summary,
+      sourceMessageCount: sourceMessages.length,
+      hotTailCount: recentUserMessages.length,
+      contextTokensBefore: tokenCountBefore.tokens,
+      contextTokensAfter: roughTokenEstimateMessages(compactedMessages),
+      tokenCountSource: tokenCountBefore.source,
+      reason: input.reason,
+      createdAt: Date.now()
+    };
+    await this.storage.set(buildMessageKey(input.userId, input.date, input.cronTitle), compactedMessages);
+    await this.appendSummaryRecord(record2);
+    await this.upsertRecallIndex(record2);
+    return {
+      record: record2,
+      messages: compactedMessages.length
+    };
+  }
+  async upsertRecallIndex(record2) {
+    if (!this.recallIndexStorage) return;
+    await upsertRecallIndexEntry(this.recallIndexStorage, {
+      id: record2.id,
+      userId: record2.userId,
+      type: "compact",
+      title: `compact ${record2.date}${record2.cronTitle ? ` ${record2.cronTitle}` : ""}`,
+      summary: record2.summary,
+      keywords: extractRecallKeywords(record2.summary),
+      date: record2.date,
+      sourceKey: buildCompactSummaryKey(record2.userId, record2.date, record2.cronTitle),
+      createdAt: record2.createdAt
+    });
+  }
+  async appendSummaryRecord(record2) {
+    if (!this.summaryStorage) return;
+    const key = buildCompactSummaryKey(record2.userId, record2.date, record2.cronTitle);
+    const records = await this.summaryStorage.get(key) || [];
+    records.push(record2);
+    await this.summaryStorage.set(key, records);
+  }
+};
+
+// src/compact/microCompact.ts
+var COMPACTED_MARKER = "[\u65E7\u5DE5\u5177\u7ED3\u679C\u5DF2\u538B\u7F29]";
+var stringify2 = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+};
+var preview = (content, maxChars) => {
+  const trimmed = content.trim();
+  if (trimmed.length <= maxChars) return trimmed;
+  const half = Math.max(80, Math.floor(maxChars / 2));
+  return `${trimmed.slice(0, half)}
+...
+${trimmed.slice(-half)}`;
+};
+var toolUseMapFromMessages = (messages) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    for (const block of message.content) {
+      if (block.type === "tool_use") {
+        map.set(block.id, block);
+      }
+    }
+  }
+  return map;
+};
+var collectToolResults = (messages) => {
+  const locations = [];
+  messages.forEach((message, messageIndex) => {
+    if (message.role !== "user") return;
+    message.content.forEach((block, blockIndex) => {
+      if (block.type === "tool_result") {
+        locations.push({ messageIndex, blockIndex, block });
+      }
+    });
+  });
+  return locations;
+};
+var stripAssistantUsage2 = (message) => {
+  if (message.role !== "assistant") return message;
+  return {
+    role: "assistant",
+    content: message.content
+  };
+};
+var buildCompactedToolResultContent = (block, toolUse, maxChars) => {
+  const toolName = toolUse?.name ?? "unknown";
+  const toolInput = toolUse ? stringify2(toolUse.input) : "{}";
+  const previewChars = Math.max(200, Math.floor(maxChars * 0.6));
+  return `${COMPACTED_MARKER}
+\u5DE5\u5177: ${toolName}
+tool_use_id: ${block.tool_use_id}
+\u539F\u59CB\u957F\u5EA6: ${block.content.length} chars
+\u5DE5\u5177\u8F93\u5165: ${toolInput.slice(0, 300)}
+\u6458\u8981: ${preview(block.content, previewChars)}
+\u8BF4\u660E: \u5B8C\u6574\u65E7\u5DE5\u5177\u7ED3\u679C\u672A\u4FDD\u5B58\uFF1B\u5982\u9700\u7EC6\u8282\u8BF7\u91CD\u65B0\u8FD0\u884C\u5BF9\u5E94\u5DE5\u5177\u6216\u4F9D\u8D56\u540E\u7EED compact summary\u3002`;
+};
+var microCompactMessages = (messages, config2) => {
+  const sanitized = sanitizeMessages(messages.map((message) => ({
+    ...message,
+    content: [...message.content]
+  })));
+  const toolResults = collectToolResults(sanitized);
+  const keepFromIndex = Math.max(0, toolResults.length - config2.microCompactKeepToolResults);
+  const toolUses = toolUseMapFromMessages(sanitized);
+  let compactedToolResults = 0;
+  let originalCharsRemoved = 0;
+  const nextMessages = sanitized.map((message) => ({
+    ...message,
+    content: [...message.content]
+  }));
+  for (let i = 0; i < keepFromIndex; i++) {
+    const location = toolResults[i];
+    if (location.block.content.startsWith(COMPACTED_MARKER)) continue;
+    if (location.block.content.length <= config2.microCompactToolResultChars) continue;
+    const compactedContent = buildCompactedToolResultContent(
+      location.block,
+      toolUses.get(location.block.tool_use_id),
+      config2.microCompactToolResultChars
+    );
+    const message = nextMessages[location.messageIndex];
+    message.content[location.blockIndex] = {
+      ...location.block,
+      content: compactedContent
+    };
+    compactedToolResults++;
+    originalCharsRemoved += Math.max(0, location.block.content.length - compactedContent.length);
+  }
+  if (compactedToolResults === 0) {
+    return {
+      messages: sanitized,
+      changed: false,
+      compactedToolResults,
+      originalCharsRemoved
+    };
+  }
+  return {
+    messages: sanitizeMessages(nextMessages.map(stripAssistantUsage2)),
+    changed: true,
+    compactedToolResults,
+    originalCharsRemoved
+  };
+};
+
+// src/agent/createAgentCore.ts
+var assistantMessageFromResponse = (response) => ({
+  role: "assistant",
+  content: response.content,
+  ...response.usage ? { usage: response.usage } : {},
+  ...response.providerResponseId ? { providerResponseId: response.providerResponseId } : {},
+  ...response.model ? { model: response.model } : {}
+});
+var isAbortError2 = (error) => {
+  if (!(error instanceof Error)) return false;
+  return error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("AbortError");
+};
+var llmRequestIdForTurn = (request, messages, system, tools) => {
+  const hash = (0, import_node_crypto18.createHash)("sha256").update(request.requestId).update("\0").update(system).update("\0").update(JSON.stringify(messages)).update("\0").update(JSON.stringify(tools.map((tool) => tool.name).sort())).digest("hex").slice(0, 40);
+  return `dreq_${hash}`;
+};
+var LLM_CREDIT_EXHAUSTED_MESSAGE = "Credit \u4F59\u989D\u4E0D\u8DB3\uFF0C\u6682\u65F6\u65E0\u6CD5\u7EE7\u7EED\u8C03\u7528\u4E3B\u6A21\u578B\u5904\u7406\u8FD9\u6761\u6D88\u606F\u3002\u8BF7\u5148\u5145\u503C\u6216\u4F7F\u7528\u6FC0\u6D3B\u7801\u589E\u52A0 Credit \u540E\u518D\u8BD5\u3002";
+var isLlmCreditExhaustedError = (error) => {
+  const err = error;
+  const message = [
+    err?.message,
+    err?.error?.type,
+    err?.error?.message
+  ].filter((value) => typeof value === "string").join("\n");
+  return err?.status === 402 || err?.status === 403 && /预扣费额度失败|额度不足|剩余额度|pre_consume.*quota|insufficient.*quota/i.test(message) || /预扣费额度失败|用户剩余额度|Credit balance is insufficient|credit_exhausted/i.test(message);
+};
+var traceMetadataFromRequest = (request, internalOnly) => ({
+  platform: request.platform,
+  userId: request.userId,
+  requestId: request.requestId,
+  departmentAgentId: request.departmentAgentId,
+  trigger: request.metadata?.trigger,
+  internalOnly,
+  jobTitle: request.job?.title,
+  eventId: request.metadata?.eventId,
+  agentEventIds: request.metadata?.agentEventIds,
+  ceoFollowupId: request.metadata?.ceoFollowupId,
+  ceoFollowupIds: request.metadata?.ceoFollowupIds,
+  mailboxMessageId: request.metadata?.mailboxMessageId,
+  threadId: request.metadata?.threadId,
+  parentMessageId: request.metadata?.parentMessageId,
+  workItemId: request.metadata?.workItemId
+});
+var genericTraceIdentity = (request) => {
+  return {
+    name: `Agent turn`,
+    role: `agent`,
+    mailboxId: request.departmentAgentId || void 0
+  };
+};
+var createAgent2 = (config2) => {
+  const { systemPrompt, llm, storage, topicStorage, compactSummaryStorage, recallIndexStorage, toolExecutor, tools, backgroundManager, maxIterations = 50, dreamEngine, skillForgeEngine, memoryEngine, onLlmRequestId, tracer } = config2;
+  const signals = /* @__PURE__ */ new Map();
+  return async (initialRequest) => {
+    let request = initialRequest;
+    if (config2.workspacePath && !request.defaultWorkDir) {
+      request.defaultWorkDir = config2.workspacePath;
+    }
+    request = await config2.hooks?.beforeRun?.(request) ?? request;
+    const { userId, job } = request;
+    const content = await config2.hooks?.augmentUserContent?.({
+      request,
+      content: request.content
+    }) ?? request.content;
+    const internalOnly = request.metadata?.internalOnly === true;
+    let rootTrace;
+    let agentTrace;
+    const requestForTrace = () => ({
+      ...request,
+      content,
+      traceRun: request.traceRun ? { id: request.traceRun.id } : void 0
+    });
+    const finish = async (result) => {
+      await agentTrace?.end({ outputs: result });
+      await rootTrace?.end({ outputs: result });
+      await config2.hooks?.afterRun?.({ request, result });
+      return result;
+    };
+    const traceOutboundText = async (to, message, send) => {
+      const outboundTrace = await agentTrace?.child({
+        name: `Outbound message`,
+        runType: `tool`,
+        inputs: {
+          to,
+          text: message,
+          metadata: request.metadata
+        },
+        metadata: traceMetadataFromRequest(request, internalOnly)
+      });
+      try {
+        await send();
+        await outboundTrace?.end({ outputs: { sent: true } });
+      } catch (error) {
+        await outboundTrace?.end({ error: error.message });
+        throw error;
+      }
+    };
+    const traceOutboundFile = async (to, fileName, fileType, file, send) => {
+      const outboundTrace = await agentTrace?.child({
+        name: `Outbound file`,
+        runType: `tool`,
+        inputs: {
+          to,
+          fileName,
+          fileType,
+          file
+        },
+        metadata: traceMetadataFromRequest(request, internalOnly)
+      });
+      try {
+        await send();
+        await outboundTrace?.end({ outputs: { sent: true } });
+      } catch (error) {
+        await outboundTrace?.end({ error: error.message });
+        throw error;
+      }
+    };
+    const injectedEventIds = /* @__PURE__ */ new Set();
+    const managerMailboxEventIds = /* @__PURE__ */ new Set();
+    const interruptQueuedEventIds = /* @__PURE__ */ new Set();
+    let durableEventPoller;
+    let activeTurnAbortController;
+    let unregisterInterruptListener;
+    const markInterruptEventIdsInjected = (metadata) => {
+      const ids = Array.isArray(metadata?.agentEventIds) ? metadata.agentEventIds.filter((id) => typeof id === "string") : [];
+      if (ids.length === 0) return;
+      for (const id of ids) injectedEventIds.add(id);
+      if (metadata?.trigger === "manager.mailbox_message") {
+        for (const id of ids) managerMailboxEventIds.add(id);
+      }
+      markAgentEventsInjected(ids);
+    };
+    const autoHandledEventIds = (userVisibleSent) => {
+      const ids = [...injectedEventIds];
+      if (userVisibleSent) return ids;
+      return ids.filter((id) => !managerMailboxEventIds.has(id));
+    };
+    const ceoFollowupIdsFromMetadata2 = (metadata) => {
+      const ids = /* @__PURE__ */ new Set();
+      if (typeof metadata?.ceoFollowupId === "string") ids.add(metadata.ceoFollowupId);
+      if (Array.isArray(metadata?.ceoFollowupIds)) {
+        for (const id of metadata.ceoFollowupIds) {
+          if (typeof id === "string") ids.add(id);
+        }
+      }
+      return Array.from(ids);
+    };
+    const rememberCeoFollowupIds = (ids) => {
+      if (ids.length === 0) return;
+      const current = ceoFollowupIdsFromMetadata2(request.metadata);
+      request.metadata = {
+        ...request.metadata ?? {},
+        ceoFollowupIds: Array.from(/* @__PURE__ */ new Set([...current, ...ids]))
+      };
+    };
+    const completeUserVisibleCeoFollowups = async () => {
+      await config2.hooks?.completeUserVisibleDelivery?.({ request });
+    };
+    const claimOutboundText = async (text2, reason) => {
+      return await config2.hooks?.claimOutboundText?.({ request, text: text2, reason }) ?? true;
+    };
+    const claimOutboundFile = async (fileName, file) => {
+      return await config2.hooks?.claimOutboundFile?.({ request, fileName, file }) ?? true;
+    };
+    const queuePendingDurableEvents = () => {
+      try {
+        const events = listPendingAgentEvents(userId, 10).filter((event) => !injectedEventIds.has(event.id)).filter((event) => !interruptQueuedEventIds.has(event.id));
+        if (events.length === 0) return;
+        for (const event of events) interruptQueuedEventIds.add(event.id);
+        queueInterrupt(userId, {
+          content: renderAgentEventReminder(events),
+          metadata: {
+            trigger: "agent_events.pending",
+            agentEventIds: events.map((event) => event.id)
+          }
+        });
+      } catch (err) {
+        console.warn(`[agent_events] durable event poll failed: ${err.message}`);
+      }
+    };
+    const prev = signals.get(userId);
+    if (prev) {
+      prev.abort();
+    }
+    const signal = {
+      aborted: false,
+      abort() {
+        this.aborted = true;
+      }
+    };
+    signals.set(userId, signal);
+    markRunning(userId);
+    unregisterInterruptListener = registerInterruptListener(userId, () => {
+      activeTurnAbortController?.abort();
+    });
+    durableEventPoller = setInterval(queuePendingDurableEvents, 1e3);
+    try {
+      const sessionTraceInput = {
+        name: `Duclaw User Session`,
+        runType: `chain`,
+        inputs: {
+          platform: request.platform,
+          userId: request.userId,
+          requestId: request.requestId,
+          content,
+          request: requestForTrace()
+        },
+        metadata: traceMetadataFromRequest(request, internalOnly)
+      };
+      rootTrace = request.traceRun ? await request.traceRun.child(sessionTraceInput) : await tracer?.startRun(sessionTraceInput);
+      const traceIdentity = await config2.hooks?.traceIdentity?.(request) ?? genericTraceIdentity(request);
+      agentTrace = await rootTrace?.child({
+        name: traceIdentity.name,
+        runType: `chain`,
+        inputs: {
+          request: requestForTrace(),
+          content
+        },
+        metadata: {
+          ...traceMetadataFromRequest(request, internalOnly),
+          agentRole: traceIdentity.role,
+          memberName: traceIdentity.memberName,
+          mailboxId: traceIdentity.mailboxId
+        }
+      });
+      if (dreamEngine) {
+        try {
+          await dreamEngine.checkAndDream(userId);
+        } catch (err) {
+          console.warn(`[agent] checkAndDream \u5931\u8D25\uFF1A${err.message}`);
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      const beijingTime = now.toLocaleString("sv-SE", {
+        timeZone: "Asia/Shanghai",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+      }).replace(/-/g, "");
+      if (!internalOnly) {
+        const msgIndex = await addMessage(storage, userId, userMessage(text(content)), beijingTime, job?.title);
+        if (topicStorage) {
+          await addTopicIndex(topicStorage, userId, beijingTime, msgIndex, content, job?.title);
+        }
+      }
+      if (skillForgeEngine && !internalOnly) {
+        try {
+          const pending = await skillForgeEngine.listPending(userId);
+          if (pending.length > 0) {
+            const lines = pending.map(
+              (p) => `  - id=${p.id} name=${p.skillName} :: ${p.description}`
+            ).join("\n");
+            await addMessage(storage, userId, userMessage(text(
+              `<pending-skill-proposal>
+\u5F53\u524D\u6709 ${pending.length} \u4E2A\u5F85\u7528\u6237\u786E\u8BA4\u7684\u6280\u80FD\u8349\u7A3F\uFF1A
+${lines}
+\u5982\u679C\u7528\u6237\u8FD9\u6761\u6D88\u606F\u662F\u5728\u56DE\u5E94"\u8981\u4E0D\u8981\u4FDD\u7559"\u8FD9\u4E2A\u95EE\u9898\uFF1A
+  \u2022 \u80AF\u5B9A\u610F\u56FE \u2192 \u8C03\u7528 skill_forge_keep\uFF08\u53EA\u6709 1 \u6761 pending \u65F6 proposalId \u53EF\u7701\u7565\uFF09
+  \u2022 \u5426\u5B9A\u610F\u56FE \u2192 \u8C03\u7528 skill_forge_drop
+  \u2022 \u672A\u8868\u6001 \u2192 \u5FFD\u7565\u672C\u63D0\u793A\uFF0C\u6B63\u5E38\u5904\u7406\u7528\u6237\u6D88\u606F
+</pending-skill-proposal>`
+            )), beijingTime, job?.title);
+          }
+        } catch (err) {
+          console.warn(`[skillForge] \u8BFB\u53D6 pending \u5217\u8868\u5931\u8D25\uFF1A${err.message}`);
+        }
+      }
+      let iterations = 0;
+      let hasSentMessage = false;
+      let sentMessageContent = "";
+      let emptyRetries = 0;
+      let contextRecoveryAttempts = 0;
+      let maxIterationCompactions = 0;
+      const compactConfig = getCompactConfig();
+      const compactEngine = new CompactEngine({
+        storage,
+        summaryStorage: compactSummaryStorage,
+        recallIndexStorage,
+        llm,
+        config: compactConfig
+      });
+      const fallbackToDreamRecovery = async (reason) => {
+        contextRecoveryAttempts++;
+        console.warn(`[agent] \u4E0A\u4E0B\u6587\u538B\u7F29\u964D\u7EA7\u89E6\u53D1 reason=${reason} attempt=${contextRecoveryAttempts}`);
+        let overflowWarning = `<system-warning>\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF0C\u5386\u53F2\u5BF9\u8BDD\u5DF2\u88AB\u6E05\u7A7A\u3002\u7531\u4E8E\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u68A6\u5883\u8BB0\u5FC6\uFF0C\u8BF7\u4E0D\u8981\u4F9D\u8D56\u66F4\u65E9\u4E0A\u4E0B\u6587\uFF0C\u53EA\u76F4\u63A5\u5904\u7406\u7528\u6237\u6700\u65B0\u7684\u6D88\u606F\u3002</system-warning>
+${content}`;
+        if (dreamEngine) {
+          try {
+            const result = await dreamEngine.dream(userId);
+            console.log(`[agent] \u5F3A\u5236\u505A\u68A6\u5B8C\u6210\uFF0C\u68A6\u5883\u957F\u5EA6=${result?.dreamContent.length ?? 0}`);
+            if (result?.dreamContent) {
+              overflowWarning = `<system-warning>\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF0C\u5DF2\u901A\u8FC7\u505A\u68A6\u538B\u7F29\u5386\u53F2\u5BF9\u8BDD\u3002\u91CD\u8981\u8BB0\u5FC6\u5DF2\u4FDD\u7559\u81F3\u68A6\u5883\uFF08systemPrompt \u4E2D\u7684 memory-context\uFF09\u3002\u8BF7\u76F4\u63A5\u56DE\u590D\u7528\u6237\u6700\u65B0\u7684\u6D88\u606F\u3002</system-warning>
+${content}`;
+            } else {
+              overflowWarning = `<system-warning>\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF0C\u5DF2\u5C1D\u8BD5\u505A\u68A6\u538B\u7F29\u5386\u53F2\u5BF9\u8BDD\uFF0C\u4F46\u672A\u751F\u6210\u53EF\u7528\u68A6\u5883\u3002\u5386\u53F2\u5BF9\u8BDD\u5DF2\u88AB\u6E05\u7A7A\uFF0C\u8BF7\u4E0D\u8981\u4F9D\u8D56\u66F4\u65E9\u4E0A\u4E0B\u6587\uFF0C\u53EA\u76F4\u63A5\u5904\u7406\u7528\u6237\u6700\u65B0\u7684\u6D88\u606F\u3002</system-warning>
+${content}`;
+            }
+          } catch (err) {
+            console.error(`[agent] \u5F3A\u5236\u505A\u68A6\u5931\u8D25\uFF1A${err.message}`);
+            overflowWarning = `<system-warning>\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF0C\u5DF2\u5C1D\u8BD5\u505A\u68A6\u538B\u7F29\u5386\u53F2\u5BF9\u8BDD\uFF0C\u4F46\u505A\u68A6\u5931\u8D25\u3002\u5386\u53F2\u5BF9\u8BDD\u5DF2\u88AB\u6E05\u7A7A\uFF0C\u8BF7\u4E0D\u8981\u4F9D\u8D56\u66F4\u65E9\u4E0A\u4E0B\u6587\uFF0C\u53EA\u76F4\u63A5\u5904\u7406\u7528\u6237\u6700\u65B0\u7684\u6D88\u606F\u3002</system-warning>
+${content}`;
+          }
+        }
+        await clearMessages(storage, userId, beijingTime, job?.title);
+        await addMessage(storage, userId, userMessage(text(overflowWarning)), beijingTime, job?.title);
+      };
+      const recoverFromContextOverflow = async (reason, messages, effectiveSystemPrompt) => {
+        contextRecoveryAttempts++;
+        try {
+          const result = await compactEngine.compact({
+            userId,
+            date: beijingTime,
+            cronTitle: job?.title,
+            messages,
+            systemPrompt: effectiveSystemPrompt,
+            reason,
+            threadId: request.departmentAgentId || void 0
+          });
+          console.warn(
+            `[compact] \u5B8C\u6574 compact \u6210\u529F reason=${reason} before=${result.record.contextTokensBefore} after=${result.record.contextTokensAfter} messages=${result.messages}`
+          );
+        } catch (err) {
+          console.error(`[compact] \u5B8C\u6574 compact \u5931\u8D25\uFF0C\u8FDB\u5165 dream \u964D\u7EA7\uFF1A${err.message}`);
+          contextRecoveryAttempts--;
+          await fallbackToDreamRecovery(reason);
+        }
+      };
+      const buildEffectiveSystemPrompt = async () => {
+        let memoryInjection = "";
+        if (memoryEngine) {
+          try {
+            memoryInjection = await memoryEngine.buildContextBlock(userId, memoryEngine.ownerFromRequest(request));
+          } catch (err) {
+            console.warn(`[memory] \u6784\u5EFA\u8BB0\u5FC6\u4E0A\u4E0B\u6587\u5931\u8D25\uFF1A${err.message}`);
+          }
+        }
+        const dreamInjection = dreamEngine ? await dreamEngine.injectDream(userId) : "";
+        const systemContext = await config2.hooks?.buildSystemContext?.({ request }) ?? "";
+        return systemPrompt + (systemContext ? `
+
+${systemContext}` : "") + (memoryInjection ? `
+
+${memoryInjection}` : "") + dreamInjection;
+      };
+      while (true) {
+        if (iterations >= maxIterations) {
+          if (compactConfig.enabled && maxIterationCompactions < 1 && contextRecoveryAttempts < compactConfig.maxFailures) {
+            const messages2 = await getMessages(storage, userId, 300, beijingTime, job?.title);
+            await recoverFromContextOverflow(
+              `max_iterations:${maxIterations}`,
+              messages2,
+              await buildEffectiveSystemPrompt()
+            );
+            iterations = 0;
+            emptyRetries = 0;
+            maxIterationCompactions++;
+            continue;
+          }
+          throw new Error(`\u8FBE\u5230\u6700\u5927\u8FED\u4EE3\u6B21\u6570:${maxIterations}`);
+        }
+        if (signal.aborted) throw new Error(`[\u667A\u80FD\u4F53\u4E2D\u65AD] \u53D7\u5230\u4E2D\u65AD\u4FE1\u53F7\u5DF2\u4E2D\u65AD`);
+        if (isCancellationRequested(userId)) throw new Error(`\u7528\u6237\u5DF2\u505C\u6B62\u5F53\u524D\u6267\u884C`);
+        iterations++;
+        if (backgroundManager) {
+          const notifs = backgroundManager.drain();
+          if (notifs.length > 0) {
+            const notifText = notifs.map((n2) => `[bg:${n2.taskId}] ${n2.result}`).join("\n");
+            await addMessage(
+              storage,
+              userId,
+              userMessage(text(`<background-results>
+${notifText}
+</background-results>`)),
+              beijingTime,
+              job?.title
+            );
+            await addMessage(
+              storage,
+              userId,
+              assistantMessage(text("\u6536\u5230\u540E\u53F0\u4EFB\u52A1\u7ED3\u679C\u3002")),
+              beijingTime,
+              job?.title
+            );
+          }
+        }
+        const interrupts = drainInterrupts(userId);
+        if (interrupts.length > 0) {
+          for (const interrupt of interrupts) {
+            markInterruptEventIdsInjected(interrupt.metadata);
+            rememberCeoFollowupIds(ceoFollowupIdsFromMetadata2(interrupt.metadata));
+            const msg = interrupt.content;
+            console.log(`[agent] \u6536\u5230\u4E2D\u65AD\u6D88\u606F\uFF0C\u6CE8\u5165\u5BF9\u8BDD: ${msg.slice(0, 80)}...`);
+            if (interrupt.metadata) {
+              request.metadata = {
+                ...request.metadata ?? {},
+                ...interrupt.metadata
+              };
+            }
+            if (interrupt.metadata?.internalOnly === true) {
+              continue;
+            }
+            const interruptContent = msg.includes("<system_reminder>") || msg.includes("<system-reminder>") ? msg : `<user-interrupt>\u7528\u6237\u53D1\u6765\u4E86\u65B0\u6D88\u606F\uFF0C\u8BF7\u7ACB\u5373\u91CD\u65B0\u8BC4\u4F30\u5F53\u524D\u5DE5\u4F5C\uFF0C\u65B0\u6D88\u606F\u53EF\u80FD\u4F1A\u6539\u53D8\u4F60\u7684\u4EFB\u52A1\u4F18\u5148\u7EA7\u6216\u65B9\u5411\u3002
+${msg}</user-interrupt>`;
+            await addMessage(storage, userId, userMessage(text(
+              interruptContent
+            )), beijingTime, job?.title);
+          }
+        }
+        let messages = await getMessages(storage, userId, 300, beijingTime, job?.title);
+        const pendingEvents = listPendingAgentEvents(userId, 10).filter((event) => !injectedEventIds.has(event.id));
+        const eventReminder = renderAgentEventReminder(pendingEvents);
+        if (pendingEvents.length > 0) {
+          for (const event of pendingEvents) injectedEventIds.add(event.id);
+          for (const event of pendingEvents) {
+            if (event.type === "manager.mailbox_message") managerMailboxEventIds.add(event.id);
+          }
+          markAgentEventsInjected(pendingEvents.map((event) => event.id));
+          rememberCeoFollowupIds(pendingEvents.filter((event) => event.type === "ceo.followup_required").map((event) => event.payload.ceoFollowupId).filter((id) => typeof id === "string"));
+        }
+        if (messages.length === 0 && internalOnly && eventReminder) {
+          messages = [userMessage(text(eventReminder))];
+        } else if (messages.length === 0) {
+          console.warn(`[agent] \u6D88\u606F\u5386\u53F2\u6E05\u6D17\u540E\u4E3A\u7A7A\uFF0C\u4F7F\u7528\u5F53\u524D\u8BF7\u6C42\u91CD\u5EFA\u5BF9\u8BDD userId=${userId}`);
+          await clearMessages(storage, userId, beijingTime, job?.title);
+          await addMessage(storage, userId, userMessage(text(
+            `<system-warning>\u5386\u53F2\u6D88\u606F\u56E0\u5DE5\u5177\u8C03\u7528\u534F\u8BAE\u635F\u574F\u5DF2\u88AB\u6E05\u7A7A\u3002\u8BF7\u4E0D\u8981\u4F9D\u8D56\u66F4\u65E9\u4E0A\u4E0B\u6587\uFF0C\u53EA\u76F4\u63A5\u5904\u7406\u4E0B\u9762\u8FD9\u6761\u6700\u65B0\u8BF7\u6C42\u3002</system-warning>
+${content}`
+          )), beijingTime, job?.title);
+          messages = await getMessages(storage, userId, 300, beijingTime, job?.title);
+        }
+        if (eventReminder && !(messages.length === 1 && internalOnly)) {
+          const last = messages[messages.length - 1];
+          if (last?.role === "user" && !last.content.some((block) => block.type === "tool_result")) {
+            messages = [
+              ...messages.slice(0, -1),
+              {
+                ...last,
+                content: [
+                  ...last.content,
+                  text(eventReminder)
+                ]
+              }
+            ];
+          } else {
+            messages = [...messages, userMessage(text(eventReminder))];
+          }
+        }
+        const systemContext = await config2.hooks?.buildSystemContext?.({ request }) ?? "";
+        const effectiveSystemPrompt = await buildEffectiveSystemPrompt();
+        if (compactConfig.enabled) {
+          let tokenCount = tokenCountWithEstimation(messages, effectiveSystemPrompt);
+          let tokenState = calculateCompactTokenState(tokenCount.tokens, compactConfig);
+          if (tokenState.isAboveWarningThreshold) {
+            console.warn(
+              `[compact] contextTokens=${tokenState.currentContextTokens} warning=${tokenState.warningThreshold} compact=${tokenState.compactThreshold} source=${tokenCount.source}`
+            );
+            const historyKey = buildMessageKey(userId, beijingTime, job?.title);
+            const fullHistory = await storage.get(historyKey) || [];
+            const microResult = microCompactMessages(fullHistory, compactConfig);
+            if (microResult.changed) {
+              await storage.set(historyKey, microResult.messages);
+              messages = await getMessages(storage, userId, 300, beijingTime, job?.title);
+              tokenCount = tokenCountWithEstimation(messages, effectiveSystemPrompt);
+              tokenState = calculateCompactTokenState(tokenCount.tokens, compactConfig);
+              console.warn(
+                `[micro-compact] compactedToolResults=${microResult.compactedToolResults} removedChars=${microResult.originalCharsRemoved} contextTokens=${tokenState.currentContextTokens} source=${tokenCount.source}`
+              );
+            }
+          }
+          if (tokenState.isAboveCompactThreshold) {
+            if (contextRecoveryAttempts >= compactConfig.maxFailures) {
+              throw new Error(`[compact] \u4E0A\u4E0B\u6587\u8D85\u8FC7\u9608\u503C\u4E14\u6062\u590D\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650 (${compactConfig.maxFailures})`);
+            }
+            await recoverFromContextOverflow(`preflight:${tokenState.currentContextTokens}/${tokenState.compactThreshold}`, messages, effectiveSystemPrompt);
+            continue;
+          }
+        }
+        let response;
+        const turnAbortController = new AbortController();
+        activeTurnAbortController = turnAbortController;
+        try {
+          const llmRequestId = llmRequestIdForTurn(request, messages, effectiveSystemPrompt, tools);
+          onLlmRequestId?.(llmRequestId);
+          const llmTrace = await agentTrace?.child({
+            name: `LLM call`,
+            runType: `llm`,
+            inputs: {
+              llmRequestId,
+              systemPrompt: effectiveSystemPrompt,
+              systemContext,
+              messages,
+              tools: tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                input_schema: tool.input_schema
+              }))
+            },
+            metadata: {
+              ...traceMetadataFromRequest(request, internalOnly),
+              iteration: iterations,
+              llmRequestId
+            }
+          });
+          try {
+            response = await llm.chat(
+              messages,
+              effectiveSystemPrompt,
+              tools,
+              {
+                requestId: llmRequestId,
+                signal: turnAbortController.signal
+              }
+            );
+            await llmTrace?.end({
+              outputs: {
+                response,
+                stopReason: response.stopReason,
+                usage: response.usage,
+                providerResponseId: response.providerResponseId,
+                model: response.model
+              }
+            });
+          } catch (error) {
+            await llmTrace?.end({ error: error.message });
+            throw error;
+          }
+        } catch (error) {
+          if (isAbortError2(error)) {
+            if (isCancellationRequested(userId)) {
+              throw new Error(`\u7528\u6237\u5DF2\u505C\u6B62\u5F53\u524D\u6267\u884C`);
+            }
+            console.log(`[agent] \u5F53\u524D LLM \u8C03\u7528\u88AB\u4E2D\u65AD\uFF0C\u51C6\u5907\u6CE8\u5165 interrupt \u540E\u91CD\u65B0\u51B3\u7B56 userId=${userId}`);
+            continue;
+          }
+          if (compactConfig.enabled && isPromptTooLongError(error) && contextRecoveryAttempts < compactConfig.maxFailures) {
+            await recoverFromContextOverflow("prompt_too_long", messages, effectiveSystemPrompt);
+            continue;
+          }
+          if (isLlmCreditExhaustedError(error)) {
+            let alreadySent = false;
+            if (config2.channelPlugin && !internalOnly) {
+              if (await claimOutboundText(LLM_CREDIT_EXHAUSTED_MESSAGE, "llm_credit_exhausted")) {
+                await traceOutboundText(
+                  request.userId,
+                  LLM_CREDIT_EXHAUSTED_MESSAGE,
+                  () => config2.channelPlugin.outbound.sendText({
+                    cfg: {},
+                    to: request.userId,
+                    text: LLM_CREDIT_EXHAUSTED_MESSAGE,
+                    accountId: request.requestId,
+                    metadata: request.metadata
+                  })
+                );
+                alreadySent = true;
+              } else {
+                console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${request.userId} \u7684\u8FD1\u91CD\u590D LLM \u989D\u5EA6\u4E0D\u8DB3\u63D0\u793A`);
+              }
+            }
+            await addMessage(storage, userId, assistantMessage(text(LLM_CREDIT_EXHAUSTED_MESSAGE)), beijingTime, job?.title);
+            markAgentEventsHandled(autoHandledEventIds(alreadySent), "ignored");
+            return finish({
+              content: LLM_CREDIT_EXHAUSTED_MESSAGE,
+              alreadySent
+            });
+          }
+          throw error;
+        } finally {
+          if (activeTurnAbortController === turnAbortController) {
+            activeTurnAbortController = void 0;
+          }
+        }
+        if (response.stopReason === "model_context_window_exceeded") {
+          await recoverFromContextOverflow("model_context_window_exceeded", messages, effectiveSystemPrompt);
+          continue;
+        }
+        if (response.stopReason === "max_tokens") {
+          const toolUsesTruncated = response.content.filter(isToolUseBlock);
+          if (toolUsesTruncated.length > 0) {
+            await addMessage(storage, userId, assistantMessage(text(
+              response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n") || "(\u8F93\u51FA\u88AB\u622A\u65AD)"
+            )), beijingTime, job?.title);
+            await addMessage(storage, userId, userMessage(text(
+              `<system-warning>\u4F60\u7684\u8F93\u51FA\u56E0 max_tokens \u9650\u5236\u88AB\u622A\u65AD\uFF0C\u5DE5\u5177\u8C03\u7528\u53C2\u6570\u4E0D\u5B8C\u6574\uFF0C\u5DF2\u8DF3\u8FC7\u6267\u884C\u3002\u8BF7\u51CF\u5C11\u5355\u6B21\u8F93\u51FA\u91CF\uFF1A\u5148\u8F93\u51FA\u6587\u672C\u8BF4\u660E\uFF0C\u518D\u5355\u72EC\u8C03\u7528\u5DE5\u5177\uFF1B\u5982\u679C\u6587\u4EF6\u5185\u5BB9\u8F83\u957F\uFF0C\u8BF7\u5206\u6BB5\u5199\u5165\u3002</system-warning>`
+            )), beijingTime, job?.title);
+            continue;
+          }
+        }
+        const toolUses = response.content.filter(isToolUseBlock);
+        if (toolUses.length > 0) {
+          await addMessage(storage, userId, assistantMessageFromResponse(response), beijingTime, job?.title);
+          if (toolExecutor) {
+            const userRecoverableMessages = [];
+            const toolResultPromises = toolUses.map(async (useBlock) => {
+              if (signal.aborted) {
+                return toolResult(useBlock.id, `\u5DE5\u5177\u6267\u884C\u88AB\u4E2D\u65AD`);
+              }
+              try {
+                if (useBlock.name === `send_message`) {
+                  const answer = useBlock.input.content?.trim();
+                  if (answer) {
+                    if (config2.channelPlugin) {
+                      console.log(`channelPlugin: ${JSON.stringify(config2.channelPlugin)}`);
+                      const { userId: userId2 } = request;
+                      console.log(`request: ${JSON.stringify(request)}`);
+                      if (await claimOutboundText(answer, "send_message_tool")) {
+                        await traceOutboundText(
+                          userId2,
+                          answer,
+                          () => config2.channelPlugin.outbound.sendText({
+                            cfg: {},
+                            to: userId2,
+                            text: answer,
+                            accountId: request.requestId,
+                            metadata: request.metadata
+                          })
+                        );
+                      } else {
+                        console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${userId2} \u7684\u8FD1\u91CD\u590D\u53D1\u9001\uFF08\u5355\u4E00\u58F0\u97F3\u515C\u5E95\uFF09`);
+                      }
+                    }
+                    hasSentMessage = true;
+                    sentMessageContent = answer;
+                    await completeUserVisibleCeoFollowups();
+                  }
+                }
+                if (useBlock.name === `send_file`) {
+                  if (config2.channelPlugin?.outbound.sendFile) {
+                    const { filePath, url, fileName } = useBlock.input;
+                    const file = filePath || url || "";
+                    if (file) {
+                      const fileType = inferFileType(fileName);
+                      const sentFileMessage = `\u6587\u4EF6\u5DF2\u53D1\u9001: ${fileName}`;
+                      if (await claimOutboundFile(fileName, file)) {
+                        await traceOutboundFile(
+                          request.userId,
+                          fileName,
+                          fileType,
+                          file,
+                          () => config2.channelPlugin.outbound.sendFile({
+                            cfg: {},
+                            to: request.userId,
+                            accountId: request.requestId,
+                            fileName,
+                            fileType,
+                            file
+                          })
+                        );
+                      } else {
+                        console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${request.userId} \u7684\u8FD1\u91CD\u590D\u6587\u4EF6\u53D1\u9001: ${fileName}`);
+                      }
+                      hasSentMessage = true;
+                      sentMessageContent ||= sentFileMessage;
+                      await completeUserVisibleCeoFollowups();
+                    }
+                  }
+                }
+                const toolRequest = {
+                  ...request,
+                  traceRun: agentTrace,
+                  metadata: {
+                    ...request.metadata ?? {},
+                    toolCallId: useBlock.id
+                  }
+                };
+                const result = await toolExecutor.execute(useBlock.name, useBlock.input, toolRequest);
+                return toolResult(useBlock.id, result);
+              } catch (error) {
+                const err = error;
+                if (isUserRecoverableToolError(error)) {
+                  userRecoverableMessages.push(error.userMessage);
+                  return toolResult(useBlock.id, `${useBlock.name}\u5DE5\u5177\u9700\u8981\u7528\u6237\u8865\u5145\u8F93\u5165,reason: ${err.message}`);
+                }
+                return toolResult(useBlock.id, `${useBlock.name}\u5DE5\u5177\u6267\u884C\u9519\u8BEF,reason: ${err.message}`);
+              }
+            });
+            const toolResults = await Promise.all(toolResultPromises);
+            if (toolResults.length > 0) {
+              await addMessage(storage, userId, { role: "user", content: toolResults }, beijingTime, job?.title);
+            }
+            const userRecoverableMessage = userRecoverableMessages[0]?.trim();
+            if (userRecoverableMessage) {
+              let recoverableMessageSent = false;
+              if (config2.channelPlugin && !internalOnly) {
+                if (await claimOutboundText(userRecoverableMessage, "user_recoverable_tool_error")) {
+                  await traceOutboundText(
+                    request.userId,
+                    userRecoverableMessage,
+                    () => config2.channelPlugin.outbound.sendText({
+                      cfg: {},
+                      to: request.userId,
+                      text: userRecoverableMessage,
+                      accountId: request.requestId,
+                      metadata: request.metadata
+                    })
+                  );
+                  recoverableMessageSent = true;
+                } else {
+                  console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${request.userId} \u7684\u8FD1\u91CD\u590D\u53EF\u6062\u590D\u9519\u8BEF\u63D0\u793A`);
+                }
+              }
+              await addMessage(storage, userId, assistantMessage(text(userRecoverableMessage)), beijingTime, job?.title);
+              markAgentEventsHandled(autoHandledEventIds(recoverableMessageSent));
+              return finish({
+                content: userRecoverableMessage,
+                alreadySent: recoverableMessageSent
+              });
+            }
+            const visibleCeoFollowupIdsAfterTools = ceoFollowupIdsFromMetadata2(request.metadata);
+            if (hasSentMessage && visibleCeoFollowupIdsAfterTools.length > 0) {
+              if (topicStorage) {
+                await updateTopicSummary(topicStorage, userId, beijingTime, sentMessageContent, job?.title);
+              }
+              await addMessage(storage, userId, assistantMessage(text(sentMessageContent)), beijingTime, job?.title);
+              markAgentEventsHandled(autoHandledEventIds(true));
+              return finish({
+                content: sentMessageContent,
+                alreadySent: true
+              });
+            }
+            if (hasSentMessage) {
+              if (topicStorage) {
+                await updateTopicSummary(topicStorage, userId, beijingTime, sentMessageContent, job?.title);
+              }
+              await addMessage(storage, userId, assistantMessage(text(sentMessageContent)), beijingTime, job?.title);
+              markAgentEventsHandled(autoHandledEventIds(true));
+              return finish({
+                content: sentMessageContent,
+                alreadySent: true
+              });
+            }
+          }
+          continue;
+        }
+        ;
+        const textBlocks = response.content.filter(
+          (b) => b.type === "text"
+        );
+        const textContent2 = textBlocks.map((b) => b.text).join(`
+`).trim();
+        if (textContent2) {
+          await addMessage(storage, userId, assistantMessageFromResponse(response), beijingTime, job?.title);
+          const lateInterrupts = drainInterrupts(userId);
+          if (lateInterrupts.length > 0) {
+            console.log(`[agent] \u9000\u51FA\u524D\u53D1\u73B0 ${lateInterrupts.length} \u6761\u8FDF\u5230\u7684\u4E2D\u65AD\u6D88\u606F\uFF0C\u7EE7\u7EED\u5904\u7406`);
+            for (const interrupt of lateInterrupts) {
+              markInterruptEventIdsInjected(interrupt.metadata);
+              rememberCeoFollowupIds(ceoFollowupIdsFromMetadata2(interrupt.metadata));
+              const msg = interrupt.content;
+              if (interrupt.metadata) {
+                request.metadata = {
+                  ...request.metadata ?? {},
+                  ...interrupt.metadata
+                };
+              }
+              if (interrupt.metadata?.internalOnly === true) {
+                continue;
+              }
+              await addMessage(storage, userId, userMessage(text(
+                `<user-interrupt>\u7528\u6237\u53D1\u6765\u4E86\u65B0\u6D88\u606F\uFF0C\u8BF7\u7ACB\u5373\u91CD\u65B0\u8BC4\u4F30\u5F53\u524D\u5DE5\u4F5C\uFF0C\u65B0\u6D88\u606F\u53EF\u80FD\u4F1A\u6539\u53D8\u4F60\u7684\u4EFB\u52A1\u4F18\u5148\u7EA7\u6216\u65B9\u5411\u3002
+${msg}</user-interrupt>`
+              )), beijingTime, job?.title);
+            }
+            continue;
+          }
+          const visibleCeoFollowupIds = ceoFollowupIdsFromMetadata2(request.metadata);
+          if (!hasSentMessage && visibleCeoFollowupIds.length > 0 && config2.channelPlugin) {
+            if (await claimOutboundText(textContent2, "followup_fallback_text")) {
+              await traceOutboundText(
+                request.userId,
+                textContent2,
+                () => config2.channelPlugin.outbound.sendText({
+                  cfg: {},
+                  to: request.userId,
+                  text: textContent2,
+                  accountId: request.requestId,
+                  metadata: request.metadata
+                })
+              );
+            } else {
+              console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${request.userId} \u7684\u8FD1\u91CD\u590D\u515C\u5E95\u53D1\u9001`);
+            }
+            hasSentMessage = true;
+            sentMessageContent = textContent2;
+            await completeUserVisibleCeoFollowups();
+          }
+          if (topicStorage) {
+            const topicSummary = hasSentMessage ? sentMessageContent : textContent2;
+            await updateTopicSummary(topicStorage, userId, beijingTime, topicSummary, job?.title);
+          }
+          markAgentEventsHandled(autoHandledEventIds(hasSentMessage));
+          return finish({
+            content: hasSentMessage ? sentMessageContent : textContent2,
+            alreadySent: hasSentMessage
+          });
+        }
+        if (hasSentMessage) {
+          const lateInterrupts = drainInterrupts(userId);
+          if (lateInterrupts.length > 0) {
+            console.log(`[agent] \u9000\u51FA\u524D\u53D1\u73B0 ${lateInterrupts.length} \u6761\u8FDF\u5230\u7684\u4E2D\u65AD\u6D88\u606F\uFF0C\u7EE7\u7EED\u5904\u7406`);
+            for (const interrupt of lateInterrupts) {
+              markInterruptEventIdsInjected(interrupt.metadata);
+              rememberCeoFollowupIds(ceoFollowupIdsFromMetadata2(interrupt.metadata));
+              const msg = interrupt.content;
+              if (interrupt.metadata) {
+                request.metadata = {
+                  ...request.metadata ?? {},
+                  ...interrupt.metadata
+                };
+              }
+              if (interrupt.metadata?.internalOnly === true) {
+                continue;
+              }
+              await addMessage(storage, userId, userMessage(text(
+                `<user-interrupt>\u7528\u6237\u53D1\u6765\u4E86\u65B0\u6D88\u606F\uFF0C\u8BF7\u7ACB\u5373\u91CD\u65B0\u8BC4\u4F30\u5F53\u524D\u5DE5\u4F5C\uFF0C\u65B0\u6D88\u606F\u53EF\u80FD\u4F1A\u6539\u53D8\u4F60\u7684\u4EFB\u52A1\u4F18\u5148\u7EA7\u6216\u65B9\u5411\u3002
+${msg}</user-interrupt>`
+              )), beijingTime, job?.title);
+            }
+            continue;
+          }
+          if (topicStorage) {
+            await updateTopicSummary(topicStorage, userId, beijingTime, sentMessageContent, job?.title);
+          }
+          await addMessage(storage, userId, assistantMessage(text(sentMessageContent)), beijingTime, job?.title);
+          markAgentEventsHandled(autoHandledEventIds(true));
+          return finish({
+            content: sentMessageContent,
+            alreadySent: true
+          });
+        }
+        emptyRetries++;
+        console.warn(`[agent] LLM \u8FD4\u56DE\u7A7A\u5185\u5BB9\uFF08\u7B2C${emptyRetries}\u6B21\uFF09\uFF0CstopReason=${response.stopReason}, content=${JSON.stringify(response.content)}`);
+        if (emptyRetries >= 3) {
+          console.error(`[agent] LLM \u8FDE\u7EED ${emptyRetries} \u6B21\u8FD4\u56DE\u7A7A\u5185\u5BB9\uFF0C\u653E\u5F03\u91CD\u8BD5`);
+          const fallback = "\u62B1\u6B49\uFF0C\u6211\u6682\u65F6\u65E0\u6CD5\u56DE\u590D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002";
+          await addMessage(storage, userId, assistantMessage(text(fallback)), beijingTime, job?.title);
+          markAgentEventsHandled(autoHandledEventIds(false), "ignored");
+          return finish({ content: fallback, alreadySent: false });
+        }
+        await addMessage(storage, userId, assistantMessage(text("(\u601D\u8003\u4E2D...)")), beijingTime, job?.title);
+        await addMessage(storage, userId, userMessage(text(
+          "<system-warning>\u4F60\u7684\u4E0A\u4E00\u6761\u56DE\u590D\u5185\u5BB9\u4E3A\u7A7A\u3002\u8BF7\u91CD\u65B0\u7EC4\u7EC7\u56DE\u590D\uFF0C\u4F7F\u7528 send_message \u5DE5\u5177\u5411\u7528\u6237\u53D1\u9001\u6D88\u606F\u3002</system-warning>"
+        )), beijingTime, job?.title);
+        continue;
+      }
+    } catch (error) {
+      const message = error.message;
+      await agentTrace?.end({ error: message });
+      await rootTrace?.end({ error: message });
+      throw error;
+    } finally {
+      if (durableEventPoller) clearInterval(durableEventPoller);
+      unregisterInterruptListener?.();
+      activeTurnAbortController?.abort();
+      markDone(userId);
+      signals.delete(userId);
+    }
+  };
+};
+
+// src/agent/createAgent.ts
+var createAgent = (config2 = getDefaultAgentConfig()) => {
+  return createAgent2(config2);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createAgent,
   createDefaultToolHookPlugins,
   createDefaultTools,
   createDuclawTools,
   duclawPreset,
-  getDefaultAgentConfig
+  getDefaultAgentConfig,
+  getDefaultDuclawAgentConfig
 });