@nowcrew/daemon 0.5.19 → 0.5.21

package/dist/local-executor.js

@@ -11,9 +11,10 @@ import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { toConsoleLines } from "./console.js";
 import { capMemoryForInject, capWorkLogForInject } from "./prompt.js";
-import { decodeExternalOutputEvent, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
-import { cleanupMaterializedAttachments as cleanupAttachments, materializeAttachments, } from "./attachments.js";
+import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
+import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
 import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilities.js";
+import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
 function truncateUtf8(value, maxBytes) {
     if (maxBytes <= 0)
         return "";
@@ -138,20 +139,22 @@ function resolvePrompt(prompt, context) {
     return typeof prompt === "string" ? prompt : prompt(context);
 }
 const nativeSessionLeaseTails = new Map();
-async function withKeyedLease(key, operation) {
+async function withKeyedLease(key, operation, cancellation) {
     const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
     let release;
     const current = new Promise((resolve) => { release = resolve; });
     const tail = predecessor.then(() => current);
     nativeSessionLeaseTails.set(key, tail);
-    await predecessor;
     try {
+        await awaitWithCancellation(predecessor, cancellation);
         return await operation();
     }
     finally {
         release();
-        if (nativeSessionLeaseTails.get(key) === tail)
-            nativeSessionLeaseTails.delete(key);
+        void tail.then(() => {
+            if (nativeSessionLeaseTails.get(key) === tail)
+                nativeSessionLeaseTails.delete(key);
+        });
     }
 }
 export async function executeLocal(input, callbacks = {}, dependencies = {}) {
@@ -167,14 +170,14 @@ export async function executeLocal(input, callbacks = {}, dependencies = {}) {
         input.keyMode ?? "legacy",
         input.resumeKey ?? input.taskKey ?? "",
     ]);
-    return withKeyedLease(leaseKey, () => executeLocalUnlocked(input, callbacks, dependencies));
+    return withKeyedLease(leaseKey, () => executeLocalUnlocked(input, callbacks, dependencies), dependencies.cancellation);
 }
 async function executeLocalUnlocked(input, callbacks, dependencies) {
     const providerConfig = input.launch.providerConfig ?? {};
     const { runtime } = input;
     const currentModel = runtime.model ?? null;
     const providerFp = providerFingerprint(runtime.name, providerConfig);
-    const workspace = await prepareWorkspace({
+    const workspace = await awaitWithCancellation(prepareWorkspace({
         agentsRoot: input.launch.agentsRoot,
         handle: input.handle,
         cliPath: input.launch.cliPath,
@@ -183,8 +186,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
         ...(input.resumeKey === undefined ? {} : { resumeKey: input.resumeKey }),
         ...(input.launch.description ? { description: input.launch.description } : {}),
-    });
+    }), dependencies.cancellation);
     let materialized = null;
+    let knownAttachmentDirectory = null;
     try {
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
@@ -208,17 +212,38 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
         const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
         if (input.attachments && input.attachments.length > 0) {
-            materialized = await (dependencies.materializeAttachments ?? materializeAttachments)({
+            if (dependencies.cancellation?.isRequested())
+                throw new RuntimeCancelledError();
+            knownAttachmentDirectory = executionAttachmentDirectory(workspace.runDir, input.executionId);
+            const controller = new AbortController();
+            const materialization = Promise.resolve().then(() => (dependencies.materializeAttachments ?? materializeAttachments)({
                 serverUrl: input.launch.serverUrl,
                 token: input.launch.token,
                 runDir: workspace.runDir,
                 executionId: input.executionId,
                 attachments: input.attachments,
+                signal: controller.signal,
+            }));
+            dependencies.cancellation?.register(async () => {
+                controller.abort(new RuntimeCancelledError());
+                await materialization.then(() => undefined, () => undefined);
             });
+            try {
+                materialized = await materialization;
+            }
+            catch (error) {
+                if (dependencies.cancellation?.isRequested())
+                    throw new RuntimeCancelledError();
+                throw error;
+            }
+            if (dependencies.cancellation?.isRequested()) {
+                await dependencies.cancellation.waitForStop();
+                throw new RuntimeCancelledError();
+            }
         }
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
-        await writeFile(workspace.systemPromptPath, systemPrompt, "utf8");
+        await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
         const baseEnv = {
             ...process.env,
             ...sanitizeEnvVars(providerConfig.envVars),
@@ -242,6 +267,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
         const childEnv = applyProviderEnv(baseEnv, runtime.name, providerConfig, workspace.homeDir);
         const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
+        if (dependencies.cancellation?.isRequested())
+            throw new RuntimeCancelledError();
         const child = await launchRuntime({
             runtime: runtime.name,
             bin: runtime.name,
@@ -259,6 +286,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ? { imagePaths: attachmentPlan.nativeImagePaths }
                 : {}),
         });
+        if (child.cancel !== undefined) {
+            dependencies.cancellation?.register(child.cancel);
+        }
+        if (dependencies.cancellation?.isRequested()) {
+            await dependencies.cancellation.waitForStop();
+            throw new RuntimeCancelledError();
+        }
         const activities = [];
         let sessionId = launchSessionId;
         let usage;
@@ -301,7 +335,17 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             process.stderr.write(data);
             stderrTail = (stderrTail + String(data)).slice(-STDERR_TAIL_CAP);
         });
-        const { exitCode, spawnError, terminationSignal } = await child.exit;
+        let runtimeExit;
+        try {
+            runtimeExit = await awaitWithCancellation(child.exit, dependencies.cancellation);
+        }
+        catch (error) {
+            if (error instanceof RuntimeCancelledError) {
+                await dependencies.cancellation?.waitForStop();
+            }
+            throw error;
+        }
+        const { exitCode, spawnError, terminationSignal } = runtimeExit;
         const errorTail = [
             stderrTail.trim(),
             spawnError,
@@ -343,17 +387,24 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             finalText: input.captureFinal && finalText !== null
                 ? stripExternalAnswerMarkers(finalText)
                 : null,
+            externalAnswer: input.captureFinal && finalText !== null
+                ? extractExternalAnswer(finalText)
+                : null,
             sentViaCrew,
         };
     }
     finally {
-        if (materialized) {
+        const attachmentDirectories = new Set([
+            ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
+            ...(materialized === null ? [] : [materialized.directory]),
+        ]);
+        for (const directory of attachmentDirectories) {
             try {
-                await (dependencies.cleanupMaterializedAttachments ?? cleanupAttachments)(materialized.directory);
+                await (dependencies.cleanupMaterializedAttachments ?? cleanupAttachments)(directory);
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error);
-                process.stderr.write(`[execution] failed to remove attachments ${materialized.directory}: ${detail}\n`);
+                process.stderr.write(`[execution] failed to remove attachments ${directory}: ${detail}\n`);
             }
         }
         try {

package/dist/machine-info.js

@@ -24,6 +24,7 @@ export const DAEMON_CAPABILITIES = [
     "execution_telemetry_ack_v1",
     "execution_external_output_v1",
     "execution_attachments_v1",
+    "execution_answer_stream_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
@@ -102,7 +103,7 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         (dependencies.detectInstalled ?? detectRuntimes)(),
         listAgentHandles(agentsRoot),
     ]);
-    const backend = executionBackendCapability(runtimePlatform);
+    const backend = executionBackendCapability(runtimePlatform, dependencies.jobObjectProbe);
     const executionRuntimes = backend.supported
         ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
         : [];

package/dist/main.js

@@ -6,15 +6,18 @@
  * 后续 (M3c):常驻 + 连 server 控制面 WS,由 agent:start 自动唤醒。
  */
 import { parseArgs } from "node:util";
+import { homedir } from "node:os";
 import { loadConfig, ConfigError } from "./config.js";
-import { detectDaemonLang, translateDaemon } from "./i18n.js";
+import { detectDaemonLang, formatDaemonText, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
 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 { applyProfileToEnv, assertProfileAgentsRootUnique, daemonHome, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, } from "./computer-profile.js";
 import { runComputerCommand } from "./computer-cli.js";
+import { runServeLifecycle } from "./serve-lifecycle.js";
+import { formatDaemonStartupError } from "./daemon-startup-error.js";
 async function main() {
     const computerResult = await runComputerCommand(process.argv.slice(2));
     if (computerResult !== null) {
@@ -51,8 +54,13 @@ async function main() {
     // 不把 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);
+    if (values.profile) {
+        const home = daemonHome();
+        const profile = await loadProfile(values.profile, home);
+        if (cmd === "serve")
+            await assertProfileAgentsRootUnique(profile, home, homedir());
+        applyProfileToEnv(profile, process.env);
+    }
     // 命令行参数优先于环境变量,填回 env 供 loadConfig 读取
     if (values["server-url"])
         process.env.CREW_SERVER_URL = values["server-url"];
@@ -72,8 +80,10 @@ async function main() {
     }
     if (cmd === "serve") {
         process.stdout.write(formatDaemonLogLine(`🛰️  crew-daemon v${daemonVersion()} (cli v${cliVersion()}) ${td("resident, connecting to")} ${config.serverUrl} ${td("control plane")}...`) + "\n");
-        serve(config);
-        await new Promise(() => { }); // 常驻,直到被 kill
+        const service = serve(config, {
+            ...(values.profile === undefined ? {} : { profileName: values.profile }),
+        });
+        await runServeLifecycle(service);
         return;
     }
     if (!values.agent || !values.channel) {
@@ -93,6 +103,16 @@ async function main() {
     process.exit(result.exitCode);
 }
 main().catch((e) => {
-    process.stderr.write(`crew-daemon: ${e.message}\n`);
-    process.exit(1);
+    const lang = detectDaemonLang();
+    const message = formatDaemonStartupError(e, lang)
+        ?? (e instanceof ProfileAgentsRootConflictError
+            ? formatDaemonText(lang, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, {
+                profile: e.profile,
+                conflict: e.conflict,
+                agentsRoot: e.agentsRoot,
+                command: e.command,
+            })
+            : e.message);
+    process.stderr.write(`crew-daemon: ${message}\n`);
+    process.exitCode = 1;
 });

package/dist/runner.js

@@ -4,10 +4,12 @@ import { join } from "node:path";
 import { mintAgentToken } from "./token.js";
 import { buildSystemPrompt, buildWakePrompt, capMemoryForInject, capWorkLogForInject } from "./prompt.js";
 import { deliverScheduledReport, } from "./scheduled-report.js";
-import { executeLocal } from "./local-executor.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";
+import { launchSupervisedRuntime } from "./supervised-runtime.js";
+import { awaitWithCancellation, } from "./runtime-cancellation.js";
 export { awaitExit, exitActivity, sanitizeEnvVars } from "./local-executor.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
@@ -18,12 +20,12 @@ function runtimeName(value) {
         return value;
     throw new Error(`unsupported runtime: ${value}`);
 }
-export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }) {
-    const credential = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName, {
+export async function runAgent(config, input, onActivity = defaultPrint, onConsole = () => { }, dependencies = {}) {
+    const credential = await awaitWithCancellation((dependencies.mintAgentToken ?? mintAgentToken)(config.serverUrl, config.machineToken, input.handle, input.displayName, {
         ...(input.wakeMessageId ? { wakeThreadRoot: input.wakeMessageId } : {}),
         ...(input.wakeContextUpToSeq === undefined ? {} : { wakeContextUpToSeq: input.wakeContextUpToSeq }),
         ...(input.runId ? { agentRunId: input.runId } : {}),
-    });
+    }), dependencies.cancellation);
     const providerConfig = credential.config ?? {};
     const runtime = runtimeName(providerConfig.runtime ?? config.runtimeBin);
     const reasoning = ReasoningSchema.safeParse(providerConfig.reasoning);
@@ -35,7 +37,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     const boundImDecisionFileName = input.scheduled?.externalNotificationPolicy === "agent_decides"
         ? `.bound-im-decision-${executionId}.json`
         : null;
-    const local = await executeLocal({
+    const local = await (dependencies.executeLocal ?? executeLocal)({
         executionId,
         handle: input.handle,
         channelId: input.channelId,
@@ -101,7 +103,10 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             softTokens: config.sessionSoftTokens,
             maxTurns: config.sessionMaxTurns,
         },
-    }, { onActivity, onConsole });
+    }, { onActivity, onConsole }, {
+        launchRuntime: dependencies.launchRuntime ?? ((request) => launchSupervisedRuntime(request, dependencies.startSupervisor, dependencies.cancellation, dependencies.platform)),
+        ...(dependencies.cancellation === undefined ? {} : { cancellation: dependencies.cancellation }),
+    });
     const activities = [...local.activities];
     if (!input.scheduled && (runtime === "codex" || runtime === "kimi")
         && local.exitCode === 0 && !local.sentViaCrew && local.finalText) {

package/dist/runtime-cancellation.js

@@ -0,0 +1,74 @@
+export class RuntimeCancelledError extends Error {
+    constructor(message = "Runtime launch cancelled") {
+        super(message);
+        this.name = "RuntimeCancelledError";
+    }
+}
+export async function awaitWithCancellation(promise, cancellation) {
+    if (cancellation === undefined)
+        return promise;
+    if (cancellation.isRequested())
+        throw new RuntimeCancelledError();
+    const result = await Promise.race([
+        promise,
+        cancellation.requested.then(() => { throw new RuntimeCancelledError(); }),
+    ]);
+    if (cancellation.isRequested())
+        throw new RuntimeCancelledError();
+    return result;
+}
+export function createRuntimeCancellation() {
+    let requested = false;
+    let resolveRequested;
+    const requestedPromise = new Promise((resolve) => { resolveRequested = resolve; });
+    const registrations = new Map();
+    const startRegisteredStops = () => {
+        if (!requested)
+            return;
+        for (const [cancel, stopPromise] of registrations) {
+            if (stopPromise !== null)
+                continue;
+            const started = Promise.resolve().then(cancel);
+            registrations.set(cancel, started);
+            void started.catch(() => undefined);
+        }
+    };
+    const waitForStop = async () => {
+        if (!requested)
+            return;
+        while (true) {
+            startRegisteredStops();
+            const registrationCount = registrations.size;
+            const results = await Promise.allSettled([...registrations.values()].filter((value) => value !== null));
+            if (registrations.size !== registrationCount)
+                continue;
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length === 1)
+                throw failures[0];
+            if (failures.length > 1)
+                throw new AggregateError(failures, "Runtime cancellation failed");
+            return;
+        }
+    };
+    const cancellation = {
+        isRequested: () => requested,
+        requested: requestedPromise,
+        register: (next) => {
+            if (registrations.has(next))
+                return;
+            registrations.set(next, null);
+            startRegisteredStops();
+        },
+        waitForStop,
+    };
+    return {
+        cancellation,
+        request: () => {
+            if (requested)
+                return;
+            requested = true;
+            resolveRequested();
+            startRegisteredStops();
+        },
+    };
+}

package/dist/runtime-path.js

@@ -1,7 +1,8 @@
 /**
  * daemon 被非登录/非交互进程(sh -c / pnpm script / tmux / 后台转发)拉起时,继承的 PATH 常退化为系统
  * 默认,缺用户级 CLI 目录——尤其 Claude 官方原生安装器默认的 `~/.local/bin`。结果 `which claude` 探测
- * 落空、真正 spawn 也 ENOENT。这里在探测与启动前把常见安装目录补进 PATH,保证「扫得到 = 起得来」。
+ * 落空、真正 spawn 也 ENOENT。Kimi 官方安装器同样只把 `~/.kimi-code/bin` 写入 shell rc。
+ * 这里在探测与启动前把常见安装目录补进 PATH,保证「扫得到 = 起得来」。
  *
  * codex 装在 `/usr/local/bin`(系统默认 PATH 本就含之)所以不受影响;本模块对已在 PATH 中的目录是无操作。
  */
@@ -13,8 +14,10 @@ export function commonBinDirs(env = process.env, platform = process.platform) {
     const p = pathApi(platform);
     if (platform === "win32") {
         const dirs = [];
-        if (env.USERPROFILE)
-            dirs.push(p.join(env.USERPROFILE, ".local", "bin"));
+        if (env.USERPROFILE) {
+            dirs.push(p.join(env.USERPROFILE, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+            p.join(env.USERPROFILE, ".local", "bin"));
+        }
         if (env.APPDATA)
             dirs.push(p.join(env.APPDATA, "npm"));
         if (env.LOCALAPPDATA)
@@ -24,7 +27,8 @@ export function commonBinDirs(env = process.env, platform = process.platform) {
     const dirs = [];
     const home = env.HOME;
     if (home) {
-        dirs.push(p.join(home, ".local", "bin"), // Claude 官方原生安装器默认落点
+        dirs.push(p.join(home, ".kimi-code", "bin"), // Kimi 官方安装器默认落点
+        p.join(home, ".local", "bin"), // Claude 官方原生安装器默认落点
         p.join(home, ".claude", "local"));
     }
     dirs.push("/opt/homebrew/bin", "/usr/local/bin"); // Apple Silicon brew / Intel brew & npm 全局

package/dist/runtimes/claude.js

@@ -4,8 +4,11 @@
 // cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
 import spawn from "cross-spawn";
 // Claude Code 原生 --effort 档位(claude 2.1.196 实测:--help 与非法值告警均枚举这五档)。
-// 白名单外的值(含 "default" 与 codex 专属档)不传参 → 用 claude 自身默认,脏数据不影响启动。
+// 白名单外的值(含 "default" 与 codex 专属档)回落 CLAUDE_DEFAULT_EFFORT,脏数据不影响启动。
 export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+// 未配置/非法档位时的默认思考强度:medium 开启原生 thinking(终端透传要展示思考过程),
+// 又不至于 high/max 的 token 开销;agent 配置白名单档位可覆盖。
+export const CLAUDE_DEFAULT_EFFORT = "medium";
 export function buildClaudeArgs(input) {
     const args = [
         "--print",
@@ -18,9 +21,10 @@ export function buildClaudeArgs(input) {
     ];
     if (input.model)
         args.push("--model", input.model);
-    if (input.reasoning && CLAUDE_EFFORT_LEVELS.includes(input.reasoning)) {
-        args.push("--effort", input.reasoning);
-    }
+    const effort = input.reasoning && CLAUDE_EFFORT_LEVELS.includes(input.reasoning)
+        ? input.reasoning
+        : CLAUDE_DEFAULT_EFFORT;
+    args.push("--effort", effort);
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }

package/dist/runtimes/codex.js

@@ -5,17 +5,21 @@
 import spawn from "cross-spawn";
 // Codex CLI 原生 model_reasoning_effort 档位(codex 0.135.0 实测:非法值时 config 解析报错枚举这六档)。
 // 注意:codex 对非法值是硬失败(进程直接退出),所以必须白名单过滤;白名单外(含 "default"、
-// claude 专属的 "max")不传 → 用 codex 自身默认。
+// claude 专属的 "max")回落 CODEX_DEFAULT_EFFORT。
 export const CODEX_EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"];
+// 未配置/非法档位时的默认思考强度:medium 开启 reasoning(终端透传要展示思考过程);
+// 配置白名单档位(含显式 none 关思考)可覆盖。
+export const CODEX_DEFAULT_EFFORT = "medium";
 export function buildCodexArgs(input) {
     // agent 运行目录由 daemon 管理,不是 git 仓库;不带 --skip-git-repo-check 时 codex exec
     // 会以 "Not inside a trusted directory" 秒退(且只报在本地 stderr),表现为 agent 静默不回复。
     const args = ["exec", "--json", "--skip-git-repo-check"];
     if (input.model)
         args.push("--model", input.model);
-    if (input.reasoning && CODEX_EFFORT_LEVELS.includes(input.reasoning)) {
-        args.push("-c", `model_reasoning_effort=${input.reasoning}`);
-    }
+    const effort = input.reasoning && CODEX_EFFORT_LEVELS.includes(input.reasoning)
+        ? input.reasoning
+        : CODEX_DEFAULT_EFFORT;
+    args.push("-c", `model_reasoning_effort=${effort}`);
     if (input.effectivePermission === "sandboxed")
         args.push("--sandbox", "read-only");
     else if (input.effectivePermission === "workspace_write")

package/dist/serve-lifecycle.js

@@ -0,0 +1,82 @@
+import { dslog, flushSlog } from "./slog.js";
+function defaultDiagnose(diagnostic) {
+    const fields = {
+        signal: diagnostic.signal,
+        stage: diagnostic.stage,
+        active_execution_count: diagnostic.activeExecutionCount,
+        active_legacy_count: diagnostic.activeLegacyCount,
+        deadline_ms: diagnostic.deadlineMs,
+        ...(diagnostic.error === undefined ? {} : { error: diagnostic.error }),
+    };
+    try {
+        dslog(diagnostic.stage === "failed" ? "daemon.shutdown_failed" : "daemon.shutdown", `daemon shutdown ${diagnostic.stage}`, { level: diagnostic.stage === "failed" ? "ERROR" : "INFO", ...fields });
+        process.stderr.write(`${JSON.stringify({
+            level: diagnostic.stage === "failed" ? "ERROR" : "INFO",
+            event_type: diagnostic.stage === "failed" ? "daemon.shutdown_failed" : "daemon.shutdown",
+            ...fields,
+        })}\n`);
+    }
+    catch { /* shutdown diagnostics must never interrupt cleanup */ }
+}
+export async function runServeLifecycle(service, dependencies = {}) {
+    const signals = dependencies.signals ?? process;
+    const flush = dependencies.flush ?? flushSlog;
+    const diagnose = dependencies.diagnose ?? defaultDiagnose;
+    let receivedSignal = null;
+    let resolveSignal;
+    const signalReceived = new Promise((resolve) => { resolveSignal = resolve; });
+    const receive = (signal) => {
+        if (receivedSignal !== null)
+            return;
+        receivedSignal = signal;
+        resolveSignal(signal);
+    };
+    const onSigint = () => receive("SIGINT");
+    const onSigterm = () => receive("SIGTERM");
+    signals.on("SIGINT", onSigint);
+    signals.on("SIGTERM", onSigterm);
+    try {
+        try {
+            await service.ready;
+        }
+        catch (readyError) {
+            try {
+                await service.stop();
+            }
+            catch { /* preserve the readiness error */ }
+            try {
+                await flush();
+            }
+            catch { /* slog is best effort */ }
+            throw readyError;
+        }
+        const signal = await signalReceived;
+        const snapshot = service.shutdownSnapshot();
+        diagnose({ signal, stage: "stopping", ...snapshot });
+        let stopError;
+        try {
+            await service.stop();
+            diagnose({ signal, stage: "completed", ...snapshot });
+        }
+        catch (error) {
+            stopError = error;
+            diagnose({
+                signal,
+                stage: "failed",
+                error: error instanceof Error ? error.message : String(error),
+                ...snapshot,
+            });
+        }
+        try {
+            await flush();
+        }
+        catch { /* slog owns its own spool fallback */ }
+        if (stopError !== undefined)
+            throw stopError;
+        return { signal };
+    }
+    finally {
+        signals.off("SIGINT", onSigint);
+        signals.off("SIGTERM", onSigterm);
+    }
+}