@nowcrew/daemon 0.5.13 → 0.5.15

package/dist/computer-service.js

@@ -0,0 +1,358 @@
+import { access, chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+import { dirname, resolve } from "node:path";
+const execFileAsync = promisify(execFile);
+const WINDOWS_STOP_TIMEOUT_MS = 5_000;
+const WINDOWS_STOP_POLL_MS = 100;
+export const systemCommandRunner = async (command, args) => {
+    try {
+        const result = await execFileAsync(command, [...args], { encoding: "utf8" });
+        return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            exitCode: typeof failure.code === "number" ? failure.code : 127,
+            stdout: failure.stdout ?? "",
+            stderr: failure.stderr ?? failure.message,
+        };
+    }
+};
+function assertSingleLine(value, field) {
+    if (value.includes("\n") || value.includes("\r") || value.includes("\0")) {
+        throw new Error(`${field} must not contain control characters`);
+    }
+    return value;
+}
+function xml(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function systemdArg(value) {
+    return `"${assertSingleLine(value, "service argument").replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%")}"`;
+}
+export function windowsCommandArg(value) {
+    const input = assertSingleLine(value, "service argument");
+    return `"${input.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\*)$/g, "$1$1")}"`;
+}
+export function buildServiceSpec(input) {
+    const { platform, profile, userHome } = input;
+    if (platform !== "darwin" && platform !== "linux" && platform !== "win32") {
+        throw new Error(`Computer services are not supported on platform '${platform}'`);
+    }
+    const daemonCommand = [
+        assertSingleLine(input.nodePath, "node path"),
+        assertSingleLine(input.entryPath, "daemon entry path"),
+        "serve",
+        "--profile",
+        assertSingleLine(profile, "profile"),
+        ...(input.profileHome ? ["--daemon-home", assertSingleLine(input.profileHome, "daemon home")] : []),
+    ];
+    if (platform === "darwin") {
+        if (input.uid === undefined)
+            throw new Error("Cannot install launchd service without a numeric uid");
+        const id = `com.nowcrew.daemon.${profile}`;
+        const args = daemonCommand.map((arg) => `      <string>${xml(arg)}</string>`).join("\n");
+        return {
+            platform,
+            profile,
+            id,
+            descriptorPath: resolve(userHome, "Library", "LaunchAgents", `${id}.plist`),
+            daemonCommand,
+            managerDomain: `gui/${input.uid}`,
+            descriptor: `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>Label</key><string>${xml(id)}</string>\n  <key>ProgramArguments</key>\n  <array>\n${args}\n  </array>\n  <key>KeepAlive</key><true/>\n  <key>ProcessType</key><string>Background</string>\n</dict>\n</plist>\n`,
+        };
+    }
+    if (platform === "linux") {
+        const id = `nowcrew-daemon-${profile}.service`;
+        return {
+            platform,
+            profile,
+            id,
+            descriptorPath: resolve(userHome, ".config", "systemd", "user", id),
+            daemonCommand,
+            managerDomain: null,
+            descriptor: `[Unit]\nDescription=NowCrew daemon (${profile})\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nExecStart=${daemonCommand.map(systemdArg).join(" ")}\nRestart=on-failure\nRestartSec=5\n\n[Install]\nWantedBy=default.target\n`,
+        };
+    }
+    const id = `NowCrew Daemon (${profile})`;
+    return { platform, profile, id, descriptorPath: null, descriptor: null, daemonCommand, managerDomain: null };
+}
+async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function writePrivateAtomic(path, content) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await chmod(dirname(path), 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+async function checked(runner, command, args, action) {
+    const result = await runner(command, args);
+    if (result.exitCode !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`;
+        throw new Error(`${action} failed: ${detail}`);
+    }
+    return result;
+}
+async function windowsTaskState(spec, runner) {
+    const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
+    const script = [
+        "$ErrorActionPreference='Stop';",
+        "$n=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
+        "$tasks=@(Get-ScheduledTask -ErrorAction Stop|Where-Object{$_.TaskPath -eq '\\' -and $_.TaskName -ceq $n});",
+        "if($tasks.Count -eq 0){'missing'}elseif($tasks.Count -eq 1){'state:'+([int]$tasks[0].State)}else{throw 'duplicate scheduled tasks'}",
+    ].join("");
+    const result = await runner("powershell.exe", [
+        "-NoProfile", "-NonInteractive", "-Command", script, encodedName,
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Unable to query scheduled task: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+    }
+    const value = result.stdout.trim();
+    if (value === "missing")
+        return { installed: false, state: null, result };
+    const match = /^state:([0-4])$/.exec(value);
+    if (!match)
+        throw new Error(`Scheduled task returned an unknown state '${value}'`);
+    return { installed: true, state: Number(match[1]), result };
+}
+async function windowsTaskExists(spec, runner) {
+    return (await windowsTaskState(spec, runner)).installed;
+}
+async function stopWindowsTask(spec, initial, runner) {
+    if (initial.state !== 2 && initial.state !== 4)
+        return initial.installed;
+    await checked(runner, "schtasks.exe", ["/End", "/TN", spec.id], "Scheduled task stop");
+    const deadline = Date.now() + WINDOWS_STOP_TIMEOUT_MS;
+    while (true) {
+        const current = await windowsTaskState(spec, runner);
+        if (!current.installed)
+            return false;
+        if (current.state !== 2 && current.state !== 4)
+            return true;
+        if (Date.now() >= deadline) {
+            throw new Error(`Scheduled task '${spec.id}' did not stop within ${WINDOWS_STOP_TIMEOUT_MS}ms`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, WINDOWS_STOP_POLL_MS));
+    }
+}
+export async function installService(spec, runner = systemCommandRunner) {
+    if (spec.platform === "win32") {
+        if (await windowsTaskExists(spec, runner))
+            throw new Error(`Service '${spec.id}' is already installed`);
+        const encodedName = Buffer.from(spec.id, "utf16le").toString("base64");
+        const encodedExecutable = Buffer.from(spec.daemonCommand[0], "utf16le").toString("base64");
+        const encodedArguments = Buffer.from(spec.daemonCommand.slice(1).map(windowsCommandArg).join(" "), "utf16le").toString("base64");
+        const script = [
+            "$ErrorActionPreference='Stop';",
+            "$name=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
+            "$exe=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[1]));",
+            "$argv=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[2]));",
+            "$identity=[Security.Principal.WindowsIdentity]::GetCurrent().Name;",
+            "$action=New-ScheduledTaskAction -Execute $exe -Argument $argv;",
+            "$trigger=New-ScheduledTaskTrigger -AtLogOn -User $identity;",
+            "$settings=New-ScheduledTaskSettingsSet -ExecutionTimeLimit ([TimeSpan]::Zero) -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1);",
+            "$principal=New-ScheduledTaskPrincipal -UserId $identity -LogonType Interactive -RunLevel Limited;",
+            "Register-ScheduledTask -TaskName $name -TaskPath '\\' -Action $action -Trigger $trigger -Settings $settings -Principal $principal -ErrorAction Stop|Out-Null;",
+        ].join("");
+        await checked(runner, "powershell.exe", [
+            "-NoProfile", "-NonInteractive", "-Command", script,
+            encodedName, encodedExecutable, encodedArguments,
+        ], "Scheduled task installation");
+        return;
+    }
+    if (spec.descriptorPath === null || spec.descriptor === null)
+        throw new Error("Missing service descriptor");
+    if (await pathExists(spec.descriptorPath))
+        throw new Error(`Service '${spec.id}' is already installed`);
+    await writePrivateAtomic(spec.descriptorPath, spec.descriptor);
+    try {
+        if (spec.platform === "linux") {
+            await checked(runner, "systemctl", ["--user", "daemon-reload"], "systemd reload");
+            await checked(runner, "systemctl", ["--user", "enable", spec.id], "systemd enable");
+        }
+    }
+    catch (error) {
+        await rm(spec.descriptorPath, { force: true });
+        if (spec.platform === "linux") {
+            await runner("systemctl", ["--user", "disable", spec.id]);
+            await runner("systemctl", ["--user", "daemon-reload"]);
+        }
+        throw error;
+    }
+}
+export async function uninstallService(spec, runner = systemCommandRunner) {
+    if (spec.platform === "win32") {
+        const task = await windowsTaskState(spec, runner);
+        if (!task.installed)
+            throw new Error(`Service '${spec.id}' is not installed`);
+        if (!await stopWindowsTask(spec, task, runner))
+            return;
+        await checked(runner, "schtasks.exe", ["/Delete", "/TN", spec.id, "/F"], "Scheduled task removal");
+        return;
+    }
+    if (spec.descriptorPath === null || !await pathExists(spec.descriptorPath)) {
+        throw new Error(`Service '${spec.id}' is not installed`);
+    }
+    if (spec.platform === "darwin") {
+        const status = await serviceStatus(spec, runner);
+        if (status.loaded) {
+            await checked(runner, "launchctl", ["bootout", `${spec.managerDomain}/${spec.id}`], "launchd bootout");
+        }
+    }
+    else {
+        const disable = await runner("systemctl", ["--user", "disable", "--now", spec.id]);
+        if (disable.exitCode !== 0 && !/not loaded|does not exist|not found/i.test(`${disable.stdout}\n${disable.stderr}`)) {
+            throw new Error(`systemd disable failed: ${disable.stderr.trim() || disable.stdout.trim()}`);
+        }
+    }
+    await rm(spec.descriptorPath);
+    if (spec.platform === "linux") {
+        await checked(runner, "systemctl", ["--user", "daemon-reload"], "systemd reload");
+    }
+}
+export async function serviceAction(spec, action, runner = systemCommandRunner) {
+    if (spec.platform !== "win32" && (spec.descriptorPath === null || !await pathExists(spec.descriptorPath))) {
+        throw new Error(`Service '${spec.id}' is not installed`);
+    }
+    if (spec.platform === "darwin") {
+        const target = `${spec.managerDomain}/${spec.id}`;
+        const status = await serviceStatus(spec, runner);
+        if (action === "start") {
+            if (status.loaded)
+                await checked(runner, "launchctl", ["kickstart", "-k", target], "launchd start");
+            else
+                await checked(runner, "launchctl", ["bootstrap", spec.managerDomain, spec.descriptorPath], "launchd start");
+        }
+        else if (action === "stop") {
+            if (status.loaded)
+                await checked(runner, "launchctl", ["bootout", target], "launchd stop");
+        }
+        else {
+            if (status.loaded)
+                await checked(runner, "launchctl", ["bootout", target], "launchd stop");
+            await checked(runner, "launchctl", ["bootstrap", spec.managerDomain, spec.descriptorPath], "launchd start");
+        }
+    }
+    else if (spec.platform === "linux") {
+        await checked(runner, "systemctl", ["--user", action, spec.id], `systemd ${action}`);
+    }
+    else {
+        const task = await windowsTaskState(spec, runner);
+        if (!task.installed)
+            throw new Error(`Service '${spec.id}' is not installed`);
+        if (action === "start")
+            await checked(runner, "schtasks.exe", ["/Run", "/TN", spec.id], "Scheduled task start");
+        else if (action === "stop") {
+            await stopWindowsTask(spec, task, runner);
+        }
+        else {
+            if (!await stopWindowsTask(spec, task, runner)) {
+                throw new Error(`Service '${spec.id}' disappeared while restarting`);
+            }
+            await checked(runner, "schtasks.exe", ["/Run", "/TN", spec.id], "Scheduled task start");
+        }
+    }
+}
+export async function serviceStatus(spec, runner = systemCommandRunner) {
+    if (spec.platform === "win32") {
+        const task = await windowsTaskState(spec, runner);
+        return {
+            ...task.result,
+            installed: task.installed,
+            loaded: task.installed,
+            running: task.state === 4,
+        };
+    }
+    if (spec.descriptorPath === null || !await pathExists(spec.descriptorPath)) {
+        return { exitCode: 3, stdout: "", stderr: "service descriptor not found", installed: false, loaded: false, running: false };
+    }
+    const result = spec.platform === "darwin"
+        ? await runner("launchctl", ["print", `${spec.managerDomain}/${spec.id}`])
+        : await runner("systemctl", ["--user", "is-active", spec.id]);
+    const running = spec.platform === "darwin"
+        ? result.exitCode === 0 && /\bstate\s*=\s*running\b/.test(result.stdout)
+        : result.exitCode === 0;
+    return { ...result, installed: true, loaded: spec.platform === "darwin" ? result.exitCode === 0 : true, running };
+}
+export async function doctorService(spec, profilePrivate, runner = systemCommandRunner) {
+    const nodeMajor = Number(process.versions.node.split(".")[0]);
+    const tool = spec.platform === "darwin" ? "launchctl" : spec.platform === "linux" ? "systemctl" : "schtasks.exe";
+    const probeArgs = spec.platform === "linux" ? ["--user", "--version"] : spec.platform === "darwin" ? ["help"] : ["/Query", "/?"];
+    const probe = await runner(tool, probeArgs);
+    const status = await serviceStatus(spec, runner);
+    return [
+        { name: "node", ok: nodeMajor >= 22, detail: `Node ${process.versions.node} (requires >=22)` },
+        { name: "profile-permissions", ok: profilePrivate, detail: profilePrivate ? "private" : "readable by other users" },
+        { name: "service-manager", ok: probe.exitCode === 0, detail: probe.exitCode === 0 ? tool : (probe.stderr.trim() || `${tool} unavailable`) },
+        { name: "service-installed", ok: status.installed, detail: status.installed ? spec.id : "not installed" },
+        { name: "service-running", ok: status.running === true, detail: status.running ? "running" : "not running" },
+    ];
+}
+export function buildUpgradeCommand(platform) {
+    return [platform === "win32" ? "npm.cmd" : "npm", ["install", "--global", "@nowcrew/daemon@latest"]];
+}
+export async function upgradeDaemon(platform, runner = systemCommandRunner) {
+    const [command, args] = buildUpgradeCommand(platform);
+    await checked(runner, command, args, "Daemon upgrade");
+}
+const WINDOWS_SID_SCRIPT = "[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value";
+export async function hardenWindowsProfile(path, runner = systemCommandRunner) {
+    const identity = await checked(runner, "powershell.exe", [
+        "-NoProfile", "-NonInteractive", "-Command", WINDOWS_SID_SCRIPT,
+    ], "Windows identity lookup");
+    const sid = identity.stdout.trim();
+    if (!/^S-1-(?:\d+-)+\d+$/.test(sid))
+        throw new Error("Windows identity lookup returned an invalid SID");
+    await checked(runner, "icacls.exe", [path, "/inheritance:r", "/grant:r", `*${sid}:(F)`], "Profile ACL hardening");
+}
+export async function windowsProfileIsPrivate(path, runner = systemCommandRunner) {
+    const encodedPath = Buffer.from(path, "utf16le").toString("base64");
+    const script = [
+        "$p=[Text.Encoding]::Unicode.GetString([Convert]::FromBase64String($args[0]));",
+        "$me=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value;",
+        "$safe=@($me,'S-1-5-18','S-1-5-32-544');",
+        "$rules=(Get-Acl -LiteralPath $p).Access;",
+        "$unsafe=$rules|Where-Object { $_.AccessControlType -eq 'Allow' -and $safe -notcontains $_.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value };",
+        "if($unsafe){'false'}else{'true'}",
+    ].join("");
+    const result = await runner("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script, encodedPath]);
+    if (result.exitCode !== 0)
+        throw new Error(`Profile ACL inspection failed: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+    if (result.stdout.trim() === "true")
+        return true;
+    if (result.stdout.trim() === "false")
+        return false;
+    throw new Error("Profile ACL inspection returned an invalid result");
+}
+export async function readServiceDescriptor(spec) {
+    if (spec.descriptorPath === null)
+        return null;
+    try {
+        return await readFile(spec.descriptorPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}

package/dist/config.js

@@ -47,8 +47,9 @@ function defaultCliPath() {
         return resolve(here, "../../cli/dist/main.js");
     }
 }
+export const DEFAULT_SERVER_URL = "http://127.0.0.1:3001";
 export function loadConfig(env = process.env) {
-    const serverUrl = (env.CREW_SERVER_URL ?? "http://127.0.0.1:3000").replace(/\/+$/, "");
+    const serverUrl = (env.CREW_SERVER_URL ?? DEFAULT_SERVER_URL).replace(/\/+$/, "");
     const machineToken = env.CREW_MACHINE_TOKEN ?? "";
     if (!machineToken) {
         const lang = detectDaemonLang(env);

package/dist/console.js

@@ -58,6 +58,16 @@ export function toConsoleLines(event) {
     const e = (event ?? {});
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
+    if (e.type === "kimi.acp.text_delta" && e.text) {
+        return [{ stream: "text", text: e.text }];
+    }
+    if (e.type === "kimi.acp.tool_call") {
+        return [{ stream: "tool", text: e.title ? `⏺ ${e.title}` : "⏺ Kimi tool" }];
+    }
+    if (e.type === "kimi.acp.tool_result") {
+        const text = typeof e.content === "string" ? e.content.trim() : "";
+        return text ? [{ stream: "tool_result", text: clip(text, TOOL_RESULT_CAP) }] : [];
+    }
     if (e.type === "system" && e.subtype === "init") {
         return [{ stream: "system", text: `● ${td("Claude session started")}` }];
     }

package/dist/execution-backend.js

@@ -0,0 +1,11 @@
+/** Durable execution needs ownership that survives daemon crashes, not only a best-effort kill. */
+export function executionBackendCapability(platform = process.platform) {
+    if (platform === "win32") {
+        return {
+            supported: false,
+            backend: "windows-job-object-unavailable",
+            reason: "protocol-v1 is disabled until a Windows Job Object backend owns every runtime process",
+        };
+    }
+    return { supported: true, backend: "posix-process-group" };
+}

package/dist/execution-protocol.js

@@ -136,6 +136,13 @@ export const ExecutionCompletionAckSchema = z.object({
     protocolVersion: ProtocolVersionSchema,
     executionId: ExecutionIdSchema,
 }).strict();
+export const ExecutionEventAckSchema = z.object({
+    type: z.literal("execution:event-ack"),
+    protocolVersion: ProtocolVersionSchema,
+    executionId: ExecutionIdSchema,
+    kind: z.enum(["activity", "console"]),
+    seq: SequenceSchema,
+}).strict();
 export const ExecutionAcceptedSchema = z.object({
     type: z.literal("execution:accepted"),
     protocolVersion: ProtocolVersionSchema,
@@ -294,6 +301,7 @@ export const ServerToDaemonExecutionFrameSchema = z.discriminatedUnion("type", [
     ExecutionCancelSchema,
     ExecutionSyncSchema,
     ExecutionCompletionAckSchema,
+    ExecutionEventAckSchema,
 ]);
 const RawDaemonToServerExecutionFrameSchema = z.discriminatedUnion("type", [
     ExecutionAcceptedSchema,

package/dist/execution-runner.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+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";
@@ -7,7 +8,8 @@ import { executeLocal, withLocalExecutionFacts, } from "./local-executor.js";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
 import { buildClaudeArgs, CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
 import { buildCodexArgs, CODEX_EFFORT_LEVELS } from "./runtimes/codex.js";
-import { buildKimiArgs, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
+import { executionBackendCapability } from "./execution-backend.js";
 const ACTIVITY_KIND = {
     init: "working",
     text: "thinking",
@@ -38,7 +40,7 @@ async function reportBestEffort(report, frame, timeoutMs) {
     let timeout;
     try {
         return await Promise.race([
-            Promise.resolve(report(frame)).then(() => true, () => true),
+            Promise.resolve(report(frame)).then(() => true, () => false),
             new Promise((resolve) => {
                 timeout = setTimeout(() => resolve(false), timeoutMs);
             }),
@@ -214,15 +216,19 @@ function supervisorLaunch(request) {
             stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
         };
     }
+    if (request.effectivePermission !== "full_access") {
+        throw new Error(`Kimi ACP cannot enforce ${request.effectivePermission} permission`);
+    }
     return {
-        command: request.bin,
-        args: buildKimiArgs({
-            wakePrompt: `${request.systemPrompt}\n\n${request.wakePrompt}`,
-            effectivePermission: request.effectivePermission,
-            ...(request.model === undefined ? {} : { model: request.model }),
-        }),
+        command: process.execPath,
+        args: [
+            fileURLToPath(new URL("./runtimes/kimi-acp-runner.js", import.meta.url)),
+            "--bin", request.bin,
+            ...(request.model === undefined ? [] : ["--model", request.model]),
+        ],
         cwd: request.cwd,
         env: request.env,
+        stdinText: `${request.systemPrompt}\n\n${request.wakePrompt}`,
     };
 }
 function rejection(executionId, reason, message, at) {
@@ -236,8 +242,9 @@ function rejection(executionId, reason, message, at) {
     });
 }
 function admission(spec, config, dependencies, at) {
-    if (dependencies.platform === "win32" || (dependencies.platform === undefined && process.platform === "win32")) {
-        return { rejected: rejection(spec.executionId, "capability_missing", "Execution supervisor is unavailable on Windows", at) };
+    const backend = executionBackendCapability(dependencies.platform ?? process.platform);
+    if (!backend.supported) {
+        return { rejected: rejection(spec.executionId, "capability_missing", backend.reason, at) };
     }
     const promptBytes = Buffer.byteLength(spec.instructions.systemPrompt, "utf8")
         + Buffer.byteLength(spec.instructions.wakePrompt, "utf8");

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);