@nowcrew/daemon 0.5.14 → 0.5.16

package/dist/execution-supervisor.js

@@ -1,8 +1,10 @@
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { executionBackendCapability } from "./execution-backend.js";
 const DEFAULT_ABORT_TIMEOUT_MS = 5_000;
 const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5_000;
 const DEFAULT_TASKKILL_TIMEOUT_MS = 5_000;
+const PROCESS_GROUP_POLL_MS = 10;
 function messageError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
@@ -21,6 +23,27 @@ async function waitForExit(exit, timeoutMs, pid) {
             clearTimeout(timer);
     }
 }
+async function waitForProcessGroupExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            process.kill(-pid, 0);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ESRCH")
+                return;
+            // POSIX defines EPERM here as "the process group exists, but is not signalable".
+            // It is therefore an alive observation, not a completed cleanup or an API failure.
+            if (code !== "EPERM")
+                throw error;
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Supervisor process group ${pid} did not exit within ${timeoutMs}ms`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, PROCESS_GROUP_POLL_MS));
+    }
+}
 async function withTimeout(promise, timeoutMs, phase) {
     let timer;
     try {
@@ -63,9 +86,9 @@ export async function signalSupervisorTree(pid, signal, platform = process.platf
 }
 export async function startDormantSupervisor(launch, options = {}) {
     const platform = options.platform ?? process.platform;
-    if (platform === "win32") {
-        throw new Error("Execution supervisor is unsupported on Windows without Job Object ownership");
-    }
+    const backend = executionBackendCapability(platform);
+    if (!backend.supported)
+        throw new Error(backend.reason);
     const childEntry = options.childEntry
         ?? fileURLToPath(new URL("./execution-supervisor-child.js", import.meta.url));
     const abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_ABORT_TIMEOUT_MS;
@@ -87,7 +110,7 @@ export async function startDormantSupervisor(launch, options = {}) {
     }
     let runtimeResult;
     let supervisorSpawnError;
-    const exit = new Promise((resolve) => {
+    const supervisorExit = new Promise((resolve) => {
         child.once("error", (error) => { supervisorSpawnError = error.message; });
         child.once("close", (code, signal) => resolve(runtimeResult ?? {
             exitCode: supervisorSpawnError === undefined ? (code ?? 128) : -1,
@@ -95,6 +118,11 @@ export async function startDormantSupervisor(launch, options = {}) {
             ...(supervisorSpawnError === undefined && signal !== null ? { terminationSignal: signal } : {}),
         }));
     });
+    const exit = supervisorExit.then(async (result) => {
+        if (platform !== "win32")
+            await waitForProcessGroupExit(pid, abortTimeoutMs);
+        return result;
+    });
     const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
     let readyResolve;
     let readyReject;
@@ -158,6 +186,21 @@ export async function startDormantSupervisor(launch, options = {}) {
             await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
         }
     };
+    const cancel = async () => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            await supervisorClosed;
+            return;
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                child.send({ type: "abort" }, (error) => error === null ? resolve() : reject(error));
+            });
+            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+        }
+        catch {
+            await abort();
+        }
+    };
     try {
         await new Promise((resolve, reject) => {
             child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env } }, (error) => {
@@ -204,6 +247,6 @@ export async function startDormantSupervisor(launch, options = {}) {
             }
         },
         abort,
-        cancel: abort,
+        cancel,
     };
 }

package/dist/execution-telemetry-journal.js

@@ -0,0 +1,71 @@
+import { access, open, mkdir, readdir, readFile, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { DaemonToServerExecutionFrameSchema, } from "./execution-protocol.js";
+const MAX_PENDING_FILES = 4_096;
+const fileName = (frame) => `${frame.executionId}.${frame.type === "execution:activity" ? "activity" : "console"}.${frame.seq}.json`;
+export class ExecutionTelemetryJournal {
+    directory;
+    constructor(agentsRoot) {
+        this.directory = join(agentsRoot, ".execution-telemetry");
+    }
+    async append(frame) {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const path = join(this.directory, fileName(frame));
+        if (await access(path).then(() => true, () => false))
+            return;
+        const pending = await readdir(this.directory);
+        if (pending.length >= MAX_PENDING_FILES) {
+            throw new Error(`execution telemetry journal is full (${MAX_PENDING_FILES} frames)`);
+        }
+        const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        let handle;
+        try {
+            handle = await open(tempPath, "wx", 0o600);
+            await handle.writeFile(JSON.stringify(frame), "utf8");
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await rename(tempPath, path);
+        }
+        catch (error) {
+            await unlink(tempPath).catch(() => { });
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        finally {
+            await handle?.close();
+        }
+    }
+    async acknowledge(executionId, kind, seq) {
+        await unlink(join(this.directory, `${executionId}.${kind}.${seq}.json`)).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
+    }
+    async replay() {
+        const names = await readdir(this.directory).catch((error) => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        });
+        const frames = [];
+        for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
+            let raw;
+            try {
+                raw = JSON.parse(await readFile(join(this.directory, name), "utf8"));
+            }
+            catch (error) {
+                throw new Error(`invalid execution telemetry journal entry: ${name}`, { cause: error });
+            }
+            const parsed = DaemonToServerExecutionFrameSchema.safeParse(raw);
+            if (!parsed.success || (parsed.data.type !== "execution:activity" && parsed.data.type !== "execution:console")) {
+                throw new Error(`invalid execution telemetry journal entry: ${name}`);
+            }
+            frames.push(parsed.data);
+        }
+        return frames.sort((left, right) => left.at.localeCompare(right.at)
+            || left.type.localeCompare(right.type) || left.seq - right.seq);
+    }
+}
+export const createExecutionTelemetryJournal = (agentsRoot) => new ExecutionTelemetryJournal(agentsRoot);

package/dist/i18n.js

@@ -29,9 +29,34 @@ const zh = {
     "for channel": "处理频道",
     "agent exited": "agent 退出",
     "activities": "活动数",
+    "Computer lifecycle:": "电脑生命周期：",
+    "profile save reads the machine token from CREW_MACHINE_TOKEN, or stdin with --token-stdin.": "profile save 从 CREW_MACHINE_TOKEN 或 --token-stdin 的标准输入读取机器令牌。",
+    "Missing {{name}}": "缺少 {{name}}",
+    "Service '{{id}}' is still installed; uninstall it before removing the profile": "服务 '{{id}}' 仍已安装；请先卸载服务再删除配置",
+    "Removed profile '{{name}}'.": "已删除配置 '{{name}}'。",
+    "Expected profile save, list, show, or remove": "profile 子命令应为 save、list、show 或 remove",
+    "Choose one token source: CREW_MACHINE_TOKEN or --token-stdin": "CREW_MACHINE_TOKEN 与 --token-stdin 只能选择一种令牌来源",
+    "Missing machine token; use CREW_MACHINE_TOKEN or --token-stdin": "缺少机器令牌；请使用 CREW_MACHINE_TOKEN 或 --token-stdin",
+    "Saved profile '{{name}}' with private credentials.": "已保存配置 '{{name}}'，凭证仅私有可读。",
+    "Service '{{id}}' is not installed": "服务 '{{id}}' 尚未安装",
+    "Upgraded daemon and restart request accepted for '{{name}}'. Verify with status.": "daemon 已升级，并已请求重启 '{{name}}'；请用 status 确认。",
+    "Upgraded daemon. Installed services were not restarted; pass --profile to restart one.": "daemon 已升级；已安装服务尚未重启，可传入 --profile 重启指定服务。",
+    "Service lifecycle requires the built daemon entry (.js), not a TypeScript development entry": "服务生命周期必须使用已构建的 daemon 入口（.js），不能使用 TypeScript 开发入口",
+    "Installed '{{id}}'. Use status to confirm runtime state.": "已安装 '{{id}}'；请用 status 确认运行状态。",
+    "Uninstalled '{{id}}'.": "已卸载 '{{id}}'。",
+    "{{action}} request accepted for '{{id}}'. Verify with status.": "已接受对 '{{id}}' 的 {{action}} 请求；请用 status 确认。",
+    "--token-stdin requires a token on standard input": "--token-stdin 需要从标准输入读取令牌",
+    "Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest": "服务生命周期需要全局安装 @nowcrew/daemon；请运行 npm install --global @nowcrew/daemon@latest",
 };
 export function translateDaemon(lang, message) {
     if (lang === "zh")
         return zh[message] ?? message;
     return message;
 }
+export function formatDaemonText(lang, message, values = {}) {
+    let rendered = translateDaemon(lang, message);
+    for (const [key, value] of Object.entries(values)) {
+        rendered = rendered.replaceAll(`{{${key}}}`, String(value));
+    }
+    return rendered;
+}

package/dist/local-executor.js

@@ -261,8 +261,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 callbacks.onActivity?.(activity);
             }
             const extracted = extractFinalText(event);
-            if (extracted)
-                finalText = extracted;
+            if (extracted) {
+                const incremental = typeof event === "object" && event !== null
+                    && "type" in event && event.type === "kimi.acp.text_delta";
+                finalText = incremental ? `${finalText ?? ""}${extracted}` : extracted;
+            }
             for (const chunk of toConsoleLines(event))
                 callbacks.onConsole?.(chunk);
         });

package/dist/machine-info.js

@@ -11,11 +11,16 @@ import { readdir } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
+import { executableRuntimes } from "./runtime-capabilities.js";
+import { executionBackendCapability } from "./execution-backend.js";
+import { probeKimiAcp } from "./runtimes/kimi-acp-runner.js";
+export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const DAEMON_CAPABILITIES = [
     "scheduled_job_v1",
     "reply_origin_v1",
     "origin_decision_v1",
+    "execution_telemetry_ack_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
@@ -43,6 +48,17 @@ export async function detectRuntimes() {
     const checks = await Promise.all(RUNTIME_BINS.map(async ([name, bin]) => ((await isInstalled(bin)) ? name : null)));
     return checks.filter((x) => x !== null);
 }
+async function supportsKimiAcp() {
+    return probeKimiAcp({ bin: "kimi" });
+}
+/** Runtime adapters that can satisfy the durable protocol-v1 process contract. */
+export async function detectExecutionRuntimes(installed = detectRuntimes(), kimiAcpProbe = supportsKimiAcp) {
+    const present = await installed;
+    const supported = executableRuntimes(present).filter((runtime) => runtime !== "kimi");
+    if (present.includes("kimi") && await kimiAcpProbe())
+        supported.push("kimi");
+    return supported;
+}
 export function daemonVersion() {
     try {
         const here = dirname(fileURLToPath(import.meta.url));
@@ -77,22 +93,27 @@ async function listAgentHandles(agentsRoot) {
         return [];
     }
 }
-export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform) {
+export async function collectMachineHello(agentsRoot, executionLimits, runtimePlatform = process.platform, dependencies = {}) {
     const [runtimes, agentHandles] = await Promise.all([
-        detectRuntimes(),
+        (dependencies.detectInstalled ?? detectRuntimes)(),
         listAgentHandles(agentsRoot),
     ]);
+    const backend = executionBackendCapability(runtimePlatform);
+    const executionRuntimes = backend.supported
+        ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
+        : [];
     return {
         type: "machine:hello",
         hostname: hostname(),
         os: `${osPlatform()} ${arch()}`,
         daemonVersion: daemonVersion(),
         runtimes,
+        executionRuntimes,
         capabilities: DAEMON_CAPABILITIES,
-        ...(runtimePlatform === "win32" ? {} : {
+        ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
             executionLimits: Object.freeze({ ...executionLimits }),
-        }),
+        } : {}),
         agentHandles,
     };
 }

package/dist/main.js

@@ -13,7 +13,14 @@ import { runAgent } from "./runner.js";
 import { serve } from "./serve.js";
 import { initSlog, flushSlog } from "./slog.js";
 import { formatDaemonLogLine } from "./log-format.js";
+import { loadProfile, applyProfileToEnv } from "./computer-profile.js";
+import { runComputerCommand } from "./computer-cli.js";
 async function main() {
+    const computerResult = await runComputerCommand(process.argv.slice(2));
+    if (computerResult !== null) {
+        process.exitCode = computerResult;
+        return;
+    }
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
     const { values, positionals } = parseArgs({
@@ -28,6 +35,8 @@ async function main() {
             "server-url": { type: "string" },
             "api-key": { type: "string" },
             token: { type: "string" }, // --api-key 的别名
+            profile: { type: "string" },
+            "daemon-home": { type: "string" },
         },
     });
     // 无子命令时默认 serve(对齐 `npx @nowcrew/daemon@latest --server-url ... --api-key ...`)
@@ -38,6 +47,12 @@ async function main() {
             "  crew-daemon run --agent <h> --channel <id> [--wake ...]                  # " + td("run once manually") + "\n");
         process.exit(2);
     }
+    // profile 先加载,显式命令行参数仍具有最高优先级。服务描述只保留 profile 名,
+    // 不把 machine token 放进 argv / plist / systemd unit / scheduled task。
+    if (values["daemon-home"])
+        process.env.CREW_DAEMON_HOME = values["daemon-home"];
+    if (values.profile)
+        applyProfileToEnv(await loadProfile(values.profile), process.env);
     // 命令行参数优先于环境变量,填回 env 供 loadConfig 读取
     if (values["server-url"])
         process.env.CREW_SERVER_URL = values["server-url"];

package/dist/normalize.js

@@ -34,6 +34,8 @@ export function classifyCommand(command) {
 /** 从各 runtime 的最终事件提取可交付文本。调用方按事件顺序保留最后一个非空值。 */
 export function extractFinalText(event) {
     const e = (event ?? {});
+    if (e.type === "kimi.acp.text_delta" && e.text)
+        return e.text;
     if (e.type === "result" && !e.is_error && e.result?.trim())
         return e.result.trim();
     if (e.type === "item.completed" && e.item?.type === "agent_message" && e.item.text?.trim()) {
@@ -59,6 +61,15 @@ function parseKimiBashCommand(args) {
 /** 把一个 stream-json 事件归一化为 0..N 个活动。 */
 export function normalizeEvent(event) {
     const e = (event ?? {});
+    if (e.type === "kimi.acp.text_delta" && e.text?.trim()) {
+        return [{ kind: "text", label: "思考/说明", detail: e.text }];
+    }
+    if (e.type === "kimi.acp.tool_call") {
+        return [{ kind: "tool", label: e.title ? `工具:${e.title}` : "工具调用" }];
+    }
+    if (e.type === "kimi.acp.tool_result") {
+        return [{ kind: "tool_result", label: "工具返回" }];
+    }
     if (e.type === "system" && e.subtype === "init") {
         return [{ kind: "init", label: "agent 启动" }];
     }

package/dist/origin-decision.js

@@ -27,7 +27,7 @@ export async function readOriginDecisionFile(path) {
     }
 }
 export function shouldRetryOriginDecision(wakeOrigin, decision, attempt) {
-    return wakeOrigin === "wecom" && decision === null && attempt === 0;
+    return wakeOrigin === "wecom" && decision?.decision !== "reply" && attempt === 0;
 }
 export async function runWithOriginDecisionGuard(wakeOrigin, runAttempt) {
     const first = await runAttempt(0);

package/dist/prompt.js

@@ -29,8 +29,25 @@ export function buildSystemPrompt(ctx) {
         ?? (ctx.scheduled ? "silent_unless_report" : null);
     const scheduled = scheduledPolicy !== null;
     const alwaysReport = scheduledPolicy === "always_report";
-    // 启动序列:非 scheduled 保持原文(含"先确认接手"/"收到消息就处理并回复"——这两条是
-    // 协作场景的核心礼仪);scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
+    const messageBodyInput = ctx.platform === "win32"
+        ? `PowerShell 5.1 向 native 进程传管道时默认可能使用 US-ASCII。发送中文等非 ASCII 正文时，**必须在同一条 shell 命令内**先设置无 BOM UTF-8:
+   \`\`\`powershell
+   $utf8 = New-Object System.Text.UTF8Encoding($false)
+   $OutputEncoding = $utf8
+   [Console]::OutputEncoding = $utf8
+   @'
+   你的消息正文
+   '@ | crew message send --channel <id> --thread <完整线程根消息 id>
+   \`\`\`
+   不得在未设置 \`$OutputEncoding\` 时把非 ASCII 正文通过 PowerShell 管道传给 \`crew\`。`
+        : `正文从 stdin 读，用 heredoc 避免 shell 解释引号/反引号/代码块:
+   \`\`\`bash
+   crew message send --channel <id> <<'CREWMSG'
+   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
+   CREWMSG
+   \`\`\``;
+    // 启动序列:普通交互对可直答来信只发一条完整回复，多步工作仍可发有信息量的进度；
+    // scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
     const startupSequence = alwaysReport
         ? `## 启动序列(每轮汇报定时任务)
 1. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
@@ -47,7 +64,7 @@ export function buildSystemPrompt(ctx) {
 4. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。
 5. 无异常时直接结束,不需要任何输出,不必读频道历史(除非指令要求)。`
             : `## 启动序列
-1. 若本轮已带具体来信,先判断是否需要立即确认/提问/声明接手;需要就先用 \`crew message send\` 发出,再去深挖上下文。确认消息的内容标准见下面「沟通风格」。
+1. 若本轮来信可以直接回答,不要先发确认消息;处理完后只发一条完整回复。只有需要澄清、调用工具、协调他人或较长时间处理时,才先发有信息量的确认/进度消息。
 2. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
 3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
 4. 收到消息就处理,并用 \`crew message send\` 回复。
@@ -74,14 +91,15 @@ export function buildSystemPrompt(ctx) {
 ## 定时任务创建与管理
 平台不会用关键词预先区分创建或管理意图,由你根据完整来信和上下文判断用户是要创建定时任务,还是查看、修改、暂停、恢复、取消或立即执行已有任务。
 1. 定时任务创建与管理无需 \`crew task claim\`;不要仅为创建或管理定时任务而创建 task。
-2. 创建时使用 \`crew schedule create --agent ${ctx.handle} --channel ${ctx.channelId} --prompt '<text>' (--cron '<expr>' | --at '<ISO>')\`,不得编造或替换当前 agent 身份与频道。
+2. 创建时使用 \`crew schedule create --agent ${ctx.handle} --channel ${ctx.channelId} --prompt '<text>' (--cron '<expr>' | --at '<ISO>') [--external-notification <disabled|agent-decides>]\`,不得编造或替换当前 agent 身份与频道。
 3. \`crew schedule create\` 和 \`crew schedule update\` 都必须遵守这条规则:\`prompt\`、\`title\`、\`cron\`、\`at\`、\`timezone\` 的值都必须分别作为单个 shell 参数传入,使用单引号 shell 引用;值内若含单引号,必须按标准方式关闭单引号、写入转义后的单引号、再重新开启单引号。不得在创建或更新持久化前展开或执行用户内容中的 \`$\`、反引号或 \`$()\`。
 4. 创建时默认使用 \`--output-policy always-report\`。创建时只有用户明确要求静默、不发送正常结果或仅在异常时汇报时,才使用 \`--output-policy on-exception\`。
 5. 更新时若用户未明确要求改变汇报行为,必须省略 \`--output-policy\` 并保留已有策略。只有用户明确要求改变汇报行为时,才按同样规则映射输出策略:正常汇报用 \`always-report\`,静默或仅异常汇报用 \`on-exception\`。创建或更新汇报行为时,把用户原始的汇报条件保留在 \`--prompt\` 中,不要改写或省略。汇报要求确实有歧义时,先向用户确认。
-6. 执行时间、时区或执行指令信息不足时,先向用户确认,不得猜测。
-7. 查询现状或执行 create/update/pause/resume/cancel/run-now 任何操作前,先运行 \`crew schedule list --channel ${ctx.channelId} --agent ${ctx.handle} --json\` 查询本频道绑定到你自己的候选;仅查看时也使用这条 JSON 查询,以获取完整的 cron/at/timezone/prompt/output policy。
-8. 只有一个明确匹配时,才运行 \`crew schedule update <jobId> ...\` 或对应 pause/resume/cancel/run-now 命令。有多个合理候选时,列出候选并先让用户选择;用户选定前不得修改任何任务。
-9. 修改请求不能用 \`crew schedule create\` 代替。完成后回复 job ID、最终 schedule、timezone 和 output policy;更新还要列出变更字段的前后值。`;
+6. 绑定会话通知创建时默认使用 \`disabled\`。只有用户明确要求将合适结果通知绑定会话时,才使用 \`--external-notification agent-decides\`;用户未明确要求修改该授权时,更新时必须省略 \`--external-notification\` 并保留已有策略。
+7. 执行时间、时区或执行指令信息不足时,先向用户确认,不得猜测。
+8. 查询现状或执行 create/update/pause/resume/cancel/run-now 任何操作前,先运行 \`crew schedule list --channel ${ctx.channelId} --agent ${ctx.handle} --json\` 查询本频道绑定到你自己的候选;仅查看时也使用这条 JSON 查询,以获取完整的 cron/at/timezone/prompt/output policy/external notification policy。
+9. 只有一个明确匹配时,才运行 \`crew schedule update <jobId> ...\` 或对应 pause/resume/cancel/run-now 命令。有多个合理候选时,列出候选并先让用户选择;用户选定前不得修改任何任务。
+10. 修改请求不能用 \`crew schedule create\` 代替。完成后回复 job ID、最终 schedule、timezone、output policy 和 external notification policy;更新还要列出变更字段的前后值。`;
     const voiceRule = alwaysReport
         ? "- **本轮报告只写在 runtime 最终回复中**:不要调用 `crew message send`;daemon 会把最终回复投递到频道。"
         : "- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**";
