@nowcrew/daemon 0.5.19 → 0.5.21

package/dist/execution-runner.js

@@ -1,17 +1,19 @@
 import { createHash } from "node:crypto";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
 import { boundExecutionFrame } from "./execution-event-limit.js";
 import { mintAgentToken } from "./token.js";
 import { executeLocal, withLocalExecutionFacts, } from "./local-executor.js";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
-import { buildClaudeArgs, CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
+import { CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
 import { CODEX_EFFORT_LEVELS } from "./runtimes/codex.js";
 import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
 import { executionBackendCapability } from "./execution-backend.js";
 import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
+import { RuntimeCancelledError } from "./runtime-cancellation.js";
+import { supervisorLaunch } from "./supervised-runtime.js";
+export { supervisorLaunch } from "./supervised-runtime.js";
 const ACTIVITY_KIND = {
     init: "working",
     text: "thinking",
@@ -183,70 +185,6 @@ function launchProviderConfig(config) {
         ...(config.description === undefined ? {} : { description: config.description }),
     };
 }
-export function supervisorLaunch(request) {
-    const common = {
-        wakePrompt: request.wakePrompt,
-        dangerous: request.effectivePermission === "full_access",
-        effectivePermission: request.effectivePermission,
-        ...(request.model === undefined ? {} : { model: request.model }),
-        ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
-    };
-    if (request.runtime === "claude") {
-        return {
-            command: request.bin,
-            args: buildClaudeArgs({
-                ...common,
-                bin: request.bin,
-                cwd: request.cwd,
-                env: request.env,
-                systemPromptPath: request.systemPromptPath,
-                ...(request.sessionId === undefined ? {} : {
-                    sessionId: request.sessionId,
-                    resume: request.resume,
-                }),
-            }),
-            cwd: request.cwd,
-            env: request.env,
-        };
-    }
-    if (request.runtime === "codex") {
-        return {
-            command: process.execPath,
-            args: [
-                fileURLToPath(new URL("./runtimes/codex-app-server-runner.js", import.meta.url)),
-                "--bin", request.bin,
-            ],
-            cwd: request.cwd,
-            env: request.env,
-            stdinText: JSON.stringify({
-                systemPrompt: request.systemPrompt,
-                wakePrompt: request.wakePrompt,
-                effectivePermission: request.effectivePermission,
-                ...(request.model === undefined ? {} : { model: request.model }),
-                ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
-                ...(request.sessionId === undefined ? {} : { sessionId: request.sessionId }),
-                ...(request.imagePaths === undefined ? {} : { imagePaths: request.imagePaths }),
-                resume: request.resume,
-            }),
-        };
-    }
-    if (request.effectivePermission !== "full_access") {
-        throw new Error(`Kimi ACP cannot enforce ${request.effectivePermission} permission`);
-    }
-    return {
-        command: process.execPath,
-        args: [
-            fileURLToPath(new URL("./runtimes/kimi-acp-runner.js", import.meta.url)),
-            "--bin", request.bin,
-            ...(request.model === undefined ? [] : ["--model", request.model]),
-            ...(request.sessionId === undefined ? [] : ["--session", request.sessionId]),
-            ...(request.resume ? ["--resume"] : []),
-        ],
-        cwd: request.cwd,
-        env: request.env,
-        stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
-    };
-}
 function rejection(executionId, reason, message, at) {
     return ExecutionRejectedSchema.parse({
         type: "execution:rejected",
@@ -494,7 +432,7 @@ export async function runExecution(config, input, dependencies) {
                     catch { /* best-effort console omitted when its envelope cannot fit */ }
                 },
             } : {}),
-            ...(spec.context.externalResponseSessionId ? {
+            ...(spec.context.externalResponseSessionId || spec.context.answerStream ? {
                 onExternalOutput: (text) => {
                     const frame = DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:output",
@@ -513,6 +451,7 @@ export async function runExecution(config, input, dependencies) {
             } : {}),
         };
         const localDependencies = {
+            ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
             launchRuntime: async (request) => {
                 if (launchClosed || dependencies.cancellation?.isRequested())
                     throw new ExecutionCancelledError();
@@ -521,27 +460,42 @@ export async function runExecution(config, input, dependencies) {
                 launchAttempts.add(launchSettled);
                 try {
                     const processStartedAt = now().toISOString();
-                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)));
+                    const launchControl = { cancel: null };
+                    const guarded = await dependencies.journal.startGuarded(spec.executionId, processStartedAt, () => startSupervisor(supervisorLaunch(request)), {
+                        beforeRelease: ({ entry, handle, abort }) => {
+                            supervisorState.active = handle;
+                            let stopPromise = null;
+                            let releaseStarted = false;
+                            const stopOnce = (operation) => {
+                                if (stopPromise === null) {
+                                    try {
+                                        stopPromise = Promise.resolve(operation());
+                                    }
+                                    catch (error) {
+                                        stopPromise = Promise.reject(error);
+                                    }
+                                }
+                                return stopPromise;
+                            };
+                            launchControl.cancel = () => stopOnce(releaseStarted ? handle.cancel : abort);
+                            supervisorState.abortOnce = () => stopOnce(abort);
+                            dependencies.cancellation?.register(launchControl.cancel);
+                            startedAt = entry.processStartedAt ?? processStartedAt;
+                            if (dependencies.cancellation?.isRequested()) {
+                                return dependencies.cancellation.waitForStop().then(() => {
+                                    throw new ExecutionCancelledError();
+                                });
+                            }
+                            releaseStarted = true;
+                        },
+                    });
                     if (guarded.kind !== "started") {
                         throw new Error(`Execution became ${guarded.entry.state} before local launch`);
                     }
-                    supervisorState.active = guarded.handle;
-                    let stopPromise = null;
-                    const stopOnce = (operation) => {
-                        if (stopPromise === null) {
-                            try {
-                                stopPromise = Promise.resolve(operation());
-                            }
-                            catch (error) {
-                                stopPromise = Promise.reject(error);
-                            }
-                        }
-                        return stopPromise;
-                    };
-                    const cancelOnce = () => stopOnce(guarded.handle.cancel);
-                    supervisorState.abortOnce = () => stopOnce(guarded.handle.abort);
-                    dependencies.cancellation?.register(cancelOnce);
-                    startedAt = guarded.entry.processStartedAt ?? processStartedAt;
+                    if (launchControl.cancel === null) {
+                        throw new Error("Execution launch cancellation gate was not installed");
+                    }
+                    const installedCancel = launchControl.cancel;
                     await reportBestEffort(dependencies.report, boundExecutionFrame(DaemonToServerExecutionFrameSchema.parse({
                         type: "execution:started",
                         protocolVersion: 1,
@@ -552,14 +506,14 @@ export async function runExecution(config, input, dependencies) {
                         timeout = setTimeout(() => {
                             timedOut = true;
                             try {
-                                void cancelOnce().catch(rejectCancellationFailure);
+                                void installedCancel().catch(rejectCancellationFailure);
                             }
                             catch (error) {
                                 rejectCancellationFailure(error);
                             }
                         }, effectiveTimeoutMs);
                     }
-                    return guarded.handle;
+                    return { ...guarded.handle, cancel: installedCancel };
                 }
                 finally {
                     launchAttempts.delete(launchSettled);
@@ -608,10 +562,10 @@ export async function runExecution(config, input, dependencies) {
                 maxTurns: config.sessionMaxTurns,
             },
         };
-        const result = await cancellable(Promise.race([
+        const result = await Promise.race([
             execute(localInput, callbacks, localDependencies),
             cancellationFailure,
-        ]), dependencies.cancellation);
+        ]);
         if (timeout !== undefined)
             clearTimeout(timeout);
         const finishedAt = now().toISOString();
@@ -652,6 +606,9 @@ export async function runExecution(config, input, dependencies) {
             ...(!spec.reporting.captureFinal || result.finalText === null
                 ? {}
                 : { finalText: result.finalText }),
+            ...(spec.context.answerStream && result.exitCode === 0 && result.externalAnswer
+                ? { externalAnswer: result.externalAnswer }
+                : {}),
             ...(result.usage === undefined ? {} : { usage: result.usage }),
             startedAt,
             finishedAt,
@@ -660,7 +617,8 @@ export async function runExecution(config, input, dependencies) {
     catch (error) {
         if (timeout !== undefined)
             clearTimeout(timeout);
-        if (error instanceof ExecutionCancelledError) {
+        const cancelled = error instanceof ExecutionCancelledError || error instanceof RuntimeCancelledError;
+        if (cancelled) {
             await closeLaunchGate();
             await dependencies.cancellation?.waitForStop();
         }
@@ -673,7 +631,7 @@ export async function runExecution(config, input, dependencies) {
                 throw new AggregateError([error, abortError], `Failed to stop the execution supervisor: ${detail}`);
             }
         }
-        completion = error instanceof ExecutionCancelledError
+        completion = cancelled
             ? ExecutionCompletedSchema.parse({
                 type: "execution:completed",
                 protocolVersion: 1,

package/dist/execution-supervisor-child.js

@@ -1,6 +1,7 @@
 import spawn from "cross-spawn";
 import { z } from "zod";
 import { pathToFileURL } from "node:url";
+import { assignProcessToJob, createKillOnCloseJob, terminateJob, } from "./win32-job-object.js";
 const LaunchSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()),
@@ -8,6 +9,9 @@ const LaunchSchema = z.object({
     env: z.record(z.string()),
     stdinText: z.string().optional(),
 }).strict();
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function send(message, callback) {
     if (!process.connected) {
         callback?.();
@@ -56,10 +60,17 @@ function forwardWhileWritable(source, destination) {
 }
 export function runExecutionSupervisorChild() {
     let launch = null;
+    // 是否用 Job Object 拥有 runtime 树。由 parent 依据「durable + win32 + Job Object 后端已选中」决定并下发;
+    // legacy(process-lifetime)路径恒为 false —— 关键:不能仅凭 process.platform 就建 Job,否则灰度关时
+    // legacy Windows 执行会被强行套 Job,且 koffi 加载失败会误杀 legacy runtime(退回 fail-closed 承诺被破坏)。
+    let useJobObject = false;
     let released = false;
     let runtime = null;
     let settled = false;
     let cleaningTree = false;
+    // win32:本 child 创建并持有的 Job(KILL_ON_JOB_CLOSE)。持有它 = 拥有整棵 runtime 进程树:
+    // 本进程一死(含崩溃)内核即回收 Job 内全部进程,等价于 POSIX killpg 且覆盖 supervisor 自身崩溃。
+    let jobHandle = null;
     const outputForwarders = [];
     const terminateOwnedTree = () => {
         if (cleaningTree)
@@ -68,6 +79,15 @@ export function runExecutionSupervisorChild() {
         for (const forwarder of outputForwarders)
             forwarder.discard();
         if (process.platform === "win32") {
+            // 显式一次性杀光 Job 内进程;即便这里失败,process.exit 关闭 job handle 也会触发内核回收。
+            if (jobHandle !== null) {
+                try {
+                    terminateJob(jobHandle);
+                }
+                catch {
+                    // handle 随进程退出自动关闭,KILL_ON_JOB_CLOSE 兜底。
+                }
+            }
             process.exit(1);
             return;
         }
@@ -126,6 +146,7 @@ export function runExecutionSupervisorChild() {
                 return;
             }
             launch = parsed.data;
+            useJobObject = raw.useJobObject === true;
             send({ type: "ready" });
             return;
         }
@@ -139,6 +160,18 @@ export function runExecutionSupervisorChild() {
         if (raw.type !== "release" || released || launch === null)
             return;
         released = true;
+        if (useJobObject) {
+            // 所有权链条落地(仅 durable win32):先建 Job(带 KILL_ON_JOB_CLOSE),再 spawn,spawn 后立即 assign。
+            // 建 Job 失败即无法保证所有权 → 宁可不 spawn,报 spawn-error 让上层 fail-closed。
+            try {
+                jobHandle = createKillOnCloseJob();
+            }
+            catch (error) {
+                send({ type: "runtime-spawn-error", message: `Job Object creation failed: ${messageOf(error)}` });
+                process.exit(2);
+                return;
+            }
+        }
         const child = spawn(launch.command, launch.args, {
             cwd: launch.cwd,
             env: launch.env,
@@ -146,6 +179,24 @@ export function runExecutionSupervisorChild() {
             stdio: [launch.stdinText === undefined ? "ignore" : "pipe", "pipe", "pipe"],
         });
         runtime = child;
+        if (jobHandle !== null && child.pid !== undefined) {
+            // spawn 返回后 child.pid 同步可用,此刻立即 assign,把「assign 前已 fork 孙进程」的窗口压到最小。
+            try {
+                assignProcessToJob(jobHandle, child.pid);
+            }
+            catch (error) {
+                // 无法建立所有权:杀掉刚起的 runtime 并拆除,不让它脱离 Job 裸奔。
+                send({ type: "runtime-spawn-error", message: `AssignProcessToJobObject failed: ${messageOf(error)}` });
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // 已退出。
+                }
+                terminateOwnedTree();
+                return;
+            }
+        }
         outputForwarders.push(forwardWhileWritable(child.stdout, process.stdout), forwardWhileWritable(child.stderr, process.stderr));
         child.once("spawn", () => {
             send({ type: "runtime-started" });

package/dist/execution-supervisor.js

@@ -1,6 +1,6 @@
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { executionBackendCapability } from "./execution-backend.js";
+import { executionBackendCapability, ownsRuntimeViaJobObject } 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;
@@ -44,6 +44,55 @@ async function waitForProcessGroupExit(pid, timeoutMs) {
         await new Promise((resolve) => setTimeout(resolve, PROCESS_GROUP_POLL_MS));
     }
 }
+async function processGroupExists(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ESRCH")
+            return false;
+        if (code === "EPERM")
+            return true;
+        throw error;
+    }
+}
+async function signalOwnedTreeIfPresent(pid, signal, platform, signalTree) {
+    try {
+        await signalTree(pid, signal, platform);
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            throw error;
+    }
+}
+async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree) {
+    const waitUntilStopped = () => platform === "win32"
+        ? waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), timeoutMs, pid)
+        : waitForProcessGroupExit(pid, timeoutMs);
+    let termError;
+    try {
+        await signalOwnedTreeIfPresent(pid, "SIGTERM", platform, signalTree);
+        await waitUntilStopped();
+        return;
+    }
+    catch (error) {
+        termError = error;
+    }
+    try {
+        await signalOwnedTreeIfPresent(pid, "SIGKILL", platform, signalTree);
+        await waitUntilStopped();
+    }
+    catch (killError) {
+        throw new AggregateError([termError, killError], "Supervisor process-tree termination failed");
+    }
+}
+async function confirmOrTerminateOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree) {
+    if (platform !== "win32" && !(await processGroupExists(pid)))
+        return;
+    await terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree);
+}
 async function withTimeout(promise, timeoutMs, phase) {
     let timer;
     try {
@@ -86,9 +135,15 @@ export async function signalSupervisorTree(pid, signal, platform = process.platf
 }
 export async function startDormantSupervisor(launch, options = {}) {
     const platform = options.platform ?? process.platform;
-    const backend = executionBackendCapability(platform);
-    if (!backend.supported)
-        throw new Error(backend.reason);
+    const ownershipMode = options.ownershipMode ?? "durable";
+    if (ownershipMode === "durable") {
+        const backend = executionBackendCapability(platform);
+        if (!backend.supported)
+            throw new Error(backend.reason);
+    }
+    // 仅 durable + win32 + Job Object 后端已选中才让 child 套 Job;legacy 恒 false(见 ownsRuntimeViaJobObject)。
+    const useJobObject = ownsRuntimeViaJobObject(ownershipMode, platform);
+    const signalTree = options.signalTree ?? signalSupervisorTree;
     const childEntry = options.childEntry
         ?? fileURLToPath(new URL("./execution-supervisor-child.js", import.meta.url));
     const abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_ABORT_TIMEOUT_MS;
@@ -118,12 +173,16 @@ export async function startDormantSupervisor(launch, options = {}) {
             ...(supervisorSpawnError === undefined && signal !== null ? { terminationSignal: signal } : {}),
         }));
     });
+    const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
+    let treeStopPromise = null;
+    const ensureTreeStopped = () => {
+        treeStopPromise ??= confirmOrTerminateOwnedTree(pid, platform, abortTimeoutMs, supervisorClosed, signalTree);
+        return treeStopPromise;
+    };
     const exit = supervisorExit.then(async (result) => {
-        if (platform !== "win32")
-            await waitForProcessGroupExit(pid, abortTimeoutMs);
+        await ensureTreeStopped();
         return result;
     });
-    const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
     let readyResolve;
     let readyReject;
     const ready = new Promise((resolve, reject) => {
@@ -161,41 +220,30 @@ export async function startDormantSupervisor(launch, options = {}) {
     const abort = async () => {
         if (child.exitCode !== null || child.signalCode !== null) {
             await supervisorClosed;
+            await ensureTreeStopped();
             return;
         }
-        try {
-            await signalSupervisorTree(pid, "SIGTERM", platform);
-        }
-        catch (error) {
-            const code = error instanceof Error && "code" in error ? error.code : undefined;
-            if (code !== "ESRCH")
-                throw error;
-        }
-        try {
-            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
-        }
-        catch (error) {
-            try {
-                await signalSupervisorTree(pid, "SIGKILL", platform);
-            }
-            catch (killError) {
-                const code = killError instanceof Error && "code" in killError ? killError.code : undefined;
-                if (code !== "ESRCH")
-                    throw new AggregateError([error, killError], "Supervisor abort failed");
-            }
-            await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
-        }
+        await ensureTreeStopped();
+        await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+        await ensureTreeStopped();
     };
     const cancel = async () => {
         if (child.exitCode !== null || child.signalCode !== null) {
             await supervisorClosed;
+            await ensureTreeStopped();
             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);
+            if (platform === "win32") {
+                await ensureTreeStopped();
+            }
+            else {
+                await waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), abortTimeoutMs, pid);
+                await ensureTreeStopped();
+            }
         }
         catch {
             await abort();
@@ -203,7 +251,7 @@ export async function startDormantSupervisor(launch, options = {}) {
     };
     try {
         await new Promise((resolve, reject) => {
-            child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env } }, (error) => {
+            child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env }, useJobObject }, (error) => {
                 if (error === null)
                     resolve();
                 else
@@ -218,9 +266,8 @@ export async function startDormantSupervisor(launch, options = {}) {
         });
         throw error;
     }
-    return {
+    const handle = {
         pid,
-        parentExitGuard: "pipe-eof",
         stdout: child.stdout,
         stderr: child.stderr,
         exit,
@@ -249,4 +296,7 @@ export async function startDormantSupervisor(launch, options = {}) {
         abort,
         cancel,
     };
+    return ownershipMode === "durable"
+        ? { ...handle, ownershipMode, parentExitGuard: "pipe-eof" }
+        : { ...handle, ownershipMode };
 }

package/dist/external-output.js

@@ -84,3 +84,31 @@ export function stripExternalAnswerMarkers(value) {
     }
     return (sections.length > 0 ? sections.join("") : value).trim();
 }
+/**
+ * 提取 marker 内容:有 marker 返回拼接内容(trim,空→null),无 marker 返回 null。
+ * 与 stripExternalAnswerMarkers 的区别:strip 在无 marker 时回退整段原文(finalText 展示用),
+ * 本函数用于判定"agent 是否给出了频道直接回复"——必须能区分有无 marker。
+ */
+export function extractExternalAnswer(value) {
+    const parts = [];
+    let found = false;
+    let rest = value;
+    for (;;) {
+        const open = rest.indexOf(EXTERNAL_ANSWER_OPEN);
+        if (open < 0)
+            break;
+        found = true;
+        const afterOpen = rest.slice(open + EXTERNAL_ANSWER_OPEN.length);
+        const close = afterOpen.indexOf(EXTERNAL_ANSWER_CLOSE);
+        if (close < 0) {
+            parts.push(afterOpen);
+            break;
+        }
+        parts.push(afterOpen.slice(0, close));
+        rest = afterOpen.slice(close + EXTERNAL_ANSWER_CLOSE.length);
+    }
+    if (!found)
+        return null;
+    const answer = parts.join("").trim();
+    return answer.length > 0 ? answer : null;
+}

package/dist/i18n.js

@@ -17,6 +17,8 @@ export function detectDaemonLang(env = process.env) {
 }
 const zh = {
     "Claude session started": "Claude 会话启动",
+    "Codex session started": "Codex 会话启动",
+    "Files changed": "文件变更",
     "Run failed": "运行出错",
     "Run finished": "本轮结束",
     "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)": "缺少 CREW_MACHINE_TOKEN（sk_machine_*，由 seed 打印）",
@@ -40,6 +42,7 @@ const zh = {
     "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 but skipped restart for '{{name}}': {{reason}}": "daemon 已升级，但已跳过 '{{name}}' 的重启：{{reason}}",
     "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 确认运行状态。",
@@ -47,6 +50,9 @@ const zh = {
     "{{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",
+    "Profile '{{profile}}' conflicts with profile '{{conflict}}': both resolve to agents root '{{agentsRoot}}'. Save it with a unique root, for example: {{command}}": "配置 '{{profile}}' 与配置 '{{conflict}}' 解析到了同一个 agents root '{{agentsRoot}}'。请保存为唯一目录，例如：{{command}}",
+    "Daemon is already running (PID={{ownerPid}}) for agents root '{{agentsRoot}}'. Journal: '{{journalPath}}'. Do not delete the active journal lock. Stop the existing daemon before retrying. If this profile is managed as a service, use 'crew-daemon stop --profile {{profileName}}' or 'crew-daemon restart --profile {{profileName}}'.": "daemon 已在运行（PID={{ownerPid}}），agents root 为 '{{agentsRoot}}'。日志目录：'{{journalPath}}'。不要删除活跃进程持有的 journal 锁。请先停止现有 daemon 再重试；如果此 profile 由系统服务管理，请使用 'crew-daemon stop --profile {{profileName}}' 或 'crew-daemon restart --profile {{profileName}}'。",
+    "Daemon is already running (PID={{ownerPid}}) for agents root '{{agentsRoot}}'. Journal: '{{journalPath}}'. Do not delete the active journal lock. Stop the existing daemon before retrying. If it is managed as a service, use 'crew-daemon stop --profile <name>' or 'crew-daemon restart --profile <name>'.": "daemon 已在运行（PID={{ownerPid}}），agents root 为 '{{agentsRoot}}'。日志目录：'{{journalPath}}'。不要删除活跃进程持有的 journal 锁。请先停止现有 daemon 再重试；如果它由系统服务管理，请使用 'crew-daemon stop --profile <name>' 或 'crew-daemon restart --profile <name>'。",
 };
 export function translateDaemon(lang, message) {
     if (lang === "zh")
@@ -54,9 +60,5 @@ export function translateDaemon(lang, 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;
+    return translateDaemon(lang, message).replace(/\{\{([^{}]+)\}\}/g, (token, key) => Object.hasOwn(values, key) ? String(values[key]) : token);
 }