@nowcrew/daemon 0.5.14 → 0.5.16

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

@@ -55,6 +55,7 @@ export const LegacyAgentStartSchema = z.object({
         runId: z.string().min(1),
         title: z.string().optional(),
         outputPolicy: z.unknown().optional(),
+        externalNotificationPolicy: z.unknown().optional(),
     }).passthrough().optional(),
     silent: z.boolean().optional(),
 }).passthrough();
@@ -119,6 +120,7 @@ export const ExecutionStartSchema = z.object({
         captureFinal: z.boolean(),
         streamActivity: z.boolean(),
         streamConsole: z.boolean(),
+        allowBoundImDecision: z.boolean().optional(),
     }).strict(),
 }).strict();
 export const ExecutionCancelSchema = z.object({
@@ -136,6 +138,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,
@@ -196,6 +205,7 @@ const RawExecutionCompletedSchema = z.object({
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),
+    boundImDecision: z.enum(["notify", "silent"]).optional(),
     usage: ExecutionUsageSchema.optional(),
     startedAt: TimestampSchema,
     finishedAt: TimestampSchema,
@@ -294,6 +304,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,6 @@
 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";
@@ -7,7 +9,9 @@ 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";
+import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 const ACTIVITY_KIND = {
     init: "working",
     text: "thinking",
@@ -38,7 +42,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 +218,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 +244,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");
@@ -404,6 +413,8 @@ export async function runExecution(config, input, dependencies) {
     const mint = dependencies.mintAgentToken ?? mintAgentToken;
     const execute = dependencies.executeLocal ?? executeLocal;
     const startSupervisor = dependencies.startSupervisor ?? startDormantSupervisor;
+    const readBoundImDecision = dependencies.readBoundImDecision ?? readBoundImDecisionFile;
+    const resetBoundImDecision = dependencies.resetBoundImDecision ?? resetBoundImDecisionFile;
     const telemetry = new TelemetryQueue(dependencies.report, bestEffortTimeoutMs, positiveTelemetryLimit(dependencies.telemetryMaxPendingFrames, DEFAULT_TELEMETRY_MAX_PENDING_FRAMES), Math.max(config.executionLimits.maxEventBytes, positiveTelemetryLimit(dependencies.telemetryMaxPendingBytes, DEFAULT_TELEMETRY_MAX_PENDING_BYTES)));
     const supervisorState = { active: null, abortOnce: null };
     let launchClosed = false;
@@ -416,6 +427,9 @@ export async function runExecution(config, input, dependencies) {
     let timeout;
     let timedOut = false;
     let completion;
+    let boundImDecision = spec.reporting.allowBoundImDecision
+        ? "silent"
+        : undefined;
     let rejectCancellationFailure;
     const cancellationFailure = new Promise((_resolve, reject) => {
         rejectCancellationFailure = reject;
@@ -424,7 +438,7 @@ export async function runExecution(config, input, dependencies) {
         if (dependencies.slot !== undefined) {
             await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
-        const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId }), dependencies.cancellation);
+        const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId, agentRunId: spec.executionId }), dependencies.cancellation);
         const providerConfig = launchProviderConfig(credential.config);
         let activitySequence = 0;
         let consoleSequence = 0;
@@ -547,6 +561,11 @@ export async function runExecution(config, input, dependencies) {
                 cliPath: config.cliPath,
                 providerConfig,
                 ...(providerConfig.description ? { description: providerConfig.description } : {}),
+                ...(spec.reporting.allowBoundImDecision ? {
+                    systemEnv: {
+                        CREW_BOUND_IM_DECISION_FILE: `.bound-im-decision-${spec.executionId}.json`,
+                    },
+                } : {}),
             },
             session: {
                 enabled: config.resume,
@@ -563,6 +582,12 @@ export async function runExecution(config, input, dependencies) {
         if (timeout !== undefined)
             clearTimeout(timeout);
         const finishedAt = now().toISOString();
+        if (spec.reporting.allowBoundImDecision) {
+            const path = join(result.workspaceRunDir, `.bound-im-decision-${spec.executionId}.json`);
+            const selected = await readBoundImDecision(path);
+            await resetBoundImDecision(path);
+            boundImDecision = selected?.decision ?? "silent";
+        }
         completion = ExecutionCompletedSchema.parse(timedOut ? {
             type: "execution:completed",
             protocolVersion: 1,
@@ -573,6 +598,7 @@ export async function runExecution(config, input, dependencies) {
             runtime: result.runtime,
             ...(result.model === null ? {} : { model: result.model }),
             resumed: result.resumed,
+            ...(boundImDecision ? { boundImDecision } : {}),
             startedAt,
             finishedAt,
         } : {
@@ -589,6 +615,7 @@ export async function runExecution(config, input, dependencies) {
             runtime: result.runtime,
             ...(result.model === null ? {} : { model: result.model }),
             resumed: result.resumed,
+            ...(boundImDecision ? { boundImDecision } : {}),
             ...(!spec.reporting.captureFinal || result.finalText === null
                 ? {}
                 : { finalText: result.finalText }),