@@ -98,7 +116,7 @@ export function buildSystemPrompt(ctx) {
 8. **\`crew task update <taskId> --status <in_progress|in_review|done>\`** —— 推进任务状态。
 9. **\`crew task unclaim <taskId>\`** —— 释放认领,把任务让给别人。
 10. **\`crew task assign <taskId> --to <handle>\`** —— 把任务指派/交接给另一个 agent(用于交接,见下)。
-11. **\`crew schedule create --agent <handle> --channel <id> --prompt <text> [--title <t>] (--cron <expr> | --at <ISO>) [--timezone <iana>] [--output-policy <always-report|on-exception>]\`** —— 创建定时任务。
+11. **\`crew schedule create --agent <handle> --channel <id> --prompt <text> [--title <t>] (--cron <expr> | --at <ISO>) [--timezone <iana>] [--output-policy <always-report|on-exception>] [--external-notification <disabled|agent-decides>]\`** —— 创建定时任务。
 12. **\`crew schedule list --channel <id> --agent <handle> [--json]\`** —— 查询本频道指定 agent 的定时任务,\`--json\` 返回完整字段。
 13. **\`crew schedule update <jobId> ...\`** —— 修改定时任务标题、指令、时间或输出策略。
 14. **\`crew schedule pause|resume|cancel|run-now <jobId>\`** —— 控制定时任务。`;
@@ -114,12 +132,7 @@ ${taskAndScheduleCommands}`
 1. **\`crew whoami\`** —— 查看你自己的身份。
 2. **\`crew message read --channel <id>\`** —— 读频道历史(读取即自动推进你的已读/新鲜度游标)。支持 \`--after <seq>\` / \`--limit <n>\`。
 3. **\`crew message check --channel <id>\`** —— 非阻塞查看未读数。工作中可在自然断点随时用。
-4. **\`crew message send --channel <id>\`** —— 发消息。正文从 stdin 读,用 heredoc 避免 shell 解释引号/反引号/代码块:
-   \`\`\`bash
-   crew message send --channel <id> <<'CREWMSG'
-   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
-   CREWMSG
-   \`\`\`
+4. **\`crew message send --channel <id>\`** —— 发消息。${messageBodyInput}
    也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <完整线程根消息 id>\`。被唤醒时优先使用环境变量 \`$CREW_WAKE_MESSAGE_ID\` 或唤醒提示里的完整 id,不要手动截短。
 ${taskAndScheduleCommands}`;
     const freshnessRule = alwaysReport
@@ -127,10 +140,13 @@ ${taskAndScheduleCommands}`;
         : `
 - **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。`;
     const externalReplyRule = scheduled
-        ? ""
+        ? ctx.scheduledExternalNotificationPolicy === "agent_decides"
+            ? `
+- **绑定会话通知由你选择**:只有本轮完整结果确实值得打扰绑定会话时,运行 \`crew message notify-bound-im --channel ${ctx.channelId}\` 一次,然后仍只返回一个完整最终报告。该命令只记录本轮决策,不会自行发消息,也不能指定收件人。`
+            : ""
         : ctx.wakeOrigin === "wecom"
             ? `
-- **本轮来自企微，结束本轮前必须明确选择外部回复决策**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。完整结果确实要回复企微时，用 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）；判断无需回复企微时，用 \`crew message skip-origin --reason "简短原因"\`。两者必须选择一个；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定。`
+- **本轮来自企微，结束本轮前必须给出一条完整回复**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。最终只用一次 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）发送有实质内容的完整结果；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定，并在本轮未形成可交付内容时发送统一兜底回复。`
             : `
 - **外部来源回复由你决定**:普通 \`crew message send\` 只写入 NowWork。只有当前 thread 明确来自企微等外部 IM、且这条消息确实要回复外部发言人时,才给该次发送加 \`--reply-origin\`;Server 会按当前 thread 的已验证来源路由,你不能指定任意机器人或会话。确认、过程进展、内部协作消息不要使用该参数。若判断无需回外部,只发普通内部消息或保持沉默。`;
     const interactiveTaskRules = scheduled ? "" : `
@@ -243,11 +259,14 @@ ${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memor
 /** 静默定时任务的唤醒提示词:不注入协作礼仪/线程提示;默认零输出(设计文档 §5.4)。
  *  汇报用 --send-draft:绕过 freshness hold(-p 单发不跑 crew read,游标落后,
  *  普通 send 会被 202 扣成 draft——监控告警绝不能被静默扣留)。 */
-export function buildScheduledPrompt(channelId, jobPrompt, outputPolicy = "silent_unless_report") {
-    if (outputPolicy === "always_report") {
+export function buildScheduledPrompt(channelId, jobPrompt, outputPolicy = "silent_unless_report", externalNotificationPolicy = "disabled") {
+    if (outputPolicy === "always_report" || externalNotificationPolicy === "agent_decides") {
         return [
             "You are executing a scheduled job. No one is waiting for an acknowledgement.",
             `Scheduled instruction: ${jobPrompt}`,
+            ...(externalNotificationPolicy === "agent_decides" ? [
+                `If and only if this complete result warrants notifying the bound conversation, run \`crew message notify-bound-im --channel ${channelId}\` once. The command records a local decision and does not send a second message.`,
+            ] : []),
             "Return exactly one self-contained final report as your runtime final response.",
             "Do not call crew message send; the daemon delivers the final response.",
             "Do not send acknowledgements or progress messages.",
