larkin 0.4.13 → 0.4.15

package/dist/feishu/host-business-state.mjs

@@ -302,31 +302,50 @@ export class HostEnvelopeProjector {
     }
     createReminderEnvelope(agentId, reminder, overdueMs, repeatDescription) {
         const seq = this.nextSequence(agentId);
-        const anchorMessageId = typeof reminder.msgRef === "string" && /^om_[A-Za-z0-9_-]+$/.test(reminder.msgRef)
-            ? reminder.msgRef
-            : null;
+        const legacyChannel = typeof reminder.channel === "string" ? reminder.channel.trim() : "";
+        const legacyChatTarget = /^oc_[A-Za-z0-9_-]+$/.test(legacyChannel) ? `chat:${legacyChannel}` : null;
+        const deliveryTarget = typeof reminder.deliveryTarget === "string" && reminder.deliveryTarget
+            ? reminder.deliveryTarget : legacyChatTarget;
+        const anchorMessageId = typeof reminder.deliveryAnchor === "string" && /^om_[A-Za-z0-9_-]+$/.test(reminder.deliveryAnchor)
+            ? reminder.deliveryAnchor
+            : typeof reminder.msgRef === "string" && /^om_[A-Za-z0-9_-]+$/.test(reminder.msgRef)
+                ? reminder.msgRef
+                : null;
+        const commentAnchorId = deliveryTarget?.startsWith("document-comment:") && typeof reminder.deliveryAnchor === "string"
+            && /^doc_comment_[A-Za-z0-9_-]+$/.test(reminder.deliveryAnchor) ? reminder.deliveryAnchor : null;
+        const anchorId = anchorMessageId || commentAnchorId;
+        const chatId = deliveryTarget?.match(/^chat:(oc_[A-Za-z0-9_-]+)$/)?.[1] || null;
         const lines = [
             `[定时提醒触发] ${reminder.title}`,
             `提醒ID: #${reminder.reminderId.slice(0, 8)}` + (reminder.repeat && repeatDescription
                 ? `　重复: ${repeatDescription}（下次已自动排在 ${reminder.fireAt}）`
                 : "　类型: 一次性"),
             overdueMs > 120_000 ? `注意: 原定时间已过 ${Math.round(overdueMs / 60_000)} 分钟（Runtime Host 离线期间错过，现补触发）` : null,
-            anchorMessageId ? `锚定消息: ${anchorMessageId}` : reminder.msgRef ? `历史锚点 ${String(reminder.msgRef)} 不是飞书 om_ message_id，不能用于回复` : null,
+            deliveryTarget ? `原始 deliveryTarget: ${deliveryTarget}`
+                : anchorId ? "这是升级前存量 user-facing reminder，优先回复其安全锚点；不得向标题中的任何人或第三方发送消息"
+                    : "本条为 internal/no-delivery reminder，不得向标题中的任何人或第三方发送消息",
+            anchorId ? `锚定消息: ${anchorId}` : reminder.msgRef ? `历史锚点 ${String(reminder.msgRef)} 不是可用的 delivery anchor，不能用于回复` : null,
             anchorMessageId
-                ? `回复原会话: ${this.larkCommand(`im +messages-reply --message-id ${anchorMessageId} ...`)}`
-                : null,
-            reminder.channel && /^oc_[A-Za-z0-9_-]+$/.test(reminder.channel)
-                ? `发送到原群: ${this.larkCommand(`im +messages-send --chat-id ${reminder.channel} ...`)}`
-                : reminder.channel
-                    ? `历史目标 ${reminder.channel} 不是 chat_id；${anchorMessageId ? "若不回复锚定消息，" : ""}先用 ${this.larkCommand("im +chat-search")} 查询并确认 oc_ chat_id，禁止按名称猜测发送目标`
-                    : anchorMessageId
-                        ? null
-                        : `本条存量提醒缺少可用的飞书 message_id/chat_id，无法安全推断原会话；请先用 ${this.larkCommand("im +chat-search")} 确认目标，禁止猜测发送`,
+                ? [
+                    `回复原会话: ${this.larkCommand(`im +messages-reply --message-id ${anchorMessageId}${deliveryTarget?.startsWith("thread:") ? " --reply-in-thread" : ""} ...`)}`,
+                    chatId ? `若 ${anchorMessageId} 无法由当前 Inbox 解析（例如 interaction_* 卡片锚点或已淘汰的历史消息），改用聊天兜底发送: ${this.larkCommand(`im +messages-send --chat-id ${chatId} ...`)}；仅使用这个持久化 chat_id，不得猜测收件人` : null,
+                ].filter((line) => Boolean(line)).join("\n")
+                : commentAnchorId
+                    ? `回复原文档评论: ${this.agentCommand(`comment reply --message-id ${commentAnchorId} --text ...`)}`
+                    : deliveryTarget
+                        ? chatId
+                            ? `发送到原始 target: ${deliveryTarget}: ${this.larkCommand(`im +messages-send --chat-id ${chatId} ...`)}（不得从提醒标题推断收件人）`
+                            : `发送到原始 target: ${deliveryTarget}（不得从提醒标题推断收件人）`
+                        : null,
             `这是你之前用 ${this.agentCommand("reminder schedule")} 设置的提醒，请按标题执行相应动作。管理: ${this.agentCommand("reminder list")} / ${this.agentCommand("reminder snooze")} / ${this.agentCommand("reminder cancel")}`,
         ].filter((line) => Boolean(line));
         const envelope = {
             kind: "reminder",
-            message_id: `rem_${reminder.reminderId.slice(0, 16)}_${seq}`,
+            // The random suffix keeps each firing's occurrence identity unique across
+            // Host restarts: the in-memory seq restarts at 1 and would otherwise let a
+            // recurring reminder reuse a prior occurrenceId in the delivery audit.
+            message_id: `rem_${reminder.reminderId.slice(0, 16)}_${seq}_${this.randomHex(6)}`,
+            reminderId: reminder.reminderId,
             seq,
             sender_name: "定时提醒",
             sender_type: "system",
@@ -336,6 +355,8 @@ export class HostEnvelopeProjector {
             timestamp: this.now().toISOString(),
             thread_id: null,
             wake: true,
+            deliveryTarget,
+            deliveryAnchor: anchorId,
         };
         return { ...envelope, target: RUNTIME_REMINDER_TARGET };
     }

package/dist/feishu/interaction-orchestrator.cjs

@@ -93,6 +93,8 @@ class HostInteractionOrchestrator {
             const reminderId = `int_${(0, node_crypto_1.createHash)("sha256").update(run.run_id).digest("hex").slice(0, 24)}`;
             const current = this.now();
             const fireAt = effect.args.fire_at ? Date.parse(effect.args.fire_at) : current + Number(effect.args.delay_seconds) * 1_000;
+            const deliveryTarget = typeof run.chat_id === "string" && run.chat_id ? `chat:${run.chat_id}` : null;
+            const deliveryAnchor = typeof run.message_id === "string" && /^om_[A-Za-z0-9_-]+$/.test(run.message_id) ? run.message_id : null;
             const reminder = ReminderStore.mutate(file, (store) => {
                 const existing = store.reminders.find((candidate) => candidate.reminderId === reminderId);
                 if (existing)
@@ -107,6 +109,9 @@ class HostInteractionOrchestrator {
                     status: "scheduled",
                     msgRef: run.message_id,
                     msgPermalink: null,
+                    deliveryTarget,
+                    deliveryAnchor,
+                    deliveryMode: "user",
                     repeat: null,
                     tz: null,
                     channel: run.chat_id,
@@ -114,7 +119,9 @@ class HostInteractionOrchestrator {
                     version: 1,
                     events: [],
                 };
-                ReminderStore.appendEvent(created, "scheduled", "interaction", run.run_id, created.fireAt, current);
+                ReminderStore.appendEvent(created, "scheduled", "interaction", run.run_id, created.fireAt, current, {
+                    deliveryTarget, deliveryAnchor, deliveryMode: "user",
+                });
                 store.reminders.push(created);
                 return created;
             }, Math.max(1, Math.min(350, deadline - this.now() - 100)));

package/dist/feishu/interaction-orchestrator.mjs

@@ -57,6 +57,8 @@ export class HostInteractionOrchestrator {
             const reminderId = `int_${createHash("sha256").update(run.run_id).digest("hex").slice(0, 24)}`;
             const current = this.now();
             const fireAt = effect.args.fire_at ? Date.parse(effect.args.fire_at) : current + Number(effect.args.delay_seconds) * 1_000;
+            const deliveryTarget = typeof run.chat_id === "string" && run.chat_id ? `chat:${run.chat_id}` : null;
+            const deliveryAnchor = typeof run.message_id === "string" && /^om_[A-Za-z0-9_-]+$/.test(run.message_id) ? run.message_id : null;
             const reminder = ReminderStore.mutate(file, (store) => {
                 const existing = store.reminders.find((candidate) => candidate.reminderId === reminderId);
                 if (existing)
@@ -71,6 +73,9 @@ export class HostInteractionOrchestrator {
                     status: "scheduled",
                     msgRef: run.message_id,
                     msgPermalink: null,
+                    deliveryTarget,
+                    deliveryAnchor,
+                    deliveryMode: "user",
                     repeat: null,
                     tz: null,
                     channel: run.chat_id,
@@ -78,7 +83,9 @@ export class HostInteractionOrchestrator {
                     version: 1,
                     events: [],
                 };
-                ReminderStore.appendEvent(created, "scheduled", "interaction", run.run_id, created.fireAt, current);
+                ReminderStore.appendEvent(created, "scheduled", "interaction", run.run_id, created.fireAt, current, {
+                    deliveryTarget, deliveryAnchor, deliveryMode: "user",
+                });
                 store.reminders.push(created);
                 return created;
             }, Math.max(1, Math.min(350, deadline - this.now() - 100)));

package/dist/feishu/outbound-transport.cjs

@@ -155,16 +155,30 @@ function createOutboundTransport(options) {
     };
     const handleSend = (body) => {
         const target = body.target || "";
+        const targetKey = String(target);
+        const report = (succeeded, details = {}) => {
+            if (options.dryRun)
+                return;
+            try {
+                options.onDeliveryOutcome?.({ target: targetKey, succeeded, ...details });
+            }
+            catch (error) {
+                options.log("delivery outcome hook 失败:", error.message);
+            }
+        };
         const content = String(body.content ?? "").replace(/\n+$/, "");
         const chatId = options.resolveChatId(target);
         if (!chatId) {
-            return { ok: false, status: 400, error: `该 target 没有已知 chat_id：${JSON.stringify(target)}。只能回复 canonical Inbox 给出的确切会话；不会兜底发往默认群。` };
+            const error = `该 target 没有已知 chat_id：${JSON.stringify(target)}。只能回复 canonical Inbox 给出的确切会话；不会兜底发往默认群。`;
+            report(false, { reason: error });
+            return { ok: false, status: 400, error };
         }
         const idempotencyKey = body.idempotencyKey
             || node_crypto_1.default.createHash("sha256").update(`${String(target)}\0${content}`).digest("hex").slice(0, 32);
         const replyContext = options.replyContextFor(String(target)) || options.replyContextFor(chatId);
         const attachmentIds = Array.isArray(body.attachmentIds) ? body.attachmentIds.filter(Boolean) : [];
         let messageId = "sent";
+        let committedProviderCalls = 0;
         if (content !== "" || attachmentIds.length === 0) {
             const replyInThread = Boolean(replyContext?.in_topic && replyContext.reply_to);
             const result = replyInThread
@@ -172,7 +186,9 @@ function createOutboundTransport(options) {
                 : options.sendText(chatId, content, idempotencyKey);
             if (result.code !== 0) {
                 options.log("send 失败 FULL:", `${result.stdout || ""} || ${result.stderr || ""}`);
-                return { ok: false, status: 502, error: `lark-cli send failed: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}` };
+                const error = `lark-cli send failed: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}`;
+                report(false, { reason: error });
+                return { ok: false, status: 502, error };
             }
             try {
                 const parsed = JSON.parse(result.stdout);
@@ -181,8 +197,10 @@ function createOutboundTransport(options) {
             catch {
                 messageId = options.dryRun ? "dryrun" : "sent";
             }
+            committedProviderCalls += 1;
             options.log(`${replyInThread ? "reply-in-thread" : "send"} → chat=${chatId} len=${content.length} id=${messageId}${options.dryRun ? " (dry-run)" : ""}`);
         }
+        const missingAttachmentIds = [];
         if (attachmentIds.length) {
             const index = loadAttachmentIndex();
             for (let position = 0; position < attachmentIds.length; position += 1) {
@@ -190,21 +208,34 @@ function createOutboundTransport(options) {
                 const attachment = index[attachmentId];
                 if (!attachment) {
                     options.log(`attachment 未找到 id=${attachmentId}（跳过）`);
+                    missingAttachmentIds.push(attachmentId);
                     continue;
                 }
                 const result = options.sendMedia(chatId, replyContext, attachment, `${idempotencyKey}:a${position}`);
                 if (result.code !== 0) {
                     options.log("attachment 发送失败 FULL:", `${result.stdout || ""} || ${result.stderr || ""}`);
-                    return { ok: false, status: 502, error: `lark-cli 发送附件失败: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}` };
+                    const error = `lark-cli 发送附件失败: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}`;
+                    report(false, { reason: error });
+                    return { ok: false, status: 502, error };
                 }
                 try {
                     const parsed = JSON.parse(result.stdout);
                     messageId = parsed?.data?.message_id || messageId;
                 }
                 catch { /* retain prior message id */ }
+                committedProviderCalls += 1;
                 options.log(`attach → chat=${chatId} name=${attachment.filename} id=${messageId}${options.dryRun ? " (dry-run)" : ""}`);
             }
         }
+        // Empty content plus attachment IDs that are all absent from the index
+        // reaches this point without any provider call; claiming success here would
+        // record delivery_succeeded for a reminder turn in which the user received
+        // nothing.
+        if (committedProviderCalls === 0) {
+            const error = `没有可发送的内容：附件不存在（${missingAttachmentIds.join(", ")}），且消息正文为空。`;
+            report(false, { reason: error });
+            return { ok: false, status: 400, error };
+        }
         options.appendConversation({
             direction: "out",
             from: options.botDisplayName() || options.agentName,
@@ -215,6 +246,9 @@ function createOutboundTransport(options) {
             messageId,
             at: new Date().toISOString(),
         });
+        // This is deliberately after every guarded provider call succeeds and after
+        // the local outbound projection, not at Runtime acceptance.
+        report(true, { messageId });
         return { ok: true, status: 200, data: { ok: true, state: "sent", messageId, messageSeq: 1 } };
     };
     return { handleSend, stageUpload };

package/dist/feishu/outbound-transport.mjs

@@ -149,16 +149,30 @@ export function createOutboundTransport(options) {
     };
     const handleSend = (body) => {
         const target = body.target || "";
+        const targetKey = String(target);
+        const report = (succeeded, details = {}) => {
+            if (options.dryRun)
+                return;
+            try {
+                options.onDeliveryOutcome?.({ target: targetKey, succeeded, ...details });
+            }
+            catch (error) {
+                options.log("delivery outcome hook 失败:", error.message);
+            }
+        };
         const content = String(body.content ?? "").replace(/\n+$/, "");
         const chatId = options.resolveChatId(target);
         if (!chatId) {
-            return { ok: false, status: 400, error: `该 target 没有已知 chat_id：${JSON.stringify(target)}。只能回复 canonical Inbox 给出的确切会话；不会兜底发往默认群。` };
+            const error = `该 target 没有已知 chat_id：${JSON.stringify(target)}。只能回复 canonical Inbox 给出的确切会话；不会兜底发往默认群。`;
+            report(false, { reason: error });
+            return { ok: false, status: 400, error };
         }
         const idempotencyKey = body.idempotencyKey
             || crypto.createHash("sha256").update(`${String(target)}\0${content}`).digest("hex").slice(0, 32);
         const replyContext = options.replyContextFor(String(target)) || options.replyContextFor(chatId);
         const attachmentIds = Array.isArray(body.attachmentIds) ? body.attachmentIds.filter(Boolean) : [];
         let messageId = "sent";
+        let committedProviderCalls = 0;
         if (content !== "" || attachmentIds.length === 0) {
             const replyInThread = Boolean(replyContext?.in_topic && replyContext.reply_to);
             const result = replyInThread
@@ -166,7 +180,9 @@ export function createOutboundTransport(options) {
                 : options.sendText(chatId, content, idempotencyKey);
             if (result.code !== 0) {
                 options.log("send 失败 FULL:", `${result.stdout || ""} || ${result.stderr || ""}`);
-                return { ok: false, status: 502, error: `lark-cli send failed: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}` };
+                const error = `lark-cli send failed: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}`;
+                report(false, { reason: error });
+                return { ok: false, status: 502, error };
             }
             try {
                 const parsed = JSON.parse(result.stdout);
@@ -175,8 +191,10 @@ export function createOutboundTransport(options) {
             catch {
                 messageId = options.dryRun ? "dryrun" : "sent";
             }
+            committedProviderCalls += 1;
             options.log(`${replyInThread ? "reply-in-thread" : "send"} → chat=${chatId} len=${content.length} id=${messageId}${options.dryRun ? " (dry-run)" : ""}`);
         }
+        const missingAttachmentIds = [];
         if (attachmentIds.length) {
             const index = loadAttachmentIndex();
             for (let position = 0; position < attachmentIds.length; position += 1) {
@@ -184,21 +202,34 @@ export function createOutboundTransport(options) {
                 const attachment = index[attachmentId];
                 if (!attachment) {
                     options.log(`attachment 未找到 id=${attachmentId}（跳过）`);
+                    missingAttachmentIds.push(attachmentId);
                     continue;
                 }
                 const result = options.sendMedia(chatId, replyContext, attachment, `${idempotencyKey}:a${position}`);
                 if (result.code !== 0) {
                     options.log("attachment 发送失败 FULL:", `${result.stdout || ""} || ${result.stderr || ""}`);
-                    return { ok: false, status: 502, error: `lark-cli 发送附件失败: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}` };
+                    const error = `lark-cli 发送附件失败: ${(result.stdout || result.stderr || "").trim().split("\n")[0]}`;
+                    report(false, { reason: error });
+                    return { ok: false, status: 502, error };
                 }
                 try {
                     const parsed = JSON.parse(result.stdout);
                     messageId = parsed?.data?.message_id || messageId;
                 }
                 catch { /* retain prior message id */ }
+                committedProviderCalls += 1;
                 options.log(`attach → chat=${chatId} name=${attachment.filename} id=${messageId}${options.dryRun ? " (dry-run)" : ""}`);
             }
         }
+        // Empty content plus attachment IDs that are all absent from the index
+        // reaches this point without any provider call; claiming success here would
+        // record delivery_succeeded for a reminder turn in which the user received
+        // nothing.
+        if (committedProviderCalls === 0) {
+            const error = `没有可发送的内容：附件不存在（${missingAttachmentIds.join(", ")}），且消息正文为空。`;
+            report(false, { reason: error });
+            return { ok: false, status: 400, error };
+        }
         options.appendConversation({
             direction: "out",
             from: options.botDisplayName() || options.agentName,
@@ -209,6 +240,9 @@ export function createOutboundTransport(options) {
             messageId,
             at: new Date().toISOString(),
         });
+        // This is deliberately after every guarded provider call succeeds and after
+        // the local outbound projection, not at Runtime acceptance.
+        report(true, { messageId });
         return { ok: true, status: 200, data: { ok: true, state: "sent", messageId, messageSeq: 1 } };
     };
     return { handleSend, stageUpload };

package/dist/runtime/pi-inline-extensions.mjs

@@ -1,8 +1,37 @@
-import subagentsExtension from "@tintinweb/pi-subagents/dist/index.js";
+import { pathToFileURL } from "node:url";
 import bashTimeoutExtension from "./pi-bash-timeout-extension.mjs";
+import { bundledPiSubagentExtensionPath } from "./pi-subagent-injection.mjs";
+/**
+ * Load the prebuilt, patched subagent bundle shipped in dist/ rather than the
+ * package-manager copy. Standalone binaries additionally load the patched
+ * package through Bun's compiled module graph, while normal package installs
+ * continue to use the prebuilt patched bundle.
+ */
+async function loadBundledPiSubagentExtension() {
+    if (process.env.LARKIN_STANDALONE === "1") {
+        const loaded = await import("@tintinweb/pi-subagents/dist/index.js");
+        if (!loaded.default)
+            throw new Error("Larkin bounded pi-subagents package is invalid; refusing to start builtin Pi");
+        return loaded.default;
+    }
+    const bundle = bundledPiSubagentExtensionPath(process.env.LARKIN_CONFIG_DIR);
+    if (!bundle)
+        throw new Error("Larkin bounded pi-subagents bundle is unavailable; refusing to start builtin Pi");
+    const loaded = await import(pathToFileURL(bundle).href);
+    if (!loaded.default)
+        throw new Error("Larkin bounded pi-subagents bundle is invalid; refusing to start builtin Pi");
+    return loaded.default;
+}
 /** Builtin Pi extensions are loaded as code, never through Pi's path/data-URL loader. */
+const bundledSubagentsExtension = async (pi) => {
+    const extension = await loadBundledPiSubagentExtension();
+    if (typeof extension === "function")
+        await extension(pi);
+    else
+        await extension.factory(pi);
+};
 export const BUILTIN_PI_EXTENSION_FACTORIES = Object.freeze([
-    subagentsExtension,
+    bundledSubagentsExtension,
     bashTimeoutExtension,
 ]);
 /** Invoke Pi RPC with Larkin's builtin-only extension factories. */

package/dist/runtime/pi-subagent-injection.mjs

@@ -81,39 +81,76 @@ export function probeExternalPiVersion(piCommand, env) {
  * 已装时 Larkin 不再 -e 注入，避免同名工具（Agent/get_subagent_result/steer_subagent）
  * 重复注册导致 pi 扩展加载 FATAL（pi 对 duplicate tool registration 是硬失败）。
  */
-export function userPiAlreadyHasSubagentsExtension(env) {
+const BOUNDED_WAIT_CAPABILITY = "larkin-pi-subagents-bounded-wait-v1";
+function userPiSubagentsWaitCapability(env) {
     const agentDir = env.PI_CODING_AGENT_DIR || path.join(env.HOME || process.env.HOME || "", ".pi", "agent");
     try {
+        let configured = false;
         const settingsFile = path.join(agentDir, "settings.json");
         if (fs.existsSync(settingsFile)) {
             const settings = JSON.parse(fs.readFileSync(settingsFile, "utf8"));
             const packages = settings?.packages;
             if (Array.isArray(packages)) {
-                for (const entry of packages) {
-                    if (typeof entry === "string" && /pi-subagents/i.test(entry))
-                        return true;
-                }
+                configured = packages.some((entry) => typeof entry === "string" && /pi-subagents/i.test(entry));
             }
         }
         // settings.json 可能未登记但包目录已存在（残留/手动安装）。
         // Split token: repo contract forbids the literal package-manager word in sources.
-        const npmDir = path.join(agentDir, "n" + "pm", "node_modules", "@tintinweb");
-        if (fs.existsSync(npmDir) && fs.readdirSync(npmDir).some((name) => /pi-subagents/i.test(name)))
-            return true;
+        const packageRoots = [
+            path.join(agentDir, "n" + "pm", "node_modules", "@tintinweb", "pi-subagents"),
+            path.join(agentDir, "node_modules", "@tintinweb", "pi-subagents"),
+        ];
+        const installedRoot = packageRoots.find((root) => fs.existsSync(root));
+        if (!configured && !installedRoot)
+            return "absent";
+        if (!installedRoot)
+            return "unbounded";
+        const packageManifest = JSON.parse(fs.readFileSync(path.join(installedRoot, "package.json"), "utf8"));
+        const extensions = packageManifest.pi?.extensions;
+        if (!Array.isArray(extensions) || extensions.length === 0
+            || !extensions.every((entry) => typeof entry === "string" && entry.length > 0)) {
+            return "unbounded";
+        }
+        // Pi executes the entries declared by the package manifest. Do not trust a
+        // marker in a build artifact when the manifest points Pi at another file.
+        const capabilityFiles = extensions.map((entry) => path.resolve(installedRoot, entry));
+        const hasCapability = capabilityFiles.every((file) => {
+            try {
+                return fs.readFileSync(file, "utf8").includes(BOUNDED_WAIT_CAPABILITY);
+            }
+            catch {
+                return false;
+            }
+        });
+        return hasCapability ? "bounded" : "unbounded";
     }
     catch {
-        /* unreadable config: assume not installed, injection stays safe */
+        // Unreadable user extension state is not safe to treat as bounded.
+        return "unbounded";
     }
-    return false;
+}
+export function userPiAlreadyHasSubagentsExtension(env) {
+    return userPiSubagentsWaitCapability(env) !== "absent";
+}
+export function userPiSubagentsHasBoundedWaitCapability(env) {
+    return userPiSubagentsWaitCapability(env) === "bounded";
 }
 export function resolvePiSubagentExtensionArg(input, probeVersion = () => probeExternalPiVersion(input.piCommand, input.env), resolveBundle = () => bundledPiSubagentExtensionPath(input.env.LARKIN_CONFIG_DIR)) {
+    // A user-installed extension wins only when it advertises the exact bounded
+    // wait capability. Check this before the bundle path so a missing Larkin
+    // asset cannot silently leave an unbounded user extension active.
+    if (userPiAlreadyHasSubagentsExtension(input.env)) {
+        if (!userPiSubagentsHasBoundedWaitCapability(input.env)) {
+            throw new Error("[larkin] WARNING: refusing external Pi because the user-installed " +
+                "pi-subagents extension is unbounded or unverifiable; remove it or install " +
+                "a version advertising larkin-pi-subagents-bounded-wait-v1.");
+        }
+        return null;
+    }
     // resolveBundle is injectable so unit tests stay environment-independent
     // (no dependency on build artifacts or the filesystem).
     const bundle = resolveBundle();
     if (!bundle)
         return null;
-    // 用户已自行安装同款扩展时跳过注入，避免工具名重复注册冲突。
-    if (userPiAlreadyHasSubagentsExtension(input.env))
-        return null;
     return piVersionSupportsSubagents(probeVersion()) ? bundle : null;
 }

package/dist/runtime/pi-subagents.bundle.js

@@ -7104,6 +7104,43 @@ function abortable(promise, signal) {
     });
   });
 }
+var RESULT_WAIT_QUEUE_POLL_MS = 50;
+var DEFAULT_RESULT_WAIT_TIMEOUT_MS = 30000;
+var MAX_RESULT_WAIT_TIMEOUT_MS = 60000;
+function normalizeResultWaitTimeout(timeoutMs) {
+  if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
+    return DEFAULT_RESULT_WAIT_TIMEOUT_MS;
+  return Math.max(1, Math.min(MAX_RESULT_WAIT_TIMEOUT_MS, Math.floor(timeoutMs)));
+}
+function waitWithDeadline(promise, timeoutMs, signal) {
+  let timer;
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2({ timedOut: true }), timeoutMs);
+  });
+  return abortable(Promise.race([
+    promise.then((value) => ({ timedOut: false, value })),
+    timeout
+  ]), signal).finally(() => {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  });
+}
+async function waitForSubagentResult(record, timeoutMs, signal) {
+  const deadline = Date.now() + timeoutMs;
+  while (record.status === "queued") {
+    const remainingMs2 = deadline - Date.now();
+    if (remainingMs2 <= 0)
+      return true;
+    await abortable(new Promise((resolve2) => setTimeout(resolve2, Math.min(RESULT_WAIT_QUEUE_POLL_MS, remainingMs2))), signal);
+  }
+  if (!record.promise)
+    return false;
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0)
+    return true;
+  return (await waitWithDeadline(record.promise, remainingMs, signal)).timedOut;
+}
+var LARKIN_BOUNDED_WAIT_CAPABILITY = "larkin-pi-subagents-bounded-wait-v1";
 function renderRunningAgentStatus(frame, statsText, activity, theme) {
   const container = new Container;
   container.addChild(new Text(theme.fg("accent", frame) + (statsText ? " " + statsText : ""), 0, 0));
@@ -7287,7 +7324,10 @@ function src_default(pi) {
   const agentActivity = new Map;
   const pendingNudges = new Map;
   const NUDGE_HOLD_MS = 200;
-  const QUEUE_WAIT_POLL_MS = Math.floor(NUDGE_HOLD_MS / 4);
+  let resultWaitConsumedInParentTurn = false;
+  pi.on("agent_start", () => {
+    resultWaitConsumedInParentTurn = false;
+  });
   function scheduleNudge(key, send, delay = NUDGE_HOLD_MS) {
     cancelNudge(key);
     pendingNudges.set(key, setTimeout(() => {
@@ -8147,6 +8187,9 @@ You will be notified when this agent completes.
       wait: Type.Optional(Type.Boolean({
         description: "If true, wait for the agent to complete before returning. Default: false."
       })),
+      timeout_ms: Type.Optional(Type.Number({
+        description: "Maximum wait in milliseconds when wait is true. Defaults to 30000 and is capped at 60000."
+      })),
       verbose: Type.Optional(Type.Boolean({
         description: "If true, include the agent's full conversation (messages + tool calls). Default: false."
       }))
@@ -8156,12 +8199,14 @@ You will be notified when this agent completes.
       if (!record) {
         return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
       }
+      if (params.wait && resultWaitConsumedInParentTurn) {
+        throw new Error("Refusing wait: true after an earlier wait began in this parent turn; yield and await the completion notification instead.");
+      }
+      let timedOut = false;
+      const waitTimeoutMs = normalizeResultWaitTimeout(params.timeout_ms);
       if (params.wait && (record.status === "running" || record.status === "queued")) {
-        while (record.status === "queued") {
-          await abortable(new Promise((resolve2) => setTimeout(resolve2, QUEUE_WAIT_POLL_MS)), signal);
-        }
-        if (record.promise)
-          await abortable(record.promise, signal);
+        resultWaitConsumedInParentTurn = true;
+        timedOut = await waitForSubagentResult(record, waitTimeoutMs, signal);
       }
       const displayName = getDisplayName(record.type);
       const duration = formatDuration(record.startedAt, record.completedAt);
@@ -8176,12 +8221,12 @@ You will be notified when this agent completes.
         statsParts.push(`Compactions: ${record.compactionCount}`);
       statsParts.push(`Duration: ${duration}`);
       let output = `Agent: ${record.id}
-` + `Type: ${displayName} | Status: ${record.status}${getStatusNote(record.status)} | ${statsParts.join(" | ")}
+` + `Type: ${displayName} | Status: ${record.status}${getStatusNote(record.status)}${timedOut ? " | timedOut: true" : ""} | ${statsParts.join(" | ")}
 ` + `Description: ${record.description}
 
 `;
-      if (record.status === "running") {
-        output += "Agent is still running. Use wait: true or check back later.";
+      if (record.status === "running" || record.status === "queued") {
+        output += timedOut ? `Agent is still ${record.status}. Wait timed out after ${waitTimeoutMs}ms; the background agent was not cancelled. Yield/end this turn and await the completion notification; do not call wait: true again.` : "Agent is still running. Use wait: true or check back later.";
       } else if (record.status === "error") {
         output += `Error: ${record.error}${partialOutputSuffix(record)}`;
       } else {
@@ -8985,6 +9030,8 @@ ${systemPrompt}
   });
 }
 export {
+  waitForSubagentResult,
   renderRunningAgentStatus,
-  src_default as default
+  src_default as default,
+  LARKIN_BOUNDED_WAIT_CAPABILITY
 };

package/dist/runtime/runtime-host.cjs

@@ -9,6 +9,7 @@ const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const agent_cli_capabilities_js_1 = require("../agent/agent-cli-capabilities.cjs");
+const reminder_delivery_audit_js_1 = require("../agent/reminder-delivery-audit.cjs");
 const inbox_projection_js_1 = require("../agent/inbox-projection.cjs");
 const api_1 = require("@opentelemetry/api");
 const provider_error_classifier_js_1 = require("./provider-error-classifier.cjs");
@@ -1071,6 +1072,33 @@ function createRuntimeHost(options) {
         agent.piProactiveCompaction = tracked;
         return tracked;
     };
+    // Reminder audit contexts are in-turn capabilities. Finalize any survivors
+    // at both turn boundaries: turn end reconciles the turn that consumed them,
+    // and turn start expires contexts left by a crashed/aborted prior turn so a
+    // direct outbound cannot be falsely attributed to a stale reminder.
+    const finalizeReminderContexts = (agent, reason) => {
+        const legacyReminder = agent.stateStore?.resolveCurrentReminders ? null : agent.stateStore?.resolveCurrentReminder?.() ?? null;
+        const reminderContexts = agent.stateStore?.resolveCurrentReminders?.() ?? (legacyReminder ? [legacyReminder] : []);
+        let reminderAuditComplete = true;
+        if (agent.stateStore?.paths?.reminders && agent.stateStore.clearCurrentReminder) {
+            for (const reminder of reminderContexts) {
+                try {
+                    (0, reminder_delivery_audit_js_1.auditReminderDelivery)({ stateStore: agent.stateStore, agentId: agent.config.agentId,
+                        reminderId: reminder.reminderId, deliveryAnchor: reminder.deliveryAnchor, target: reminder.deliveryTarget,
+                        succeeded: reminder.deliveryCommitted === true, finalize: true,
+                        ...(reminder.deliveryMessageId ? { messageId: reminder.deliveryMessageId } : {}),
+                        ...(!reminder.deliveryCommitted ? { reason } : {}) });
+                }
+                catch {
+                    // Retain the context if the failure could not be durably recorded;
+                    // a later matching outbound or turn can reconcile it.
+                    reminderAuditComplete = false;
+                }
+            }
+        }
+        if (reminderAuditComplete)
+            agent.stateStore?.clearCurrentReminders?.();
+    };
     const observe = (agent, session, event) => {
         if (agent.session !== session)
             return; // Ignore late output from a replaced child.
@@ -1113,6 +1141,10 @@ function createRuntimeHost(options) {
                 ...(event.model ? { model: event.model } : {}), ...(event.reasoningEffort ? { reasoningEffort: event.reasoningEffort } : {}) });
         }
         else if (event.type === "turn-start") {
+            // Clear a source left by a crashed/aborted prior turn before a new turn
+            // can execute a direct task without an Inbox poll.
+            agent.stateStore?.clearCurrentInboxSource?.();
+            finalizeReminderContexts(agent, "Runtime turn started before a prior turn reconciled this reminder delivery");
             agent.busy = true;
             agent.turnInProgress = true;
             agent.turnHadFailure = false;
@@ -1134,6 +1166,11 @@ function createRuntimeHost(options) {
             agent.busy = false;
             emit({ type: "activity", agentId: agent.config.agentId, activity: "idle", activityKind: "idle", detailKind: "turn_ended" });
             reconcileAcceptedAtTurnEnd(agent);
+            // last_source and reminder audit contexts are in-turn capabilities,
+            // never cross-turn defaults. A later direct Runtime task must fail
+            // closed instead of inheriting a previous turn's chat or reminder.
+            agent.stateStore?.clearCurrentInboxSource?.();
+            finalizeReminderContexts(agent, "Runtime turn ended without a matching Feishu write");
             if (agent.backgroundCompletionInFlight) {
                 if (agent.turnHadFailure)
                     failBackgroundCompletionWake(agent);