@nowcrew/daemon 0.5.27 → 0.5.28

package/dist/runtimes/kimi-acp-runner.js

@@ -1,364 +0,0 @@
-import { once } from "node:events";
-import { parseArgs } from "node:util";
-import { Readable, Writable } from "node:stream";
-import { pathToFileURL } from "node:url";
-import spawn from "cross-spawn";
-import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from "@agentclientprotocol/sdk";
-import { augmentedPath } from "../runtime-path.js";
-import { startFirstProgressWatchdog } from "./progress-watchdog.js";
-import { assertKimiLegacyPromptFits, buildKimiArgs } from "./kimi.js";
-const ERROR_MESSAGE_CAP = 2_000;
-const PROBE_TIMEOUT_MS = 5_000;
-function jsonLine(event) {
-    if (process.stdout.write(`${JSON.stringify(event)}\n`))
-        return Promise.resolve();
-    return once(process.stdout, "drain").then(() => undefined);
-}
-function textContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content.flatMap((part) => {
-        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
-            return [part.text];
-        }
-        if (part && typeof part === "object" && "content" in part
-            && part.content && typeof part.content === "object"
-            && "type" in part.content && part.content.type === "text"
-            && "text" in part.content && typeof part.content.text === "string") {
-            return [part.content.text];
-        }
-        return [];
-    }).join("\n");
-}
-/** Translate stable ACP updates into daemon-owned NDJSON, without exposing thought chunks. */
-export function mapKimiAcpUpdate(update) {
-    if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-        return [{ type: "kimi.acp.text_delta", text: update.content.text }];
-    }
-    if (update.sessionUpdate === "tool_call") {
-        return [{
-                type: "kimi.acp.tool_call",
-                id: update.toolCallId,
-                title: update.title,
-                ...(update.kind === undefined ? {} : { kind: update.kind }),
-                ...(update.status === undefined ? {} : { status: update.status }),
-                ...(update.rawInput === undefined ? {} : { input: update.rawInput }),
-            }];
-    }
-    if (update.sessionUpdate === "tool_call_update") {
-        const output = textContent(update.content);
-        return [{
-                type: "kimi.acp.tool_result",
-                id: update.toolCallId,
-                ...(update.status === undefined ? {} : { status: update.status }),
-                ...(output ? { content: output } : {}),
-            }];
-    }
-    return [];
-}
-function safeErrorMessage(error, prompt) {
-    const raw = error instanceof Error ? error.message : String(error);
-    const redacted = prompt && raw.includes(prompt) ? raw.replaceAll(prompt, "[prompt redacted]") : raw;
-    return redacted.slice(0, ERROR_MESSAGE_CAP);
-}
-export function isKimiAuthenticationRequired(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /\bauthentication required\b/i.test(message);
-}
-export function kimiResumeMethod(capabilities) {
-    if (capabilities?.sessionCapabilities?.resume != null)
-        return "resume";
-    if (capabilities?.loadSession)
-        return "load";
-    return null;
-}
-/** Full access may approve an operation, but it must never fabricate an answer to an agent question. */
-export function selectKimiPermission(params) {
-    const allowOnce = params.options.filter((option) => option.kind === "allow_once");
-    if (params.toolCall.title === "AskUserQuestion" || allowOnce.length > 1) {
-        return { outcome: { outcome: "cancelled" } };
-    }
-    const allowed = allowOnce[0]
-        ?? (params.options.filter((option) => option.kind === "allow_always").length === 1
-            ? params.options.find((option) => option.kind === "allow_always")
-            : undefined);
-    return allowed === undefined
-        ? { outcome: { outcome: "cancelled" } }
-        : { outcome: { outcome: "selected", optionId: allowed.optionId } };
-}
-async function readPrompt() {
-    process.stdin.setEncoding("utf8");
-    let prompt = "";
-    for await (const chunk of process.stdin)
-        prompt += String(chunk);
-    if (!prompt)
-        throw new Error("Kimi ACP prompt is empty");
-    return prompt;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return;
-    const closed = once(child, "close").then(() => undefined);
-    child.kill("SIGTERM");
-    let timer;
-    const graceful = await Promise.race([
-        closed.then(() => true),
-        new Promise((resolve) => { timer = setTimeout(() => resolve(false), 1_000); }),
-    ]);
-    if (timer !== undefined)
-        clearTimeout(timer);
-    if (!graceful && child.exitCode === null && child.signalCode === null) {
-        child.kill("SIGKILL");
-        await closed;
-    }
-}
-/** Probe the ACP transport without starting a session or forcing an optional interactive login flow. */
-export async function probeKimiAcp(options, spawnProcess = spawn) {
-    const child = spawnProcess(options.bin, ["acp"], {
-        cwd: process.cwd(),
-        // probe 在 daemon 自身 PATH 下运行,补上用户级 CLI 目录,与 which 探测保持一致。
-        env: { ...process.env, PATH: augmentedPath() },
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    if (child.stdin === null || child.stdout === null || child.stderr === null)
-        return false;
-    child.stderr.resume();
-    const app = client({ name: "nowcrew-daemon-kimi-probe" })
-        .onRequest(methods.client.session.requestPermission, () => ({
-        outcome: { outcome: "cancelled" },
-    }))
-        .onNotification(methods.client.session.update, () => undefined);
-    let timeout;
-    try {
-        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
-        const connected = app.connectWith(stream, async (context) => {
-            await context.request(methods.agent.initialize, {
-                protocolVersion: PROTOCOL_VERSION,
-                clientCapabilities: {},
-                clientInfo: { name: "nowcrew-daemon", version: "1" },
-            });
-            return true;
-        });
-        const result = await Promise.race([
-            connected,
-            new Promise((resolve) => {
-                timeout = setTimeout(() => {
-                    void stopChild(child);
-                    resolve(false);
-                }, PROBE_TIMEOUT_MS);
-            }),
-        ]);
-        return result;
-    }
-    catch {
-        return false;
-    }
-    finally {
-        if (timeout !== undefined)
-            clearTimeout(timeout);
-        await stopChild(child);
-    }
-}
-export async function runKimiAcp(options) {
-    const prompt = await readPrompt();
-    const child = spawn(options.bin, ["acp"], {
-        cwd: process.cwd(),
-        env: process.env,
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    let runtimeChild = child;
-    if (child.stdin === null || child.stdout === null || child.stderr === null) {
-        throw new Error("Kimi ACP process did not expose stdio");
-    }
-    child.stderr.pipe(process.stderr, { end: false });
-    let context = null;
-    let sessionId = null;
-    let acpSemanticProgress = false;
-    let progressTimedOut = false;
-    let cancelling = false;
-    const cancel = async () => {
-        if (cancelling)
-            return;
-        cancelling = true;
-        if (context !== null && sessionId !== null) {
-            await context.notify(methods.agent.session.cancel, { sessionId }).catch(() => undefined);
-        }
-        await stopChild(runtimeChild);
-    };
-    const onSignal = () => {
-        void cancel().finally(() => process.exit(130));
-    };
-    process.once("SIGTERM", onSignal);
-    process.once("SIGINT", onSignal);
-    const app = client({ name: "nowcrew-daemon-kimi" })
-        .onRequest(methods.client.session.requestPermission, ({ params }) => selectKimiPermission(params))
-        .onNotification(methods.client.session.update, async ({ params }) => {
-        acpSemanticProgress = true;
-        firstProgress.observe();
-        for (const event of mapKimiAcpUpdate(params.update))
-            await jsonLine(event);
-    });
-    let firstProgress = startFirstProgressWatchdog(() => undefined);
-    firstProgress.stop();
-    try {
-        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
-        const result = await app.connectWith(stream, async (nextContext) => {
-            context = nextContext;
-            const initialized = await nextContext.request(methods.agent.initialize, {
-                protocolVersion: PROTOCOL_VERSION,
-                clientCapabilities: {},
-                clientInfo: { name: "nowcrew-daemon", version: "1" },
-            });
-            if (process.env.CREW_KIMI_ACP_DEBUG === "1") {
-                process.stderr.write(`Kimi ACP auth methods: ${JSON.stringify(initialized.authMethods ?? [])}\n`);
-            }
-            if (options.resume && options.sessionId) {
-                const resumeMethod = kimiResumeMethod(initialized.agentCapabilities);
-                if (resumeMethod === "resume") {
-                    await nextContext.request(methods.agent.session.resume, {
-                        sessionId: options.sessionId,
-                        cwd: process.cwd(),
-                        mcpServers: [],
-                    });
-                }
-                else if (resumeMethod === "load") {
-                    await nextContext.request(methods.agent.session.load, {
-                        sessionId: options.sessionId,
-                        cwd: process.cwd(),
-                        mcpServers: [],
-                    });
-                }
-                else {
-                    throw new Error("Kimi ACP does not advertise session resume support");
-                }
-                sessionId = options.sessionId;
-            }
-            else {
-                const session = await nextContext.request(methods.agent.session.new, {
-                    cwd: process.cwd(),
-                    mcpServers: [],
-                });
-                sessionId = session.sessionId;
-            }
-            await jsonLine({ type: "thread.started", thread_id: sessionId });
-            if (options.model) {
-                await nextContext.request(methods.agent.session.setConfigOption, {
-                    sessionId,
-                    configId: "model",
-                    value: options.model,
-                });
-            }
-            firstProgress = startFirstProgressWatchdog(() => {
-                progressTimedOut = true;
-                void cancel();
-            });
-            return nextContext.request(methods.agent.session.prompt, {
-                sessionId,
-                prompt: [{ type: "text", text: prompt }],
-            });
-        });
-        firstProgress.stop();
-        if (progressTimedOut) {
-            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
-            return 1;
-        }
-        const usage = result.usage;
-        await jsonLine({
-            type: "turn.completed",
-            stop_reason: result.stopReason,
-            ...(usage === undefined || usage === null ? {} : {
-                usage: {
-                    input_tokens: usage.inputTokens,
-                    output_tokens: usage.outputTokens,
-                    cache_read_input_tokens: usage.cachedReadTokens ?? 0,
-                    cache_creation_input_tokens: usage.cachedWriteTokens ?? 0,
-                },
-            }),
-        });
-        return result.stopReason === "end_turn" ? 0 : result.stopReason === "cancelled" ? 130 : 1;
-    }
-    catch (error) {
-        if (progressTimedOut) {
-            process.stderr.write("Kimi produced no semantic progress within the startup window\n");
-            return 1;
-        }
-        if (!acpSemanticProgress && isKimiAuthenticationRequired(error)) {
-            firstProgress.stop();
-            await stopChild(child);
-            process.stderr.write("Kimi ACP requires account login; falling back to configured CLI provider transport\n");
-            assertKimiLegacyPromptFits(prompt);
-            const fallback = spawn(options.bin, buildKimiArgs({
-                wakePrompt: prompt,
-                effectivePermission: "full_access",
-                ...(options.model === undefined ? {} : { model: options.model }),
-                ...(options.resume && options.sessionId ? { sessionId: options.sessionId } : {}),
-            }), {
-                cwd: process.cwd(),
-                env: process.env,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            runtimeChild = fallback;
-            if (fallback.stdout === null || fallback.stderr === null) {
-                throw new Error("Kimi CLI fallback did not expose output streams");
-            }
-            firstProgress = startFirstProgressWatchdog(() => {
-                progressTimedOut = true;
-                void stopChild(fallback);
-            });
-            fallback.stdout.on("data", () => firstProgress.observe());
-            fallback.stdout.pipe(process.stdout, { end: false });
-            fallback.stderr.pipe(process.stderr, { end: false });
-            const code = await new Promise((resolve, reject) => {
-                fallback.once("error", reject);
-                fallback.once("close", (exitCode, signal) => {
-                    resolve(exitCode ?? (signal === null ? 1 : 128));
-                });
-            });
-            firstProgress.stop();
-            if (progressTimedOut) {
-                process.stderr.write("Kimi CLI fallback produced no output within the startup window\n");
-                return 1;
-            }
-            return code;
-        }
-        process.stderr.write(`Kimi ACP execution failed: ${safeErrorMessage(error, prompt)}\n`);
-        return 1;
-    }
-    finally {
-        firstProgress.stop();
-        process.off("SIGTERM", onSignal);
-        process.off("SIGINT", onSignal);
-        await stopChild(child);
-    }
-}
-function optionsFromArgv(argv) {
-    const { values } = parseArgs({
-        args: [...argv],
-        options: {
-            bin: { type: "string" },
-            model: { type: "string" },
-            session: { type: "string" },
-            resume: { type: "boolean", default: false },
-        },
-    });
-    if (!values.bin)
-        throw new Error("--bin is required");
-    if (values.resume && !values.session)
-        throw new Error("--resume requires --session");
-    return {
-        bin: values.bin,
-        ...(values.model ? { model: values.model } : {}),
-        ...(values.session ? { sessionId: values.session } : {}),
-        ...(values.resume ? { resume: true } : {}),
-    };
-}
-if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
-    runKimiAcp(optionsFromArgv(process.argv.slice(2)))
-        .then((code) => { process.exitCode = code; })
-        .catch((error) => {
-        process.stderr.write(`Kimi ACP runner failed: ${safeErrorMessage(error, "")}\n`);
-        process.exitCode = 1;
-    });
-}

package/dist/runtimes/kimi.js

@@ -1,45 +0,0 @@
-/**
- * Kimi Code CLI runtime adapter: non-interactive prompt mode with stream-json output.
- *
- * 事实依据(kimi-code 0.23.0 本机实测 + 官方文档 www.kimi.com/code/docs):
- * - `kimi -p <prompt> --output-format stream-json`:单次非交互执行,stdout 每行一个 JSON。
- * - `-p` 固定 auto 权限(自动批准普通工具调用),且与 --yolo/--auto/--plan 互斥,
- *   故 dangerous 无需(也不能)映射任何 flag。
- * - 无 system prompt 注入参数 → 与 codex 同法:systemPrompt 拼在 wakePrompt 前。
- * - 鉴权是机器级的(`kimi login` 或 ~/.kimi-code/config.toml),不读 shell 环境变量。
- */
-// cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
-import spawn from "cross-spawn";
-// Windows CreateProcess receives one UTF-16 command line. Reserve room for the executable, flags,
-// model and cmd shim quoting instead of relying on the theoretical 32767-character ceiling.
-export const KIMI_LEGACY_PROMPT_MAX_UTF16 = 28_000;
-export function assertKimiLegacyPromptFits(prompt, platform = process.platform) {
-    if (platform !== "win32" || prompt.length <= KIMI_LEGACY_PROMPT_MAX_UTF16)
-        return;
-    throw new Error(`Kimi legacy prompt exceeds the Windows argv limit (${prompt.length}/${KIMI_LEGACY_PROMPT_MAX_UTF16}); `
-        + "shorten the prompt (protocol-v1 remains disabled on Windows until Job Object ownership is available)");
-}
-// Kimi Code 思考强度档位(kimi-code 0.23.0 实测+源码):无 CLI 参数,
-// 由 runner 经 KIMI_MODEL_THINKING_EFFORT env 注入;白名单外的值不注。
-export const KIMI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
-export function buildKimiArgs(input) {
-    if (input.effectivePermission !== undefined && input.effectivePermission !== "full_access") {
-        throw new Error(`Kimi prompt mode cannot enforce ${input.effectivePermission} permission`);
-    }
-    const args = ["--output-format", "stream-json"];
-    if (input.model)
-        args.push("--model", input.model);
-    if (input.sessionId)
-        args.push("--session", input.sessionId);
-    args.push("--prompt", input.wakePrompt);
-    return args;
-}
-export function spawnKimi(input) {
-    assertKimiLegacyPromptFits(input.wakePrompt);
-    // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
-    return spawn(input.bin, buildKimiArgs(input), {
-        cwd: input.cwd,
-        env: input.env,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-}

package/dist/runtimes/progress-watchdog.js

@@ -1,26 +0,0 @@
-export const DEFAULT_FIRST_PROGRESS_TIMEOUT_MS = 120_000;
-/**
- * Bound the silent gap after a protocol turn starts. Once any semantic notification arrives,
- * the runtime's configured total timeout remains authoritative; long-running tools are not killed
- * merely because they produce no output.
- */
-export function startFirstProgressWatchdog(onTimeout, timeoutMs = DEFAULT_FIRST_PROGRESS_TIMEOUT_MS) {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-        throw new RangeError("First-progress timeout must be a positive finite number");
-    }
-    let active = true;
-    const timer = setTimeout(() => {
-        if (!active)
-            return;
-        active = false;
-        onTimeout();
-    }, timeoutMs);
-    timer.unref?.();
-    const stop = () => {
-        if (!active)
-            return;
-        active = false;
-        clearTimeout(timer);
-    };
-    return { observe: stop, stop };
-}

package/dist/scheduled-report.js

@@ -1,51 +0,0 @@
-export function normalizeScheduledPolicy(value) {
-    return value === "always_report" ? "always_report" : "silent_unless_report";
-}
-export function normalizeExternalNotificationPolicy(value) {
-    return value === "agent_decides" ? "agent_decides" : "disabled";
-}
-export function normalizeScheduledContext(input) {
-    return {
-        jobId: input.jobId,
-        runId: input.runId,
-        title: input.title?.trim() || "Scheduled job",
-        outputPolicy: normalizeScheduledPolicy(input.outputPolicy),
-        externalNotificationPolicy: normalizeExternalNotificationPolicy(input.externalNotificationPolicy),
-    };
-}
-export async function deliverScheduledReport(input) {
-    const title = input.title.trim() || "Scheduled job";
-    let source = "none";
-    let content = null;
-    if (input.exitCode !== 0) {
-        source = "failure_notice";
-        const detail = input.errorMessage?.trim().slice(0, 500);
-        content = `Scheduled job "${title}" failed${detail ? `: ${detail}` : ` (exit ${input.exitCode})`}.`;
-    }
-    else if (input.policy === "always_report") {
-        if (input.finalText?.trim()) {
-            source = "runtime_final";
-            content = input.finalText.trim();
-        }
-        else {
-            source = "empty_notice";
-            content = `Scheduled job "${title}" completed without a usable report.`;
-        }
-    }
-    if (!content) {
-        return { required: false, attempted: false, delivered: false, source: "none" };
-    }
-    try {
-        const sent = await input.send(content);
-        return {
-            required: true,
-            attempted: true,
-            delivered: sent.delivered,
-            status: sent.status,
-            source,
-        };
-    }
-    catch {
-        return { required: true, attempted: true, delivered: false, source };
-    }
-}

package/dist/scheduled-run-report.js

@@ -1,57 +0,0 @@
-function fields(input) {
-    return {
-        ...(input.scheduledRunId ? { scheduled_run_id: input.scheduledRunId } : {}),
-        run_id: input.runId,
-        agent_handle: input.agentHandle,
-        channel_id: input.channelId,
-        exit_code: input.exitCode,
-        ...(input.runtime ? { runtime: input.runtime } : {}),
-        ...(input.model ? { model: input.model } : {}),
-    };
-}
-export function reportAgentRunComplete(socket, input, log) {
-    const eventPrefix = input.scheduledRunId ? "scheduled_run" : "run";
-    if (!socket) {
-        log(`${eventPrefix}.complete_send_failed`, "Agent 完成回报未发送:控制面连接不可用", {
-            level: "WARN", ...fields(input), error_message: "control socket unavailable",
-        });
-        return;
-    }
-    const payload = JSON.stringify({
-        type: "agent:run-complete",
-        runId: input.runId,
-        agentHandle: input.agentHandle,
-        channelId: input.channelId,
-        ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),
-        ...(input.scheduledRunId ? { scheduledRunId: input.scheduledRunId } : {}),
-        exitCode: input.exitCode,
-        ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
-        ...(input.originDecision ? { originDecision: input.originDecision } : {}),
-        ...(input.contextUpToSeq !== undefined ? { contextUpToSeq: input.contextUpToSeq } : {}),
-        ...(input.runtime ? { runtime: input.runtime } : {}),
-        ...(input.model !== undefined ? { model: input.model } : {}),
-        ...(input.resumed !== undefined ? { resumed: input.resumed } : {}),
-        ...(input.errorMessage ? { errorMessage: input.errorMessage } : {}),
-        ...(input.usage ? { usage: input.usage } : {}),
-        ...(input.report ? { report: input.report } : {}),
-    });
-    try {
-        socket.send(payload, (error) => {
-            if (error) {
-                log(`${eventPrefix}.complete_send_failed`, "Agent 完成回报发送失败", {
-                    level: "WARN", ...fields(input), error_message: error.message,
-                });
-                return;
-            }
-            log(`${eventPrefix}.complete_sent`, "Agent 完成回报已发送", fields(input));
-        });
-    }
-    catch (error) {
-        log(`${eventPrefix}.complete_send_failed`, "Agent 完成回报发送失败", {
-            level: "WARN", ...fields(input), error_message: error.message,
-        });
-    }
-}
-export function reportScheduledRunComplete(socket, input, log) {
-    reportAgentRunComplete(socket, input, log);
-}

package/dist/serve-lifecycle.js

@@ -1,82 +0,0 @@
-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);
-    }
-}