@@ -277,8 +296,8 @@ export function buildOriginDecisionRetryPrompt(channelId, threadId) {
     const thread = threadId ? ` --thread ${threadId}` : "";
     return [
         "本轮尚未完成企微回复决策。不要重复执行已经完成的工作，只完成下面这个决策后结束：",
-        `- 需要回复企微：用 crew message send --channel ${channelId}${thread} --reply-origin --content "完整最终回复"。`,
-        `- 不需要回复企微：用 crew message skip-origin --channel ${channelId} --reason "简短原因"。`,
+        `- 必须回复企微：用 crew message send --channel ${channelId}${thread} --reply-origin --content "完整最终回复"。`,
+        "- 只发送一条有实质内容的完整回复，不要拆成确认、进展和结论多条外部消息。",
         "普通内部消息不算外部回复决策；--send-draft 也不是外部回复开关。",
     ].join("\n");
 }

package/dist/runner.js

@@ -7,6 +7,7 @@ import { deliverScheduledReport, } from "./scheduled-report.js";
 import { executeLocal } from "./local-executor.js";
 import { ReasoningSchema } from "./execution-protocol.js";
 import { readOriginDecisionFile, resetOriginDecisionFile } from "./origin-decision.js";
+import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 export { awaitExit, exitActivity, sanitizeEnvVars } from "./local-executor.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
@@ -31,6 +32,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     const originDecisionFileName = input.wakeOrigin === "wecom"
         ? `.origin-decision-${executionId}.json`
         : null;
