@modelzen/feishu-codex-bridge 0.6.7 → 0.6.9

package/dist/cli.js

@@ -155,6 +155,35 @@ function getMaxConcurrentRuns(cfg) {
 function getPendingPolicy(cfg) {
   return cfg.preferences?.pendingPolicy === "queue" ? "queue" : "steer";
 }
+function getCompletionReminderConfig(cfg) {
+  const raw = cfg.preferences?.completionReminder;
+  const mode = raw?.mode === "manual" || raw?.mode === "long" || raw?.mode === "always" ? raw.mode : "failures";
+  const minutes = raw?.longTaskMinutes;
+  const longTaskMinutes = typeof minutes !== "number" || !Number.isFinite(minutes) || minutes <= 0 ? COMPLETION_REMINDER_LONG_TASK_DEFAULT_MINUTES : Math.min(
+    COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES,
+    Math.max(COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES, Math.floor(minutes))
+  );
+  return { mode, longTaskMinutes };
+}
+function shouldShowCompletionReminderButton(cfg) {
+  return getCompletionReminderConfig(cfg).mode === "manual";
+}
+function shouldSendCompletionReminder(cfg, decision) {
+  if (decision.outcome === "interrupted" || decision.outcome === "cancelled") return false;
+  const reminder = getCompletionReminderConfig(cfg);
+  switch (reminder.mode) {
+    case "manual":
+      return decision.manuallyRequested === true;
+    case "long": {
+      const elapsedMs = Number.isFinite(decision.elapsedMs) ? Math.max(0, decision.elapsedMs) : 0;
+      return elapsedMs >= reminder.longTaskMinutes * 6e4;
+    }
+    case "always":
+      return true;
+    case "failures":
+      return decision.outcome === "error" || decision.outcome === "idle_timeout";
+  }
+}
 function getRunIdleTimeoutMs(cfg) {
   const raw = cfg.preferences?.runIdleTimeoutSeconds;
   if (raw === 0) return void 0;
@@ -233,10 +262,13 @@ function canEnableCliBridge(cfg) {
 function getCommentsConfig(cfg) {
   return cfg.preferences?.comments ?? {};
 }
-var RUN_IDLE_TIMEOUT_MIN_SEC, RUN_IDLE_TIMEOUT_MAX_SEC;
+var COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES, COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES, COMPLETION_REMINDER_LONG_TASK_DEFAULT_MINUTES, RUN_IDLE_TIMEOUT_MIN_SEC, RUN_IDLE_TIMEOUT_MAX_SEC;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     "use strict";
+    COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES = 1;
+    COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES = 1440;
+    COMPLETION_REMINDER_LONG_TASK_DEFAULT_MINUTES = 3;
     RUN_IDLE_TIMEOUT_MIN_SEC = 10;
     RUN_IDLE_TIMEOUT_MAX_SEC = 3600;
   }
@@ -2550,6 +2582,7 @@ async function pollEventSubscription(appId, appSecret, tenant, opts = {}) {
 
 // src/agent/types.ts
 var DEFAULT_BACKEND_ID = "codex-appserver";
+var REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
 function isGoalTerminal(status) {
   return status === "complete" || status === "budgetLimited" || status === "usageLimited" || status === "blocked";
 }
@@ -4111,6 +4144,7 @@ ${b.thinking}` : b.thinking;
 
 // src/agent/claude-agent/thread.ts
 init_logger();
+import { readFile as readFile5 } from "fs/promises";
 var COMPACT_TIMEOUT_MS2 = 12e4;
 var ABORT_ESCALATE_MS = 4e3;
 var Inbox = class {
@@ -4158,15 +4192,53 @@ var PushablePrompt = class {
 function toSdkEffort(e) {
   if (!e) return void 0;
   if (e === "none" || e === "minimal") return "low";
+  if (e === "ultra") return "max";
   return e;
 }
-function toUserMessage(input2) {
+var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+function sniffImageType(b) {
+  if (b.length >= 8 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return "image/png";
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return "image/jpeg";
+  if (b.length >= 6 && b[0] === 71 && b[1] === 73 && b[2] === 70 && b[3] === 56) return "image/gif";
+  if (b.length >= 12 && b.toString("ascii", 0, 4) === "RIFF" && b.toString("ascii", 8, 12) === "WEBP") return "image/webp";
+  return void 0;
+}
+async function toImageBlock(path) {
+  let bytes;
+  try {
+    bytes = await readFile5(path);
+  } catch (err) {
+    log.warn("agent", "image-read-failed", { backend: "claude-agent", err: String(err) });
+    return void 0;
+  }
+  if (bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES) {
+    log.warn("agent", "image-skip-size", { backend: "claude-agent", bytes: bytes.byteLength });
+    return void 0;
+  }
+  const mediaType = sniffImageType(bytes);
+  if (!mediaType) {
+    log.info("agent", "image-skip-unsupported", { backend: "claude-agent", head: bytes.toString("hex", 0, 4) });
+    return void 0;
+  }
+  return { type: "image", source: { type: "base64", media_type: mediaType, data: bytes.toString("base64") } };
+}
+function textUserMessage(text) {
+  return { type: "user", message: { role: "user", content: text }, parent_tool_use_id: null };
+}
+async function toUserMessage(input2) {
   const text = input2.text ?? "";
-  return {
-    type: "user",
-    message: { role: "user", content: text },
-    parent_tool_use_id: null
-  };
+  const paths2 = input2.images ?? [];
+  if (paths2.length === 0) return textUserMessage(text);
+  const blocks = [];
+  if (text) blocks.push({ type: "text", text });
+  for (const path of paths2) {
+    const block = await toImageBlock(path);
+    if (block) blocks.push(block);
+  }
+  const imageCount = blocks.filter((b) => b.type === "image").length;
+  if (imageCount === 0) return textUserMessage(text);
+  log.info("agent", "images-attached", { backend: "claude-agent", count: imageCount, of: paths2.length });
+  return { type: "user", message: { role: "user", content: blocks }, parent_tool_use_id: null };
 }
 function goalPrompt(objective) {
   return [
@@ -4253,7 +4325,13 @@ var ClaudeAgentThread = class {
     const inbox = new Inbox();
     const mySink = (item) => inbox.push(item);
     this.sink = mySink;
-    this.input.push(toUserMessage(input2));
+    void toUserMessage(input2).then(
+      (m) => this.input.push(m),
+      (err) => {
+        log.fail("agent", err, { backend: "claude-agent", phase: "build-user-message" });
+        this.input.push(textUserMessage(input2.text ?? ""));
+      }
+    );
     const self = this;
     async function* gen() {
       yield { type: "turn_started", turnId };
@@ -4334,7 +4412,7 @@ var ClaudeAgentThread = class {
     const inbox = new Inbox();
     const mySink = (item) => inbox.push(item);
     this.sink = mySink;
-    this.input.push(toUserMessage({ text: goalPrompt(objective) }));
+    this.input.push(textUserMessage(goalPrompt(objective)));
     const self = this;
     async function* gen() {
       yield { type: "goal_update", status: "active", objective, tokensUsed: 0, timeUsedSeconds: 0, tokenBudget: null };
@@ -4430,7 +4508,7 @@ var ClaudeAgentThread = class {
     });
     let compacted = false;
     try {
-      this.input.push(toUserMessage({ text: "/compact" }));
+      this.input.push(textUserMessage("/compact"));
       while (true) {
         const step = await Promise.race([inbox.next(), timeout]);
         if (step === "timeout") throw new Error(`\u538B\u7F29\u8D85\u65F6\uFF08Claude \u672A\u5728 ${COMPACT_TIMEOUT_MS2 / 1e3}s \u5185\u5B8C\u6210\uFF09`);
@@ -4683,7 +4761,7 @@ async function effectiveDefaultBackend(opts) {
 }
 
 // src/agent/installer.ts
-import { mkdir as mkdir4, rm as rm2, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir4, rm as rm2, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { join as join8 } from "path";
 init_paths();
@@ -4872,7 +4950,7 @@ async function rollback(bareName) {
 async function removeBackendsDep(bareName) {
   const pkgFile = join8(paths.backendsDir, "package.json");
   try {
-    const raw = await readFile5(pkgFile, "utf8");
+    const raw = await readFile6(pkgFile, "utf8");
     const json = JSON.parse(raw);
     if (json.dependencies && bareName in json.dependencies) {
       delete json.dependencies[bareName];
@@ -5371,7 +5449,7 @@ init_schema();
 
 // src/project/registry.ts
 init_paths();
-import { mkdir as mkdir5, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 import { randomUUID as randomUUID3 } from "crypto";
 import { dirname as dirname5 } from "path";
 function defaultNoMention(p) {
@@ -5398,7 +5476,7 @@ async function read() {
 }
 async function listProjectsIn(file) {
   try {
-    const text = await readFile6(file, "utf8");
+    const text = await readFile7(file, "utf8");
     const parsed = JSON.parse(text);
     return Array.isArray(parsed.projects) ? parsed.projects : [];
   } catch (err) {
@@ -5488,8 +5566,13 @@ var EFFORT_LABEL = {
   low: "\u4F4E",
   medium: "\u4E2D",
   high: "\u9AD8",
-  xhigh: "\u6781\u9AD8"
+  xhigh: "\u6781\u9AD8",
+  max: "\u6700\u9AD8",
+  ultra: "\u8D85\u5F3A"
 };
+function reasoningEffortLabel(effort) {
+  return EFFORT_LABEL[effort] ?? (effort || "\u672A\u77E5");
+}
 function buildModelCard(state) {
   const visible = state.models.filter((m) => !m.hidden);
   const cur = state.models.find((m) => m.id === state.model);
@@ -5517,7 +5600,7 @@ function buildModelCard(state) {
           actionId: MC.effort,
           placeholder: "effort",
           initial: state.effort,
-          options: efforts.map((e) => ({ label: `effort\uFF1A${EFFORT_LABEL[e]}`, value: e }))
+          options: efforts.map((e) => ({ label: `effort\uFF1A${reasoningEffortLabel(e)}`, value: e }))
         })
       );
     }
@@ -5735,6 +5818,10 @@ var DM = {
   // 假死超时「自定义…」：watchdogCustom 打开输入卡，watchdogCustomSubmit 保存任意秒数
   watchdogCustom: "dm.set.watchdog.custom",
   watchdogCustomSubmit: "dm.set.watchdog.customSubmit",
+  // 普通群任务结束提醒（与 ☕ CLI Stop 通知无关）：四档策略 + 长任务阈值子卡
+  setCompletionReminder: "dm.set.completionReminder",
+  completionReminderCustom: "dm.set.completionReminder.custom",
+  completionReminderCustomSubmit: "dm.set.completionReminder.customSubmit",
   setPending: "dm.set.pending",
   setConcurrency: "dm.set.concurrency",
   // 权限管理：全局 admins（settings 卡进入）+ 项目响应白名单（项目列表 / 建项目完成卡进入）
@@ -6270,6 +6357,7 @@ function settingItem(name, desc, actionId, current, opts) {
 }
 function buildSettingsCard(cfg) {
   const watchdogSec = cfg.preferences?.runIdleTimeoutSeconds ?? 120;
+  const completionReminder = getCompletionReminderConfig(cfg);
   return card(
     [
       settingSection("\u{1F4E4} \u8F93\u51FA\u5C55\u793A"),
@@ -6304,6 +6392,23 @@ function buildSettingsCard(cfg) {
         ),
         button("\u81EA\u5B9A\u4E49\u2026", { a: DM.watchdogCustom })
       ]),
+      ...settingItem(
+        "\u{1F514} \u4EFB\u52A1\u7ED3\u675F\u63D0\u9192",
+        "\u7ED3\u675F\u540E\u989D\u5916\u56DE\u590D\u4E00\u6761\u6D88\u606F\u5E76 @ \u53D1\u8D77\u4EBA\u3002\u300C\u4EC5\u624B\u52A8\u300D\u4F1A\u5728\u8FD0\u884C\u5361\u663E\u793A\u63D0\u9192\u6309\u94AE\uFF1B\u5176\u4ED6\u6863\u4F4D\u81EA\u52A8\u5224\u65AD\uFF0C\u4E0D\u663E\u793A\u6309\u94AE\u3002",
+        DM.setCompletionReminder,
+        completionReminder.mode,
+        [
+          { label: "\u4EC5\u624B\u52A8", value: "manual" },
+          { label: "\u957F\u4EFB\u52A1", value: "long" },
+          { label: "\u5931\u8D25\u6216\u8D85\u65F6", value: "failures" },
+          { label: "\u6BCF\u6B21\u7ED3\u675F", value: "always" }
+        ]
+      ),
+      ...completionReminder.mode === "long" ? [
+        md(`**\u23F3 \u957F\u4EFB\u52A1\u9608\u503C** \xB7 \u5F53\u524D **${completionReminder.longTaskMinutes} \u5206\u949F**`),
+        note("\u4EFB\u52A1\u8017\u65F6\u8FBE\u5230\u8FD9\u4E2A\u9608\u503C\u540E\uFF0C\u7ED3\u675F\u65F6\u624D\u4F1A\u63D0\u9192\u3002"),
+        actions([button("\u4FEE\u6539\u9608\u503C\u2026", { a: DM.completionReminderCustom })])
+      ] : [],
       ...settingItem(
         "\u{1F4E5} \u8FD0\u884C\u4E2D\u6765\u65B0\u6D88\u606F",
         "\u6B63\u5728\u8DD1\u65F6\u4F60\u53C8\u53D1\u6D88\u606F\uFF1A\u5F15\u5BFC\uFF1D\u63D2\u8FDB\u5F53\u524D\u8F6E\u7EA0\u504F\uFF1B\u6392\u961F\uFF1D\u7B49\u8FD9\u8F6E\u8DD1\u5B8C\u518D\u5904\u7406\u3002",
@@ -6401,7 +6506,7 @@ function buildCommentSettingsCard(cfg, backendOptions, models, notice) {
         selectMenu({
           name: "effort",
           placeholder: "\u9009\u62E9\u63A8\u7406\u5F3A\u5EA6",
-          options: unionEfforts.map((e) => ({ label: EFFORT_LABEL[e], value: e })),
+          options: unionEfforts.map((e) => ({ label: reasoningEffortLabel(e), value: e })),
           initial: curEffort
         })
       );
@@ -6506,6 +6611,25 @@ function buildWatchdogCustomCard(cfg) {
     { header: { title: "\u23F1 \u81EA\u5B9A\u4E49\u8D85\u65F6", template: "blue" } }
   );
 }
+function buildCompletionReminderCustomCard(cfg) {
+  const cur = getCompletionReminderConfig(cfg).longTaskMinutes;
+  return card(
+    [
+      md("**\u81EA\u5B9A\u4E49\u957F\u4EFB\u52A1\u9608\u503C**"),
+      note(
+        `\u4EFB\u52A1\u8017\u65F6\u8FBE\u5230\u8FD9\u4E2A\u65F6\u957F\uFF0C\u7ED3\u675F\u65F6\u989D\u5916\u56DE\u590D\u6D88\u606F\u5E76 @ \u53D1\u8D77\u4EBA\u3002\u8303\u56F4 ${COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES}\u2013${COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES} \u5206\u949F\u3002`
+      ),
+      form("completion_reminder_custom", [
+        input({ name: "minutes", label: "\u65F6\u957F\uFF08\u5206\u949F\uFF09", placeholder: "\u4F8B\u5982 10", value: String(cur), required: true }),
+        actions([
+          submitButton("\u2705 \u4FDD\u5B58", { a: DM.completionReminderCustomSubmit }, "primary", "submit_completion_reminder")
+        ])
+      ]),
+      actions([button("\u2B05\uFE0F \u8FD4\u56DE\u8BBE\u7F6E", { a: DM.settings })])
+    ],
+    { header: { title: "\u{1F514} \u957F\u4EFB\u52A1\u9608\u503C", template: "blue" } }
+  );
+}
 function buildGroupSettingsCard(project) {
   const kind = project.kind ?? "multi";
   const noMention = project.noMention ?? defaultNoMention(project);
@@ -6644,10 +6768,10 @@ function buildPermissionCard(p) {
     { header: { title: "\u{1F510} \u6743\u9650", template: "blue" } }
   );
 }
-var EFFORT_ORDER = ["none", "minimal", "low", "medium", "high", "xhigh"];
+var EFFORT_ORDER = REASONING_EFFORTS;
 function modelDefaultSummary(p) {
   if (!p.defaultModel) return "\u540E\u7AEF\u9ED8\u8BA4\uFF08\u672A\u8BBE\uFF09";
-  const eff = p.defaultEffort ? ` \xB7 \u5F3A\u5EA6 ${EFFORT_LABEL[p.defaultEffort]}` : "";
+  const eff = p.defaultEffort ? ` \xB7 \u5F3A\u5EA6 ${reasoningEffortLabel(p.defaultEffort)}` : "";
   return `${p.defaultModel}${eff}`;
 }
 function buildModelDefaultCard(p, models, ctx, notice) {
@@ -6698,7 +6822,7 @@ function buildModelDefaultCard(p, models, ctx, notice) {
       selectMenu({
         name: "effort",
         placeholder: "\u9009\u62E9\u9ED8\u8BA4\u63A8\u7406\u5F3A\u5EA6",
-        options: unionEfforts.map((e) => ({ label: `\u5F3A\u5EA6\uFF1A${EFFORT_LABEL[e]}`, value: e })),
+        options: unionEfforts.map((e) => ({ label: `\u5F3A\u5EA6\uFF1A${reasoningEffortLabel(e)}`, value: e })),
         initial: curEffort
       })
     );
@@ -6822,6 +6946,8 @@ function buildAddAllowedCard(projectName, members) {
 }
 
 // src/admin/ops.ts
+init_schema();
+init_store();
 var AdminWriteError = class extends Error {
   code = "ADMIN_WRITE_REJECTED";
   constructor(reason) {
@@ -6829,7 +6955,26 @@ var AdminWriteError = class extends Error {
     this.name = "AdminWriteError";
   }
 };
+function createAppPreferencesWriter(opts) {
+  let chain = Promise.resolve();
+  const persist = opts.persistConfig ?? saveConfig;
+  return (mutate) => {
+    const run = chain.then(async () => {
+      const preferences = { ...opts.cfg.preferences ?? {} };
+      mutate(preferences);
+      await persist({ ...opts.cfg, preferences });
+      opts.cfg.preferences = preferences;
+      return preferences;
+    });
+    chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  };
+}
 var TIERS = ["qa", "write", "full"];
+var COMPLETION_REMINDER_MODES = ["manual", "long", "failures", "always"];
 function validateBackendSwitch(opts) {
   if (!opts.registered.includes(opts.target)) {
     return `\u672A\u77E5\u540E\u7AEF\u300C${opts.target}\u300D\uFF08\u53EF\u7528\uFF1A${opts.registered.join("\u3001")}\uFF09`;
@@ -6928,9 +7073,30 @@ async function performSetModelDefault(opts) {
   await updateProject(opts.projectName, { defaultModel: opts.model, defaultEffort: opts.effort });
   return { ok: true, project: await freshOr(opts.projectName, { ...p, defaultModel: opts.model, defaultEffort: opts.effort }) };
 }
+async function performSetCompletionReminder(opts) {
+  if (!COMPLETION_REMINDER_MODES.includes(opts.mode)) {
+    return { ok: false, reason: `\u672A\u77E5\u5B8C\u6210\u63D0\u9192\u7B56\u7565\u300C${String(opts.mode)}\u300D` };
+  }
+  if (opts.longTaskMinutes !== void 0 && (!Number.isInteger(opts.longTaskMinutes) || opts.longTaskMinutes < COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES || opts.longTaskMinutes > COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES)) {
+    return {
+      ok: false,
+      reason: `\u957F\u4EFB\u52A1\u9608\u503C\u5FC5\u987B\u662F ${COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES}\u2013${COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES} \u4E4B\u95F4\u7684\u6574\u6570\u5206\u949F`
+    };
+  }
+  const writePreferences = opts.writePreferences ?? createAppPreferencesWriter({ cfg: opts.cfg, persistConfig: opts.persistConfig });
+  await writePreferences((preferences) => {
+    const current = getCompletionReminderConfig({ ...opts.cfg, preferences });
+    preferences.completionReminder = {
+      mode: opts.mode,
+      longTaskMinutes: opts.longTaskMinutes ?? current.longTaskMinutes
+    };
+  });
+  return { ok: true, completionReminder: getCompletionReminderConfig(opts.cfg) };
+}
 function createAdminWriteExecutor(deps) {
+  const writePreferences = deps.writePreferences ?? (deps.cfg ? createAppPreferencesWriter({ cfg: deps.cfg, persistConfig: deps.persistConfig }) : void 0);
   return async (op) => {
-    const outcome = await runAdminWriteOp(op, deps);
+    const outcome = await runAdminWriteOp(op, { ...deps, writePreferences });
     if (!outcome.ok) throw new AdminWriteError(outcome.reason);
   };
 }
@@ -6954,12 +7120,20 @@ async function runAdminWriteOp(op, deps) {
         on: op.on,
         evictLiveSessionsForChat: deps.evictLiveSessionsForChat
       });
+    case "setCompletionReminder":
+      if (!deps.cfg) return { ok: false, reason: "bot \u8FD0\u884C\u914D\u7F6E\u4E0D\u53EF\u7528\uFF0C\u65E0\u6CD5\u5373\u65F6\u66F4\u65B0\u5B8C\u6210\u63D0\u9192" };
+      return performSetCompletionReminder({
+        cfg: deps.cfg,
+        mode: op.mode,
+        longTaskMinutes: op.longTaskMinutes,
+        persistConfig: deps.persistConfig,
+        writePreferences: deps.writePreferences
+      });
   }
 }
 
 // src/bot/handle-message.ts
 init_schema();
-init_store();
 
 // src/card/dispatcher.ts
 init_logger();
@@ -7574,6 +7748,8 @@ function gaugeEl(state) {
 }
 var RC = {
   stop: "run.stop",
+  /** manual completion-reminder mode: notify this turn's requester when it ends. */
+  remind: "run.remind",
   /** goal-only: clear the goal but let the in-flight turn finish (no auto-continue). */
   endGoal: "goal.end"
 };
@@ -7628,8 +7804,16 @@ function renderRunning(state, rc) {
         )
       );
     }
-  } else if (rc.cardKey && !rc.hideStop) {
-    elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")], CONTROLS_EID));
+  } else if (rc.cardKey) {
+    if (rc.completionReminder === "requested") {
+      elements.push(noteMd("_\u{1F514} \u672C\u8F6E\u7ED3\u675F\u540E\u4F1A\u63D0\u9192\u53D1\u8D77\u4EBA_"));
+    }
+    const controls = [];
+    if (!rc.hideStop) controls.push(button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger"));
+    if (rc.completionReminder === "available") {
+      controls.push(button("\u{1F514} \u5B8C\u6210\u540E\u63D0\u9192\u6211", { a: RC.remind, m: rc.cardKey }, "default"));
+    }
+    if (controls.length > 0) elements.push(actions(controls, CONTROLS_EID));
   }
   return elements;
 }
@@ -7743,7 +7927,14 @@ function buildQueuedCard(qc) {
     md(`\u23F3 \u6392\u961F\u4E2D\uFF08\u7B2C **${qc.position ?? 1}** \u4F4D\uFF09`),
     noteMd("\u5168\u5C40\u5E76\u53D1\u6C60\u5DF2\u6EE1\uFF08\u6240\u6709\u7FA4/\u8BDD\u9898\u5171\u4EAB\uFF09\uFF0C\u8F6E\u5230\u540E\u81EA\u52A8\u5F00\u59CB\u3002")
   ];
-  if (qc.cardKey) els.push(actions([button("\u23F9 \u53D6\u6D88", { a: RC.stop, m: qc.cardKey }, "danger")], CONTROLS_EID));
+  if (qc.completionReminder === "requested") els.push(noteMd("_\u{1F514} \u672C\u8F6E\u7ED3\u675F\u540E\u4F1A\u63D0\u9192\u53D1\u8D77\u4EBA_"));
+  if (qc.cardKey) {
+    const controls = [button("\u23F9 \u53D6\u6D88", { a: RC.stop, m: qc.cardKey }, "danger")];
+    if (qc.completionReminder === "available") {
+      controls.push(button("\u{1F514} \u5B8C\u6210\u540E\u63D0\u9192\u6211", { a: RC.remind, m: qc.cardKey }, "default"));
+    }
+    els.push(actions(controls, CONTROLS_EID));
+  }
   return card(els, { summary: "\u6392\u961F\u4E2D" });
 }
 function* groupBlocks(blocks) {
@@ -7825,7 +8016,9 @@ var EFFORT_TIER = {
   low: { label: "\u4F4E", color: "yellow" },
   medium: { label: "\u4E2D", color: "green" },
   high: { label: "\u9AD8", color: "violet" },
-  xhigh: { label: "\u6781\u9AD8", color: "purple" }
+  xhigh: { label: "\u6781\u9AD8", color: "purple" },
+  max: { label: "\u6700\u9AD8", color: "purple" },
+  ultra: { label: "\u8D85\u5F3A", color: "purple" }
 };
 function modelEffortMd(model, effort) {
   if (!effort) return model;
@@ -7970,6 +8163,16 @@ var RunCardStream = class {
   lastAnswerText = "";
   // Per-chat pacer shared with the chat's other streams (set in create()).
   pacer = null;
+  // Forced whole-card writes (button/settings repaint, queue → run flip,
+  // terminal frame) must never race one another. In particular, an async
+  // completion-reminder repaint that started just before turn completion must
+  // land BEFORE the terminal frame, not finish late and put the card back into
+  // its running layout. This tail is deliberately separate from the coalesced
+  // pump: event consumption remains non-blocking, and the caller drains that
+  // pump before finalizing.
+  forcedUpdateTail = Promise.resolve();
+  /** Once terminal finalization starts, reminder/settings repaint is stale. */
+  liveUpdatesFrozen = false;
   get messageId() {
     return this._messageId;
   }
@@ -8161,8 +8364,10 @@ var RunCardStream = class {
       return false;
     }
   }
-  /** Forced whole-card replace for structural/terminal updates. A terminal
-   * card built with streaming off clears the typewriter cursor.
+  /** Forced whole-card replace for structural updates. Calls are serialized in
+   * invocation order so concurrent callback repaints cannot complete out of
+   * order. A terminal card built with streaming off clears the typewriter
+   * cursor.
    *
    * The terminal frame MUST land — losing it leaves the card "streaming"
    * forever (cursor + dead ⏹) while the run is over and `runsByCard` already
@@ -8170,10 +8375,43 @@ var RunCardStream = class {
    * with exponential backoff (1s/2s/4s, {@link TERMINAL_RL_RETRIES} retries);
    * anything else — typically 200810 "card in ongoing interaction" when the
    * update fires inside a ⏹ click's 3s window — waits out the window and
-   * retries once. */
-  async updateCard(channel, fullCard) {
-    if (!this.cardId) return;
+   * retries once. Returns whether the requested frame is observably on the
+   * entity, so terminal callers can emit a truthful fallback notification. */
+  updateCard(channel, fullCard) {
+    return this.enqueueForcedUpdate(channel, fullCard);
+  }
+  /**
+   * Repaint a still-live card (currently used by the completion-reminder
+   * control). Once {@link finalizeCard} has synchronously frozen live repaints,
+   * late callbacks become a no-op. Repaints accepted before the freeze share
+   * the forced-update tail and therefore finish before the terminal frame.
+   */
+  updateLiveCard(channel, fullCard) {
+    if (this.liveUpdatesFrozen) return Promise.resolve(false);
+    return this.enqueueForcedUpdate(channel, fullCard);
+  }
+  /**
+   * Freeze live repaints synchronously, then enqueue the terminal whole-card
+   * frame after every already-accepted forced update. Future intentional
+   * non-live updates (for example demoting an old terminal card's settings
+   * control) may still use {@link updateCard}.
+   */
+  finalizeCard(channel, fullCard) {
+    this.liveUpdatesFrozen = true;
+    return this.enqueueForcedUpdate(channel, fullCard);
+  }
+  enqueueForcedUpdate(channel, fullCard) {
+    if (!this.cardId) return Promise.resolve(false);
     const data = JSON.stringify(fullCard);
+    const task = this.forcedUpdateTail.then(() => this.pushForcedUpdate(channel, data));
+    this.forcedUpdateTail = task.then(
+      () => void 0,
+      () => void 0
+    );
+    return task;
+  }
+  async pushForcedUpdate(channel, data) {
+    if (!this.cardId) return false;
     const push = async () => {
       await channel.rawClient.cardkit.v1.card.update({
         path: { card_id: this.cardId },
@@ -8185,13 +8423,13 @@ var RunCardStream = class {
       await this.pacer?.wait();
       try {
         await push();
-        return;
+        return true;
       } catch (err) {
         const rl = isRateLimited(err);
         if (rl) this.pacer?.penalize();
         if (i >= (rl ? TERMINAL_RL_RETRIES : 1)) {
           log.fail("card", err, { phase: "run-update-retry", cardId: this.cardId, seq: this.seq });
-          return;
+          return false;
         }
         log.fail("card", err, { phase: "run-update", cardId: this.cardId, seq: this.seq, retry: true, rateLimited: rl });
         await new Promise((r) => setTimeout(r, rl ? RL_BACKOFF_BASE_MS * 2 ** i : 3200));
@@ -8221,7 +8459,7 @@ function structureSig(card2, eid) {
 
 // src/card/outbound-images.ts
 init_logger();
-import { readFile as readFile7, stat as stat2 } from "fs/promises";
+import { readFile as readFile8, stat as stat2 } from "fs/promises";
 import { extname as extname2, isAbsolute, resolve as resolve2, sep } from "path";
 var MAX_IMAGES = 9;
 var MAX_BYTES = 10 * 1024 * 1024;
@@ -8308,7 +8546,7 @@ async function loadLocal(src, cwd) {
     log.warn("outbound", "image-size", { size, src: src.slice(0, 80) });
     return { cacheKey: `local:${abs}:${size}` };
   }
-  const buffer = await readFile7(abs);
+  const buffer = await readFile8(abs);
   return { buffer, cacheKey: `local:${abs}:${mtimeMs}:${size}` };
 }
 async function loadRemote(url) {
@@ -8361,7 +8599,7 @@ init_logger();
 init_cards2();
 
 // src/cli-bridge/hooks.ts
-import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { join as join10, resolve as resolve3 } from "path";
 var AGENT2LARK_MARKER = "agent2lark-hook";
@@ -8382,7 +8620,7 @@ async function inspectCliBridgeHooks(opts = {}) {
   const codex = await readJson(join10(home, ".codex", "hooks.json"));
   let codexStatus = inspectAgent("codex", codex, [...CODEX_EVENTS]);
   if (codexStatus.status === "installed") {
-    const toml = await readFile8(join10(home, ".codex", "config.toml"), "utf8").catch(() => "");
+    const toml = await readFile9(join10(home, ".codex", "config.toml"), "utf8").catch(() => "");
     if (!hasCodexHooksFeature(toml)) {
       codexStatus = {
         agent: "codex",
@@ -8410,7 +8648,7 @@ async function installCliBridgeHooks(opts) {
     json.hooks = installAgentGroups(json.hooks, "codex", [...CODEX_EVENTS], opts.command);
     await writeJson(file, json);
     const tomlPath = join10(home, ".codex", "config.toml");
-    const existing = await readFile8(tomlPath, "utf8").catch(() => "");
+    const existing = await readFile9(tomlPath, "utf8").catch(() => "");
     await mkdir6(join10(home, ".codex"), { recursive: true });
     await writeFile6(tomlPath, withCodexHooksFeature(existing), "utf8");
   }
@@ -8419,7 +8657,7 @@ function resolveHome(homeDir) {
   return homeDir ?? homedir3();
 }
 async function readJson(path) {
-  const text = await readFile8(path, "utf8").catch(() => "{}");
+  const text = await readFile9(path, "utf8").catch(() => "{}");
   const parsed = JSON.parse(text || "{}");
   return typeof parsed === "object" && parsed ? parsed : {};
 }
@@ -8539,6 +8777,81 @@ function withCodexHooksFeature(text) {
   return [...lines, ""].join("\n");
 }
 
+// src/card/completion-reminder.ts
+function formatCompletionElapsed(elapsedMs) {
+  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const parts = [];
+  if (hours > 0) parts.push(`${hours} \u5C0F\u65F6`);
+  if (minutes > 0) parts.push(`${minutes} \u5206`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds} \u79D2`);
+  return parts.join(" ");
+}
+function buildCompletionReminderContent(input2) {
+  const task = compactSummary(input2.summary);
+  const elapsed = formatCompletionElapsed(input2.elapsedMs);
+  const headline = input2.outcome === "done" ? ` \u2705\u300C${task}\u300D\u5DF2\u5B8C\u6210 \xB7 \u7528\u65F6 ${elapsed}` : input2.outcome === "idle_timeout" ? ` \u23F1\u300C${task}\u300D\u54CD\u5E94\u8D85\u65F6 \xB7 \u7B49\u5F85 ${elapsed}` : ` \u26A0\uFE0F\u300C${task}\u300D\u6267\u884C\u5931\u8D25 \xB7 \u7528\u65F6 ${elapsed}`;
+  const detail = input2.cardUpdated ? input2.outcome === "done" ? "\u7ED3\u679C\u5728\u4E0A\u65B9\u5361\u7247\u3002" : "\u8BE6\u60C5\u5728\u4E0A\u65B9\u5361\u7247\u3002" : "\u6700\u7EC8\u5361\u7247\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u67E5\u770B\u4E0A\u65B9\u6D41\u5F0F\u5185\u5BB9\u6216\u91CD\u65B0\u53D1\u8D77\u4EFB\u52A1\u3002";
+  return JSON.stringify({
+    zh_cn: {
+      title: "",
+      content: [
+        [
+          { tag: "at", user_id: input2.requesterOpenId },
+          { tag: "text", text: headline }
+        ],
+        [{ tag: "text", text: detail }]
+      ]
+    }
+  });
+}
+function compactSummary(summary) {
+  const clean = (summary ?? "").replace(/\s+/g, " ").trim();
+  if (!clean) return "\u672C\u8F6E\u4EFB\u52A1";
+  return clean.length > 32 ? `${clean.slice(0, 31)}\u2026` : clean;
+}
+
+// src/bot/completion-reminder.ts
+init_schema();
+init_logger();
+async function sendCompletionReminderReply(deps, input2) {
+  if (!input2.requesterOpenId || input2.outcome !== "done" && input2.outcome !== "error" && input2.outcome !== "idle_timeout") {
+    return "skipped";
+  }
+  const elapsedMs = Math.max(0, (deps.now?.() ?? Date.now()) - input2.requestedAt);
+  const policyMatch = shouldSendCompletionReminder(deps.cfg, {
+    outcome: input2.outcome,
+    elapsedMs,
+    manuallyRequested: input2.manuallyRequested
+  });
+  if (input2.cardUpdated && !policyMatch) return "skipped";
+  if (deps.dedupe.seen(input2.cardMsgId)) return "skipped";
+  const content = buildCompletionReminderContent({
+    requesterOpenId: input2.requesterOpenId,
+    outcome: input2.outcome,
+    elapsedMs,
+    summary: input2.summary,
+    cardUpdated: input2.cardUpdated
+  });
+  try {
+    await deps.channel.rawClient.im.v1.message.reply({
+      path: { message_id: input2.cardMsgId },
+      data: { msg_type: "post", content, reply_in_thread: input2.replyInThread }
+    });
+    log.info("card", "completion-reminder", {
+      terminal: input2.outcome,
+      elapsedMs,
+      cardUpdated: input2.cardUpdated
+    });
+    return "sent";
+  } catch (err) {
+    log.fail("card", err, { phase: "completion-reminder", terminal: input2.outcome });
+    return "failed";
+  }
+}
+
 // src/service/update.ts
 init_paths();
 import { closeSync, existsSync as existsSync9, openSync as openSync2, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2, writeSync } from "fs";
@@ -8556,7 +8869,7 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 // src/service/common.ts
 init_paths();
 import { appendFileSync, createReadStream, statSync as statSync2 } from "fs";
-import { appendFile, mkdir as mkdir7, readFile as readFile9 } from "fs/promises";
+import { appendFile, mkdir as mkdir7, readFile as readFile10 } from "fs/promises";
 import { dirname as dirname6, join as join11, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function serviceStdoutPath() {
@@ -8625,7 +8938,7 @@ function fileSize(file) {
 }
 async function lastLines(file, n) {
   try {
-    const text = await readFile9(file, "utf8");
+    const text = await readFile10(file, "utf8");
     return text.split("\n").slice(-n - 1).join("\n").trimEnd();
   } catch {
     return "";
@@ -9435,7 +9748,7 @@ async function restartDaemon() {
 
 // src/agent/codex-appserver/usage.ts
 init_logger();
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join16 } from "path";
 var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
@@ -9453,7 +9766,7 @@ async function readCodexAuth() {
   for (let i = 0; i < 3; i++) {
     let raw;
     try {
-      raw = await readFile10(file, "utf8");
+      raw = await readFile11(file, "utf8");
     } catch (err) {
       throw new UsageError("no-auth", `\u8BFB\u4E0D\u5230 ${file}\uFF1A${err instanceof Error ? err.message : String(err)}`);
     }
@@ -9482,7 +9795,7 @@ function jwtExpMs(token) {
 }
 async function chatgptBaseUrl() {
   try {
-    const raw = await readFile10(join16(resolveCodexHome(), "config.toml"), "utf8");
+    const raw = await readFile11(join16(resolveCodexHome(), "config.toml"), "utf8");
     for (const line of raw.split("\n")) {
       const t = line.trim();
       if (t.startsWith("[")) break;
@@ -9845,7 +10158,15 @@ function heatmapElements(p, today) {
   return [md("\u{1F4C8} **\u6BCF\u65E5 Token \u7528\u91CF**"), heatmapChartEl(p.dailyBuckets, today)];
 }
 function effortLabel(effort) {
-  const m = { minimal: "\u6781\u4F4E", low: "\u4F4E", medium: "\u4E2D", high: "\u9AD8", xhigh: "\u8D85\u9AD8" };
+  const m = {
+    minimal: "\u6781\u4F4E",
+    low: "\u4F4E",
+    medium: "\u4E2D",
+    high: "\u9AD8",
+    xhigh: "\u8D85\u9AD8",
+    max: "\u6700\u9AD8",
+    ultra: "\u8D85\u5F3A"
+  };
   return m[effort] ?? effort;
 }
 function insightsElements(p) {
@@ -10086,6 +10407,7 @@ init_paths();
 init_logger();
 import { mkdir as mkdir11 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir7 } from "os";
 import { isAbsolute as isAbsolute2, join as join17, resolve as resolve7 } from "path";
 
 // src/project/announcement.ts
@@ -10275,22 +10597,38 @@ function assertBackendUsable(backend, mode) {
   }
   throw new Error(`\u6240\u9009\u540E\u7AEF\u300C${backend}\u300D\u5F53\u524D\u4E0D\u53EF\u7528\uFF08\u672A\u4E0B\u8F7D\u6216\u4E0D\u652F\u6301\u8BE5\u6743\u9650\u6863\uFF09\uFF0C\u8BF7\u56DE\u5361\u7247\u91CD\u65B0\u9009\u62E9`);
 }
-async function resolveCwd(name, existingPath) {
+async function resolveCwd(name, existingPath, configuredProjectsRootDir) {
   if (existingPath) {
     const cwd2 = isAbsolute2(existingPath) ? existingPath : resolve7(existingPath);
     if (!existsSync10(cwd2)) throw new Error(`\u6587\u4EF6\u5939\u4E0D\u5B58\u5728\uFF1A${cwd2}`);
     return { cwd: cwd2, blank: false };
   }
-  const cwd = join17(paths.projectsRootDir, name);
+  const cwd = join17(resolveProjectsRootDir(configuredProjectsRootDir), name);
   await mkdir11(cwd, { recursive: true });
   return { cwd, blank: true };
 }
+function resolveProjectsRootDir(configured) {
+  if (configured === void 0 || configured === null) return paths.projectsRootDir;
+  if (typeof configured !== "string") {
+    throw new Error("\u914D\u7F6E preferences.projectsRootDir \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  const value = configured.trim();
+  if (!value) return paths.projectsRootDir;
+  if (value === "~") return homedir7();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return resolve7(homedir7(), value.slice(2));
+  }
+  if (!isAbsolute2(value)) {
+    throw new Error("\u914D\u7F6E preferences.projectsRootDir \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\u6216\u4EE5 ~ \u5F00\u5934");
+  }
+  return resolve7(value);
+}
 async function createProject(channel, input2) {
   const name = input2.name.trim();
   if (!name) throw new Error("\u9879\u76EE\u540D\u4E0D\u80FD\u4E3A\u7A7A");
   if (await getProjectByName(name)) throw new Error(`\u9879\u76EE\u540D\u300C${name}\u300D\u5DF2\u5B58\u5728\uFF0C\u6362\u4E2A\u540D\u6216\u7528 /projects \u770B\u5DF2\u6709\u7684`);
   assertBackendUsable(input2.backend, input2.mode ?? "full");
-  const { cwd, blank } = await resolveCwd(name, input2.existingPath);
+  const { cwd, blank } = await resolveCwd(name, input2.existingPath, input2.projectsRootDir);
   const res = await channel.rawClient.im.v1.chat.create({
     params: { user_id_type: "open_id" },
     data: { name, user_id_list: [input2.ownerOpenId] }
@@ -10327,7 +10665,7 @@ async function joinExistingGroup(channel, input2) {
   const bound = await getProjectByChatId(input2.chatId);
   if (bound) throw new Error(`\u8BE5\u7FA4\u5DF2\u7ED1\u5B9A\u4E3A\u9879\u76EE\u300C${bound.name}\u300D`);
   assertBackendUsable(input2.backend, input2.mode ?? "qa");
-  const { cwd, blank } = await resolveCwd(name, input2.existingPath);
+  const { cwd, blank } = await resolveCwd(name, input2.existingPath, input2.projectsRootDir);
   const project = {
     name,
     chatId: input2.chatId,
@@ -10367,7 +10705,7 @@ async function leaveChat(channel, chatId) {
 
 // src/bot/session-store.ts
 init_paths();
-import { mkdir as mkdir12, readFile as readFile11, rename as rename5, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile12, rename as rename5, writeFile as writeFile10 } from "fs/promises";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname12 } from "path";
 var FILE_VERSION3 = 2;
@@ -10386,7 +10724,7 @@ async function read2() {
 }
 async function listSessionsIn(file) {
   try {
-    const text = await readFile11(file, "utf8");
+    const text = await readFile12(file, "utf8");
     const parsed = JSON.parse(text);
     if (!Array.isArray(parsed.sessions)) return [];
     return parsed.sessions.map(migrate);
@@ -11020,7 +11358,7 @@ function weaveSender(text, sender) {
 
 // src/bot/comments.ts
 init_logger();
-import { mkdir as mkdir14, readdir as readdir4, readFile as readFile12, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir14, readdir as readdir4, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname13, join as join19 } from "path";
 var SUPPORTED_FILE_TYPES = /* @__PURE__ */ new Set(["doc", "docx", "sheet", "bitable"]);
 var REPLY_MAX_CHARS = 2e3;
@@ -11149,7 +11487,7 @@ function commentCwd(projectsRoot, fileType, fileToken) {
 }
 async function loadCommentInstructions(masterFile) {
   try {
-    const existing = await readFile12(masterFile, "utf8");
+    const existing = await readFile13(masterFile, "utf8");
     return existing.trim() ? existing : DEFAULT_COMMENT_INSTRUCTIONS;
   } catch {
   }
@@ -11461,7 +11799,6 @@ function selectValue(formValue, name) {
 function asTier(v) {
   return v === "qa" || v === "write" || v === "full" ? v : void 0;
 }
-var REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh"];
 function asEffort(v) {
   return v !== void 0 && REASONING_EFFORTS.includes(v) ? v : void 0;
 }
@@ -11488,6 +11825,22 @@ function safeBackendId(formValue) {
   const v = selectValue(formValue, "backend");
   return v && backendIds().includes(v) ? v : void 0;
 }
+function activateQueuedTurn(state, turn) {
+  state.requesterOpenId = turn.requesterOpenId;
+  state.completionReminderRequested = false;
+}
+function isCompletionReminderRequester(operatorOpenId, requesterOpenId) {
+  return Boolean(operatorOpenId && requesterOpenId && operatorOpenId === requesterOpenId);
+}
+function settleOrdinaryTurnRender(render, input2) {
+  if (input2.interrupted) render.interrupt();
+  else if (input2.timedOut) render.timeout(input2.idleTimeoutSeconds);
+  else if (input2.procDead && render.terminal() === "running") {
+    render.apply({ type: "error", message: "agent \u8FDB\u7A0B\u5F02\u5E38\u9000\u51FA\uFF0C\u8BF7\u91CD\u53D1\u672C\u6761\u6D88\u606F", willRetry: false });
+  } else {
+    render.finalize();
+  }
+}
 function parseGoalTrigger(text) {
   if (!/(^|\s)\/goal(?=\s|$)/i.test(text)) return null;
   const objective = text.replace(/(^|\s)\/goal(?=\s|$)/gi, " ").replace(/\s+/g, " ").trim();
@@ -11584,14 +11937,21 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
   const commentInstrUsed = /* @__PURE__ */ new Map();
   const sema = new Semaphore(getMaxConcurrentRuns(cfg));
   const currentIdleMs = () => getRunIdleTimeoutMs(cfg) ?? 0;
+  const writePreferences = createAppPreferencesWriter({ cfg });
   const resumePending = /* @__PURE__ */ new Map();
   const modelPending = /* @__PURE__ */ new Map();
   const runsByCard = /* @__PURE__ */ new Map();
   const runCards = /* @__PURE__ */ new Map();
   const runStreams = /* @__PURE__ */ new Map();
+  const completionReminderRefreshers = /* @__PURE__ */ new Map();
+  const refreshCompletionReminderCards = () => {
+    for (const refresh of completionReminderRefreshers.values()) refresh();
+  };
+  const completionReminderSent = new RecentIdCache(4096, 24 * 60 * 6e4);
   const lastRunCard = /* @__PURE__ */ new Map();
   const lastUsage = /* @__PURE__ */ new Map();
   const seenInbound = new RecentIdCache();
+  const completionReminderView = (state) => shouldShowCompletionReminderButton(cfg) ? state.completionReminderRequested ? "requested" : "available" : void 0;
   const listModels = (be = backend) => be.listModels();
   async function addReaction(messageId, emoji) {
     try {
@@ -11899,7 +12259,12 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
           }
         }
       }
-      cur.queue.push({ text: woven, images });
+      cur.queue.push({
+        input: { text: woven, images },
+        requesterOpenId: msg.senderId,
+        requestedAt: msg.createTime || Date.now(),
+        summary: stripFileTokens(text).slice(0, 80) || void 0
+      });
       log.info("intake", "queued", { depth: cur.queue.length });
       return;
     }
@@ -11924,7 +12289,12 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
         void replyGoalBusy(msg, flat);
         return;
       }
-      existing.queue.push({ text, images: preloadedImages });
+      existing.queue.push({
+        input: { text, images: preloadedImages },
+        requesterOpenId: msg.senderId,
+        requestedAt: msg.createTime || Date.now(),
+        summary: stripFileTokens(summaryText2 ?? text).slice(0, 80) || void 0
+      });
       log.info("intake", "queued", { depth: existing.queue.length });
       return;
     }
@@ -12000,7 +12370,9 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
           firstText,
           images,
           knownThreadId: sessionKey,
+          summary: stripFileTokens(summaryText2 ?? text).slice(0, 80) || "(\u672C\u8F6E\u4EFB\u52A1)",
           requesterOpenId: msg.senderId,
+          requestedAt: msg.createTime || tIntake,
           // 编织完成 → turn/start 之间不再读盘：首轮直接用预取的会话记录
           // （prior=undefined 即确知是全新会话，刚 upsert 的记录还没有 model）。
           firstRec: prior ?? null,
@@ -12119,6 +12491,7 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
         cwd,
         summary: stripFileTokens(text).slice(0, 80) || "(\u7A7A)",
         requesterOpenId: msg.senderId,
+        requestedAt: msg.createTime || tIntake,
         roleSuffix: perm.roleSuffix,
         backendId: be.id,
         timing: { tResolve: tResolveDone - tIntake, tWeave: Date.now() - tIntake }
@@ -12483,6 +12856,35 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
     }
     st.interrupt?.();
     log.info("card", "action", { actionId: "run.stop", stopped: Boolean(st.interrupt) });
+  }).on(RC.remind, ({ evt, value }) => {
+    const key = typeof value.m === "string" ? value.m : evt.messageId;
+    if (!runAllowed(evt)) return;
+    const st = runsByCard.get(key);
+    if (!st) {
+      if (!runControlNotes.seen(`remind-ended:${key}:${evt.operator?.openId ?? ""}`)) {
+        void channel.send(evt.chatId, { markdown: "\u2139\uFE0F \u8BE5\u4EFB\u52A1\u5DF2\u7ED3\u675F\uFF0C\u65E0\u9700\u518D\u5F00\u542F\u5B8C\u6210\u63D0\u9192\u3002" }, { replyTo: evt.messageId }).catch(() => void 0);
+      }
+      log.info("card", "action", { actionId: RC.remind, ended: true });
+      return;
+    }
+    const op = evt.operator?.openId;
+    if (!isCompletionReminderRequester(op, st.requesterOpenId)) {
+      if (!runControlNotes.seen(`remind-deny:${key}:${op ?? ""}`)) {
+        void channel.send(evt.chatId, { markdown: "\u26A0\uFE0F \u4EC5\u672C\u8F6E\u53D1\u8D77\u4EBA\u53EF\u5F00\u542F\u5B8C\u6210\u63D0\u9192\u3002" }, { replyTo: evt.messageId }).catch(() => void 0);
+      }
+      log.info("card", "action", { actionId: RC.remind, denied: true });
+      return;
+    }
+    if (!shouldShowCompletionReminderButton(cfg)) {
+      completionReminderRefreshers.get(key)?.();
+      log.info("card", "action", { actionId: RC.remind, stale: true });
+      return;
+    }
+    if (!st.completionReminderRequested) {
+      st.completionReminderRequested = true;
+      completionReminderRefreshers.get(key)?.();
+    }
+    log.info("card", "action", { actionId: RC.remind, requested: true });
   }).on(RC.endGoal, ({ evt, value }) => {
     const key = typeof value.m === "string" ? value.m : evt.messageId;
     if (!runAllowed(evt)) return;
@@ -12510,12 +12912,49 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
     return m;
   };
   function applyPref(evt, mut, opts) {
-    if (!dmAdmin(evt.operator?.openId)) return;
-    const prefs = { ...cfg.preferences ?? {} };
-    mut(prefs);
-    cfg.preferences = prefs;
-    void saveConfig(cfg).catch((err) => log.fail("console", err, { phase: "save-config" }));
-    if (opts?.render !== false) void patch(evt, renderSettings);
+    if (!dmAdmin(evt.operator?.openId)) return Promise.resolve(false);
+    const saved = writePreferences(mut).then(
+      () => true,
+      (err) => {
+        log.fail("console", err, { phase: "save-config" });
+        return false;
+      }
+    );
+    if (opts?.render !== false) {
+      void patch(evt, async () => {
+        await saved;
+        return renderSettings();
+      });
+    }
+    return saved;
+  }
+  let cliEnabledTransition = Promise.resolve();
+  function setCliBridgeEnabled(evt, enabled) {
+    const run = cliEnabledTransition.then(async () => {
+      if (getCliBridgePreferences(cfg).enabled === enabled) return;
+      try {
+        if (enabled) await cliBridge?.start?.();
+        else await cliBridge?.shutdown?.();
+        const saved = await applyPref(
+          evt,
+          (p) => {
+            p.cliBridge = { ...p.cliBridge ?? {}, enabled };
+          },
+          { render: false }
+        );
+        if (!saved) {
+          if (enabled) await cliBridge?.shutdown?.();
+          else await cliBridge?.start?.();
+        }
+      } catch (err) {
+        log.fail("cli-bridge", err, { phase: enabled ? "enable" : "disable" });
+      }
+    });
+    cliEnabledTransition = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
   }
   let cliHookStatuses;
   function renderSettings() {
@@ -12537,20 +12976,36 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
   function commentBackendOptions() {
     return visibleCatalog().filter((e) => e.id === DEFAULT_BACKEND_ID || isBackendEntryInstalled(e)).map((e) => ({ id: e.id, label: e.displayName }));
   }
+  let commentSettingsRenderGeneration = 0;
   async function renderCommentSettings(notice) {
-    const comments = getCommentsConfig(cfg);
-    const models = await listModels(backendFor(comments.backend)).catch(() => []);
-    return buildCommentSettingsCard(cfg, commentBackendOptions(), models, notice);
+    ++commentSettingsRenderGeneration;
+    for (; ; ) {
+      const generation = commentSettingsRenderGeneration;
+      const comments = getCommentsConfig(cfg);
+      const models = await listModels(backendFor(comments.backend)).catch(() => []);
+      if (generation !== commentSettingsRenderGeneration) continue;
+      const latest = getCommentsConfig(cfg);
+      if (latest.backend !== comments.backend || latest.model !== comments.model || latest.effort !== comments.effort) {
+        continue;
+      }
+      const snapshot = {
+        ...cfg,
+        preferences: { ...cfg.preferences ?? {}, comments: { ...comments } }
+      };
+      return buildCommentSettingsCard(snapshot, commentBackendOptions(), models, notice);
+    }
   }
   function applyCommentsPref(evt, mut) {
     if (!dmAdmin(evt.operator?.openId)) return;
-    const prefs = { ...cfg.preferences ?? {} };
-    const comments = { ...prefs.comments ?? {} };
-    mut(comments);
-    prefs.comments = comments;
-    cfg.preferences = prefs;
-    void saveConfig(cfg).catch((err) => log.fail("console", err, { phase: "save-config" }));
-    void patch(evt, () => renderCommentSettings());
+    const saved = writePreferences((prefs) => {
+      const comments = { ...prefs.comments ?? {} };
+      mut(comments);
+      prefs.comments = comments;
+    }).catch((err) => log.fail("console", err, { phase: "save-config" }));
+    void patch(evt, async () => {
+      await saved;
+      return renderCommentSettings();
+    });
   }
   const freshMenu = (evt) => {
     patch(evt, buildDmMenuCard({ webConsoleUrl: webConsoleUrl(), version: bridgeVersion() }));
@@ -12655,7 +13110,14 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
       else if (!op) result = buildNewProjectFormCard({ name, cwd: cwdIn, error: "\u65E0\u6CD5\u8BC6\u522B\u64CD\u4F5C\u8005\u8EAB\u4EFD", backends: backends2 });
       else {
         try {
-          const p = await createProject(channel, { name, ownerOpenId: op, existingPath: cwdIn || void 0, kind, backend: backend2 });
+          const p = await createProject(channel, {
+            name,
+            ownerOpenId: op,
+            existingPath: cwdIn || void 0,
+            projectsRootDir: cfg.preferences?.projectsRootDir,
+            kind,
+            backend: backend2
+          });
           log.info("console", "new-project", { name: p.name, blank: p.blank, backend: p.backend });
           result = buildNewProjectDoneCard(p);
         } catch (err) {
@@ -12683,7 +13145,16 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
       else if (!op) result = buildJoinGroupFormCard({ chatId, name, cwd: cwdIn, error: "\u65E0\u6CD5\u8BC6\u522B\u64CD\u4F5C\u8005\u8EAB\u4EFD", backends: backends2 });
       else {
         try {
-          const p = await joinExistingGroup(channel, { name, chatId, addedBy: op, existingPath: cwdIn || void 0, kind, backend: backend2, mode: bindModeFor(backend2) });
+          const p = await joinExistingGroup(channel, {
+            name,
+            chatId,
+            addedBy: op,
+            existingPath: cwdIn || void 0,
+            projectsRootDir: cfg.preferences?.projectsRootDir,
+            kind,
+            backend: backend2,
+            mode: bindModeFor(backend2)
+          });
           log.info("console", "join-group", { name: p.name, blank: p.blank, backend: p.backend, mode: p.mode });
           result = buildNewProjectDoneCard(p);
         } catch (err) {
@@ -12702,26 +13173,15 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
     if (dmAdmin(evt.operator?.openId)) await patch(evt, renderSettings);
   }).on(DM.coffeeSettings, async ({ evt }) => {
     if (dmAdmin(evt.operator?.openId)) await patch(evt, () => renderCoffeeSettings(true));
-  }).on(CLI.toggleEnabled, async ({ evt, value }) => {
+  }).on(CLI.toggleEnabled, ({ evt, value }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     const enabled = value.v === "on";
     if (enabled && !canEnableCliBridge(cfg).ok) return;
-    try {
-      if (enabled) {
-        await cliBridge?.start?.();
-        applyPref(evt, (p) => {
-          p.cliBridge = { ...p.cliBridge ?? {}, enabled: true };
-        }, { render: false });
-      } else {
-        applyPref(evt, (p) => {
-          p.cliBridge = { ...p.cliBridge ?? {}, enabled: false };
-        }, { render: false });
-        await cliBridge?.shutdown?.();
-      }
-    } catch (err) {
-      log.fail("cli-bridge", err, { phase: enabled ? "enable" : "disable" });
-    }
-    void patch(evt, renderCoffeeSettings);
+    const transition = setCliBridgeEnabled(evt, enabled);
+    void patch(evt, async () => {
+      await transition;
+      return renderCoffeeSettings();
+    });
   }).on(CLI.repairHooks, async ({ evt }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     try {
@@ -12736,27 +13196,36 @@ function createOrchestrator(channel, cfg, fallbackCwd, cliBridge) {
   }).on(CLI.setNotifyScope, ({ evt, value }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     const scope = value.v === "bound_projects" || value.v === "none" ? value.v : "all";
-    applyPref(evt, (p) => {
+    const saved = applyPref(evt, (p) => {
       p.cliBridge = { ...p.cliBridge ?? {}, notifyScope: scope };
     }, { render: false });
-    void patch(evt, renderCoffeeSettings);
+    void patch(evt, async () => {
+      await saved;
+      return renderCoffeeSettings();
+    });
   }).on(CLI.toggleAgent, ({ evt, value }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     const agent = value.agent === "codex" ? "codex" : "claude";
     const on = value.v === "on";
-    applyPref(evt, (p) => {
+    const saved = applyPref(evt, (p) => {
       const cur = p.cliBridge ?? {};
       p.cliBridge = { ...cur, agents: { ...cur.agents ?? {}, [agent]: on } };
     }, { render: false });
-    void patch(evt, renderCoffeeSettings);
+    void patch(evt, async () => {
+      await saved;
+      return renderCoffeeSettings();
+    });
   }).on(CLI.toggleKeepAwake, ({ evt, value }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     const on = value.v === "on";
-    applyPref(evt, (p) => {
+    const saved = applyPref(evt, (p) => {
       const cur = p.cliBridge ?? {};
       p.cliBridge = { ...cur, keepAwake: { ...cur.keepAwake ?? {}, enabled: on } };
     }, { render: false });
-    void patch(evt, renderCoffeeSettings);
+    void patch(evt, async () => {
+      await saved;
+      return renderCoffeeSettings();
+    });
   }).on(DM.doctor, async ({ evt }) => {
     if (!dmAdmin(evt.operator?.openId)) return;
     await sendManagedCard(channel, evt.chatId, buildDoctorCard(await buildDoctorInfo()), evt.messageId).catch(
@@ -12925,6 +13394,52 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
     }
     const sec = n === 0 ? 0 : Math.min(Math.max(Math.floor(n), RUN_IDLE_TIMEOUT_MIN_SEC), RUN_IDLE_TIMEOUT_MAX_SEC);
     applyPref(evt, (p) => p.runIdleTimeoutSeconds = sec);
+  }).on(DM.setCompletionReminder, ({ evt, value }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const mode = value.v;
+    if (mode !== "manual" && mode !== "long" && mode !== "failures" && mode !== "always") return;
+    const saved = performSetCompletionReminder({
+      cfg,
+      mode,
+      writePreferences
+    }).then(
+      (result) => {
+        if (!result.ok) log.warn("console", "completion-reminder-rejected", { reason: result.reason });
+        else refreshCompletionReminderCards();
+      },
+      (err) => log.fail("console", err, { phase: "save-config" })
+    );
+    void patch(evt, async () => {
+      await saved;
+      return renderSettings();
+    });
+  }).on(DM.completionReminderCustom, ({ evt }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    void patch(evt, buildCompletionReminderCustomCard(cfg));
+  }).on(DM.completionReminderCustomSubmit, ({ evt, formValue }) => {
+    if (!dmAdmin(evt.operator?.openId)) return;
+    const raw = String(formValue?.minutes ?? "").trim();
+    const minutes = Number(raw);
+    if (!Number.isInteger(minutes) || minutes < COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES || minutes > COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES) {
+      void patch(evt, buildCompletionReminderCustomCard(cfg));
+      return;
+    }
+    const saved = performSetCompletionReminder({
+      cfg,
+      mode: "long",
+      longTaskMinutes: minutes,
+      writePreferences
+    }).then(
+      (result) => {
+        if (!result.ok) log.warn("console", "completion-reminder-rejected", { reason: result.reason });
+        else refreshCompletionReminderCards();
+      },
+      (err) => log.fail("console", err, { phase: "save-config" })
+    );
+    void patch(evt, async () => {
+      await saved;
+      return renderSettings();
+    });
   }).on(DM.setPending, ({ evt, value }) => {
     if (value.v === "steer" || value.v === "queue") applyPref(evt, (p) => p.pendingPolicy = value.v);
   }).on(DM.setConcurrency, ({ evt, value }) => {
@@ -13080,11 +13595,12 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
     log.info("console", "admin-add", { picked: id?.slice(-6) ?? null });
     void (async () => {
       if (id) {
-        const access = { ...cfg.preferences?.access ?? {} };
-        access.ownerOpenId ??= resolveOwner(cfg);
-        access.admins = Array.from(/* @__PURE__ */ new Set([...access.admins ?? [], id]));
-        cfg.preferences = { ...cfg.preferences ?? {}, access };
-        await saveConfig(cfg).catch((e) => log.fail("console", e, { phase: "save-config" }));
+        await writePreferences((preferences) => {
+          const access = { ...preferences.access ?? {} };
+          access.ownerOpenId ??= resolveOwner(cfg);
+          access.admins = Array.from(/* @__PURE__ */ new Set([...access.admins ?? [], id]));
+          preferences.access = access;
+        }).catch((e) => log.fail("console", e, { phase: "save-config" }));
       }
       const ids = [resolveOwner(cfg), ...cfg.preferences?.access?.admins ?? []];
       const next = buildAdminsCard(cfg, await namesWithOperator(evt, ids));
@@ -13095,11 +13611,12 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
     const id = typeof value.u === "string" ? value.u : "";
     patch(evt, async () => {
       if (id && id !== resolveOwner(cfg)) {
-        const access = { ...cfg.preferences?.access ?? {} };
-        access.ownerOpenId ??= resolveOwner(cfg);
-        access.admins = (access.admins ?? []).filter((x) => x !== id);
-        cfg.preferences = { ...cfg.preferences ?? {}, access };
-        await saveConfig(cfg).catch((e) => log.fail("console", e, { phase: "save-config" }));
+        await writePreferences((preferences) => {
+          const access = { ...preferences.access ?? {} };
+          access.ownerOpenId ??= resolveOwner(cfg);
+          access.admins = (access.admins ?? []).filter((x) => x !== id);
+          preferences.access = access;
+        }).catch((e) => log.fail("console", e, { phase: "save-config" }));
       }
       const ids = [resolveOwner(cfg), ...cfg.preferences?.access?.admins ?? []];
       return buildAdminsCard(cfg, await namesWithOperator(evt, ids));
@@ -13324,22 +13841,36 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
       settleUpdate(evt.messageId, buildResumeErrorCard(state, err instanceof Error ? err.message : String(err)));
     }
   }
+  async function sendCompletionReminder(input2) {
+    await sendCompletionReminderReply({ channel, cfg, dedupe: completionReminderSent }, input2);
+  }
   async function acquireRunSlot(opts, state, activeKey, reaction) {
     if (sema.hasFree()) return { release: await sema.acquire() };
     const stream2 = new RunCardStream();
     let msgId;
+    const queueCard = (input2) => buildQueuedCard({
+      ...input2,
+      ...!state.isGoal ? { completionReminder: completionReminderView(state) } : {}
+    });
     const q = sema.enqueue((pos) => {
-      if (msgId) stream2.streamCoalesced(channel, buildQueuedCard({ position: pos, cardKey: msgId }), null);
+      if (msgId) stream2.streamCoalesced(channel, queueCard({ position: pos, cardKey: msgId }), null);
     });
     try {
-      msgId = await stream2.create(channel, opts.chatId, buildQueuedCard({ position: q.position() }), {
+      msgId = await stream2.create(channel, opts.chatId, queueCard({ position: q.position() }), {
         replyTo: opts.replyTo,
         replyInThread: opts.flat ? false : opts.replyInThread ?? Boolean(opts.knownThreadId)
       });
       const pos = q.position();
-      if (pos > 0) await stream2.updateCard(channel, buildQueuedCard({ position: pos, cardKey: msgId }));
+      if (pos > 0) await stream2.updateCard(channel, queueCard({ position: pos, cardKey: msgId }));
       runsByCard.set(msgId, state);
       runStreams.set(msgId, stream2);
+      if (!state.isGoal) {
+        const key = msgId;
+        completionReminderRefreshers.set(key, () => {
+          const currentPos = q.position();
+          if (currentPos > 0) void stream2.updateLiveCard(channel, queueCard({ position: currentPos, cardKey: key }));
+        });
+      }
     } catch (err) {
       log.fail("card", err, { phase: "queued-card" });
     }
@@ -13352,7 +13883,8 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
       if (msgId) {
         runsByCard.delete(msgId);
         runStreams.delete(msgId);
-        void stream2.updateCard(channel, buildQueuedCard({ cancelled: true, dropped: state.queue.length }));
+        completionReminderRefreshers.delete(msgId);
+        void stream2.updateCard(channel, queueCard({ cancelled: true, dropped: state.queue.length }));
       }
       reaction?.done();
       log.info("card", "action", { actionId: "run.stop", queuedCancel: true });
@@ -13407,10 +13939,17 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
     let intake = opts.timing;
     let firstRec = opts.firstRec;
     try {
-      let turnInput = { text: opts.firstText, images: opts.images };
+      let currentTurn = {
+        input: { text: opts.firstText, images: opts.images },
+        requesterOpenId: opts.requesterOpenId,
+        requestedAt: opts.requestedAt ?? Date.now(),
+        summary: opts.summary
+      };
       let replyTo = opts.replyTo;
       let replyInThread = opts.flat ? false : opts.replyInThread ?? Boolean(opts.knownThreadId);
       for (; ; ) {
+        const turnInput = currentTurn.input;
+        state.requesterOpenId = currentTurn.requesterOpenId;
         const rec = firstRec !== void 0 ? firstRec ?? void 0 : topicThreadId ? await getSession(topicThreadId) : void 0;
         firstRec = void 0;
         const turnModel = rec?.model ?? opts.model;
@@ -13424,8 +13963,9 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
         let cardMsgId;
         const rc = {
           rs: render.snapshot(),
-          requesterOpenId: opts.requesterOpenId,
+          requesterOpenId: currentTurn.requesterOpenId,
           showTools: render.showTools,
+          completionReminder: completionReminderView(state),
           // 模型显示档位：footnote 本轮 model·推理强度；always 档终态卡也保留。
           ...modelDisp !== "off" && turnModel ? { model: turnModel, effort: turnEffort, modelOnTerminal: modelDisp === "always" } : {}
         };
@@ -13469,6 +14009,11 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
         rc.cardKey = cardMsgId;
         runsByCard.set(cardMsgId, state);
         runStreams.set(cardMsgId, stream2);
+        completionReminderRefreshers.set(cardMsgId, () => {
+          rc.completionReminder = completionReminderView(state);
+          void stream2.updateLiveCard(channel, buildRunCard(rc));
+        });
+        stream2.streamCoalesced(channel, buildRunCard(rc), ANSWER_EID);
         await adoptThreadId(cardMsgId);
         if (!firstCardSent) {
           firstCardSent = true;
@@ -13526,6 +14071,7 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           }
           render.apply(ev);
           rc.rs = render.snapshot();
+          rc.completionReminder = completionReminderView(state);
           stream2.streamCoalesced(channel, buildRunCard(rc), ANSWER_EID);
         }
         const doneAt = Date.now();
@@ -13534,12 +14080,15 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
         state.interrupt = void 0;
         const interrupted = stopper.interrupted();
         const killed = timedOut || interrupted && stopper.forced();
-        if (interrupted) render.interrupt();
-        else if (timedOut) render.timeout(Math.round(idleMs / 1e3));
-        else render.finalize();
+        const procDead = !killed && !opts.thread.isAlive();
+        settleOrdinaryTurnRender(render, {
+          interrupted,
+          timedOut,
+          idleTimeoutSeconds: Math.round(idleMs / 1e3),
+          procDead
+        });
         rc.rs = render.snapshot();
         if (interrupted) log.info("agent", "interrupt", { graceful: !stopper.forced(), threadId: topicThreadId ?? null });
-        const procDead = !killed && !opts.thread.isAlive();
         if (killed || procDead) {
           void opts.thread.close().catch(() => void 0);
           if (topicThreadId) sessions.delete(topicThreadId);
@@ -13557,7 +14106,9 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
         if (imgSources.length > 0) {
           rc.images = await uploadOutboundImages(channel, imgSources, opts.cwd ?? fallbackCwd);
         }
-        await stream2.updateCard(channel, buildRunCard(rc));
+        const manuallyRequested = Boolean(state.completionReminderRequested);
+        completionReminderRefreshers.delete(cardMsgId);
+        const terminalCardUpdated = await stream2.finalizeCard(channel, buildRunCard(rc));
         {
           const terminalAt = Date.now();
           const st = stream2.stats();
@@ -13597,6 +14148,16 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           touchSession(topicThreadId);
           await patchSession(topicThreadId, { updatedAt: Date.now() });
         }
+        await sendCompletionReminder({
+          cardMsgId: finalMsgId,
+          requesterOpenId: currentTurn.requesterOpenId,
+          outcome: rc.rs.terminal === "running" ? "done" : rc.rs.terminal,
+          requestedAt: currentTurn.requestedAt,
+          manuallyRequested,
+          summary: currentTurn.summary,
+          cardUpdated: terminalCardUpdated,
+          replyInThread: !opts.flat
+        });
         replyTo = finalMsgId;
         replyInThread = !opts.flat;
         log.info("card", "final", { terminal: render.terminal() });
@@ -13612,14 +14173,18 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           break;
         }
         if (state.queue.length === 0) break;
-        turnInput = state.queue.shift();
+        currentTurn = state.queue.shift();
+        activateQueuedTurn(state, currentTurn);
       }
     } catch (err) {
       log.fail("intake", err);
       await channel.send(opts.chatId, { markdown: `\u274C ${err instanceof Error ? err.message : String(err)}` }, { replyTo: opts.replyTo, replyInThread: !opts.flat }).catch(() => void 0);
     } finally {
       active.delete(activeKey);
-      if (curCardKey) runsByCard.delete(curCardKey);
+      if (curCardKey) {
+        runsByCard.delete(curCardKey);
+        completionReminderRefreshers.delete(curCardKey);
+      }
       if (activeKey.startsWith("pending:")) {
         void opts.thread.close().catch(() => void 0);
         log.warn("intake", "unadopted-thread-closed", { activeKey });
@@ -14198,7 +14763,11 @@ ${facts}`;
     log.info("bridge", "shutdown", { closed: live.length });
   }
   void backend.listModels().catch((err) => log.fail("agent", err, { phase: "models-prewarm" }));
-  const adminExecute = createAdminWriteExecutor({ backendFor, evictLiveSessionsForChat });
+  const executeAdminWrite = createAdminWriteExecutor({ cfg, backendFor, evictLiveSessionsForChat, writePreferences });
+  const adminExecute = async (op) => {
+    await executeAdminWrite(op);
+    if (op.kind === "setCompletionReminder") refreshCompletionReminderCards();
+  };
   return { onMessage, onComment, onBotAddedToChat, onBotRemovedFromChat, onReaction, onBotMenu, dispatcher, adminExecute, shutdown };
 }
 async function getThreadId(channel, messageId, attempts = 1) {
@@ -14398,10 +14967,9 @@ function createAdminIpcResponder(execute, send) {
 // src/admin/service.ts
 init_bots();
 init_paths();
-import { readFile as readFile13, rm as rm7 } from "fs/promises";
+import { readFile as readFile14, rm as rm7 } from "fs/promises";
 init_schema();
 init_store();
-init_schema();
 
 // src/bot/register-bot.ts
 init_store();
@@ -14571,7 +15139,7 @@ function createAdminService(deps = {}) {
   }
   async function lockFileRunState(botId) {
     try {
-      const raw = await readFile13(botPaths(botId).processesFile, "utf8");
+      const raw = await readFile14(botPaths(botId).processesFile, "utf8");
       const rec = JSON.parse(raw);
       if (typeof rec.pid === "number" && isAlive2(rec.pid)) {
         return { running: true, pid: rec.pid, startedAt: rec.startedAt };
@@ -14584,6 +15152,13 @@ function createAdminService(deps = {}) {
     const live = await deps.liveStatus?.(botId).catch(() => void 0);
     return live ?? lockFileRunState(botId);
   }
+  async function completionReminderFor(botId) {
+    try {
+      return getCompletionReminderConfig(await loadConfig(botPaths(botId).configFile));
+    } catch {
+      return getCompletionReminderConfig({});
+    }
+  }
   function executeWrite(botId, action, op) {
     if (!deps.executeWrite) throw new NotWiredYetError(action);
     return deps.executeWrite(botId, op);
@@ -14594,7 +15169,7 @@ function createAdminService(deps = {}) {
       const configured = reg.bots.some((b) => b.active !== void 0);
       const out = [];
       for (const b of reg.bots) {
-        const run = await runState(b.appId);
+        const [run, completionReminder] = await Promise.all([runState(b.appId), completionReminderFor(b.appId)]);
         out.push({
           name: b.name,
           appId: b.appId,
@@ -14606,7 +15181,8 @@ function createAdminService(deps = {}) {
           running: run.running,
           pid: run.pid,
           startedAt: run.startedAt,
-          connection: run.connection
+          connection: run.connection,
+          completionReminder
         });
       }
       return out;
@@ -14635,6 +15211,13 @@ function createAdminService(deps = {}) {
     async setAutoCompact(botId, projectName, on) {
       await executeWrite(botId, "\u{1F5DC}\uFE0F \u81EA\u52A8\u538B\u7F29\u5F00\u5173", { kind: "setAutoCompact", project: projectName, on });
     },
+    async setCompletionReminder(botId, value) {
+      await executeWrite(botId, "\u{1F514} \u5B8C\u6210\u63D0\u9192", {
+        kind: "setCompletionReminder",
+        mode: value.mode,
+        longTaskMinutes: value.longTaskMinutes
+      });
+    },
     doctorBackends() {
       return probeAllBackends();
     },
@@ -15122,6 +15705,7 @@ init_logger();
 
 // src/web/server.ts
 init_paths();
+init_schema();
 import { createServer } from "http";
 import { randomUUID as randomUUID7, timingSafeEqual } from "crypto";
 import { mkdirSync as mkdirSync3, watch } from "fs";
@@ -15706,6 +16290,11 @@ var UI_HTML = `<!doctype html>
   .drawer-mask.open { display: block; }
   .drawer h3 { margin: 0 0 4px; font-size: 16px; }
   .opt-row { display: flex; gap: 8px; margin: 6px 0 2px; flex-wrap: wrap; }
+  .compact-input {
+    width: 84px; border: 1px solid var(--border-2); border-radius: 8px; padding: 7px 9px;
+    font: 13px var(--mono); background: #0c0e0c; color: var(--text);
+  }
+  .compact-input:focus { outline: 0; border-color: var(--accent); box-shadow: 0 0 0 3px var(--accent-dim); }
   .backend-row { display: flex; align-items: center; gap: 8px; padding: 6px 0; }
   .backend-row .grow { flex: 1; min-width: 0; }
   .bk-group { margin: 6px 0 2px; }
@@ -17182,6 +17771,9 @@ ${UI_PURE_JS}
     left.appendChild(projCard);
     renderProjects(projList, pcount, b);
 
+    // \u{1F514} \u666E\u901A\u4EFB\u52A1\u7ED3\u675F\u63D0\u9192\uFF08\u6BCF bot \u72EC\u7ACB\uFF09\u3002\u9009\u62E9\u5373\u4FDD\u5B58\uFF1B\u4EC5 long \u989D\u5916\u5C55\u793A\u5206\u949F\u9608\u503C\u3002
+    renderCompletionReminderCard(right, b);
+
     cols.appendChild(left);
     cols.appendChild(right);
     root.appendChild(cols);
@@ -17253,6 +17845,58 @@ ${UI_PURE_JS}
     });
   }
 
+  function renderCompletionReminderCard(root, b) {
+    var reminder = b.completionReminder || { mode: 'failures', longTaskMinutes: 3 };
+    var card = el('div', 'card');
+    card.appendChild(el('h2', null, '\u{1F514} \u5B8C\u6210\u63D0\u9192'));
+    card.appendChild(el('div', 'note', '\u4EFB\u52A1\u7ED3\u675F\u540E\u662F\u5426\u53E6\u53D1\u4E00\u6761\u6D88\u606F @ \u53D1\u8D77\u4EBA\u3002\u6BCF\u4E2A\u673A\u5668\u4EBA\u72EC\u7ACB\u8BBE\u7F6E\uFF0C\u4FDD\u5B58\u540E\u7ACB\u5373\u751F\u6548\u3002'));
+    var modes = [
+      { label: '\u4EC5\u624B\u52A8', value: 'manual' },
+      { label: '\u957F\u4EFB\u52A1', value: 'long' },
+      { label: '\u5931\u8D25\u6216\u8D85\u65F6', value: 'failures' },
+      { label: '\u6BCF\u6B21\u7ED3\u675F', value: 'always' },
+    ];
+    card.appendChild(optButtons(modes, reminder.mode, function (mode) {
+      postWrite('/api/bots/' + encodeURIComponent(b.appId) + '/completion-reminder', {
+        mode: mode,
+        longTaskMinutes: reminder.longTaskMinutes,
+      });
+    }));
+
+    var descriptions = {
+      manual: '\u8FD0\u884C\u5361\u663E\u793A\u300C\u5B8C\u6210\u540E\u63D0\u9192\u6211\u300D\uFF0C\u53EA\u6709\u672C\u8F6E\u53D1\u8D77\u4EBA\u70B9\u8FC7\u624D\u901A\u77E5\u3002',
+      long: '\u4EFB\u52A1\u8017\u65F6\u8FBE\u5230\u9608\u503C\u540E\u901A\u77E5\uFF1B\u8FD0\u884C\u5361\u4E0D\u663E\u793A\u63D0\u9192\u6309\u94AE\u3002',
+      failures: '\u4EC5\u4EFB\u52A1\u5931\u8D25\u6216\u5047\u6B7B\u8D85\u65F6\u65F6\u901A\u77E5\uFF1B\u8FD0\u884C\u5361\u4E0D\u663E\u793A\u63D0\u9192\u6309\u94AE\u3002',
+      always: '\u6BCF\u6B21\u6B63\u5E38\u7ED3\u675F\u3001\u5931\u8D25\u6216\u8D85\u65F6\u90FD\u901A\u77E5\uFF1B\u8FD0\u884C\u5361\u4E0D\u663E\u793A\u63D0\u9192\u6309\u94AE\u3002',
+    };
+    card.appendChild(el('div', 'note', descriptions[reminder.mode] || descriptions.failures));
+
+    if (reminder.mode === 'long') {
+      var threshold = el('div', 'statline');
+      threshold.appendChild(el('span', null, '\u957F\u4EFB\u52A1\u9608\u503C'));
+      var input = el('input', 'compact-input');
+      input.type = 'number'; input.min = '1'; input.max = '1440'; input.step = '1';
+      input.value = String(reminder.longTaskMinutes);
+      input.setAttribute('aria-label', '\u957F\u4EFB\u52A1\u9608\u503C\uFF08\u5206\u949F\uFF09');
+      threshold.appendChild(input);
+      threshold.appendChild(el('span', 'note', '\u5206\u949F\uFF081\u20131440\uFF09'));
+      var save = el('button', 'btn primary sm', '\u4FDD\u5B58\u9608\u503C');
+      save.onclick = function () {
+        var minutes = Number(input.value);
+        if (!Number.isInteger(minutes) || minutes < 1 || minutes > 1440) {
+          toast('\u274C \u957F\u4EFB\u52A1\u9608\u503C\u8BF7\u8F93\u5165 1\u20131440 \u7684\u6574\u6570\u5206\u949F');
+          return;
+        }
+        postWrite('/api/bots/' + encodeURIComponent(b.appId) + '/completion-reminder', {
+          mode: 'long', longTaskMinutes: minutes,
+        });
+      };
+      threshold.appendChild(save);
+      card.appendChild(threshold);
+    }
+    root.appendChild(card);
+  }
+
   function renderProjects(box, countEl, b) {
     box.textContent = '';
     var projects = (b && b.projects) || [];
@@ -17873,6 +18517,7 @@ var LOGO_PNG = Buffer.from(LOGO_PNG_BASE64, "base64");
 var DEFAULT_WEB_PORT = 51847;
 var COOKIE_NAME = "fcb_console_token";
 var SSE_INITIAL_TAIL_BYTES = 16 * 1024;
+var COMPLETION_REMINDER_MODES2 = ["manual", "long", "failures", "always"];
 function createWebServer(opts) {
   const token = opts.token ?? randomUUID7();
   const html = opts.html ?? UI_HTML;
@@ -18048,6 +18693,45 @@ function createWebServer(opts) {
       sendJson(res, 200, status);
       return;
     }
+    const completionReminderMatch = /^\/api\/bots\/([^/]+)\/completion-reminder$/.exec(pathName);
+    if (req.method === "POST" && completionReminderMatch) {
+      let body;
+      try {
+        body = await readJsonBody(req);
+      } catch {
+        sendJson(res, 400, { error: "bad_body", message: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F JSON" });
+        return;
+      }
+      const mode = body.mode;
+      const minutes = body.longTaskMinutes;
+      if (!COMPLETION_REMINDER_MODES2.includes(mode)) {
+        sendJson(res, 400, { error: "invalid_input", message: "mode \u5FC5\u987B\u662F manual / long / failures / always" });
+        return;
+      }
+      if (typeof minutes !== "number" || !Number.isInteger(minutes) || minutes < COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES || minutes > COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES) {
+        sendJson(res, 400, {
+          error: "invalid_input",
+          message: `longTaskMinutes \u5FC5\u987B\u662F ${COMPLETION_REMINDER_LONG_TASK_MIN_MINUTES}\u2013${COMPLETION_REMINDER_LONG_TASK_MAX_MINUTES} \u4E4B\u95F4\u7684\u6574\u6570`
+        });
+        return;
+      }
+      try {
+        await opts.service.setCompletionReminder(decodeURIComponent(completionReminderMatch[1]), {
+          mode,
+          longTaskMinutes: minutes
+        });
+        sendJson(res, 200, { ok: true, completionReminder: { mode, longTaskMinutes: minutes } });
+      } catch (err) {
+        if (err instanceof NotWiredYetError) {
+          sendJson(res, 501, { error: "not_wired_yet", message: err.message });
+        } else if (err instanceof AdminWriteError) {
+          sendJson(res, 409, { error: "write_rejected", message: err.message });
+        } else {
+          throw err;
+        }
+      }
+      return;
+    }
     const botMatch = /^\/api\/bots\/([^/]+)$/.exec(pathName);
     if (req.method === "PATCH" && botMatch) {
       const appId = decodeURIComponent(botMatch[1]);