+    const boundImDecisionFileName = input.scheduled?.externalNotificationPolicy === "agent_decides"
+        ? `.bound-im-decision-${executionId}.json`
+        : null;
     const local = await executeLocal({
         executionId,
         handle: input.handle,
@@ -43,7 +47,11 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             agentId: credential.agentId,
             homeDir: workspace.dir,
             productName: config.productName,
+            platform: process.platform,
             ...(input.scheduled ? { scheduledOutputPolicy: input.scheduled.outputPolicy } : {}),
+            ...(input.scheduled?.externalNotificationPolicy
+                ? { scheduledExternalNotificationPolicy: input.scheduled.externalNotificationPolicy }
+                : {}),
             ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
             memory: capMemoryForInject(workspace.memory),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
@@ -81,6 +89,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
                     CREW_WAKE_ORIGIN: "wecom",
                     CREW_ORIGIN_DECISION_FILE: originDecisionFileName,
                 } : {}),
+                ...(boundImDecisionFileName ? {
+                    CREW_BOUND_IM_DECISION_FILE: boundImDecisionFileName,
+                } : {}),
             },
         },
         session: {
@@ -116,9 +127,20 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         process.stdout.write(`📊 tokens: in=${usage.inputTokens} out=${usage.outputTokens} cache_read=${usage.cacheReadTokens} cache_create=${usage.cacheCreationTokens}`
             + `${usage.costUsd != null ? ` cost=$${usage.costUsd.toFixed(4)}` : ""} ${local.resumed ? "(resumed)" : "(fresh)"}\n`);
     }
+    const boundImDecisionPath = boundImDecisionFileName
+        ? join(local.workspaceRunDir, boundImDecisionFileName)
+        : null;
+    const selectedBoundImDecision = boundImDecisionPath
+        ? await readBoundImDecisionFile(boundImDecisionPath)
+        : null;
+    if (boundImDecisionPath)
+        await resetBoundImDecisionFile(boundImDecisionPath);
+    const boundImDecision = boundImDecisionPath
+        ? selectedBoundImDecision?.decision ?? "silent"
+        : undefined;
     const report = input.scheduled
         ? await deliverScheduledReport({
-            policy: input.scheduled.outputPolicy,
+            policy: boundImDecision === "notify" ? "always_report" : input.scheduled.outputPolicy,
             title: input.scheduled.title,
             exitCode: local.exitCode,
             finalText: local.finalText,
@@ -126,6 +148,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
                 content,
                 force: true,
+                ...(boundImDecision === "notify" ? { notifyBoundIm: true } : {}),
             }),
         })
         : undefined;
@@ -145,6 +168,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         errorMessage: local.errorMessage,
         ...(local.usage ? { usage: local.usage } : {}),
         ...(report ? { report } : {}),
+        ...(boundImDecision ? { boundImDecision } : {}),
         ...(input.wakeOrigin === "wecom" ? {
             originDecision: originDecision?.decision ?? "missing",
             ...(originDecision?.decision === "silent" && originDecision.reason

package/dist/runtime-capabilities.js

@@ -0,0 +1,5 @@
+export const LOCAL_EXECUTION_RUNTIMES = ["claude", "codex", "kimi"];
+const LOCAL_EXECUTION_RUNTIME_SET = new Set(LOCAL_EXECUTION_RUNTIMES);
+export function executableRuntimes(installed) {
+    return [...new Set(installed)].filter((runtime) => LOCAL_EXECUTION_RUNTIME_SET.has(runtime));
+}