@aiden-ade/sandbox-agent 0.1.59 → 0.1.60

package/dist/__tests__/daemon.test.js

@@ -0,0 +1,3975 @@
+import { EventEmitter } from "node:events";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ALAN_DEFAULT_WORKSPACE_URI } from "@alan-ai/shared/constants";
+import { OPENCODE_ZEN_MODELS } from "@alan-ai/shared/frontend";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+const mocks = vi.hoisted(() => ({
+    spawnSync: vi.fn(),
+    io: vi.fn(),
+    coreAgentConstructor: vi.fn(),
+    agentRun: vi.fn(),
+    agentKill: vi.fn(),
+    sendToolResponse: vi.fn(),
+    collectLocalAgentProviderLimits: vi.fn(),
+    ensureAlanMcpRegistered: vi.fn(),
+    verifyAlanMcpRegistered: vi.fn(),
+    runRuntimeModelScan: vi.fn(),
+    discoverRelocatedWorkspace: vi.fn(),
+    workspaceMatchesExpectedRepositories: vi.fn(),
+    captureWorkspaceRunLease: vi.fn(),
+    workspaceLeaseVerify: vi.fn(),
+    defaultWorkspacePath: "",
+    leaseReleaseMutationHook: null,
+}));
+const readinessContract = {
+    requiredTools: ["create_plan", "create_document_artifact"],
+    contractVersion: 1,
+};
+vi.mock("node:fs", async () => {
+    const actual = await vi.importActual("node:fs");
+    return {
+        ...actual,
+        renameSync: (oldPath, newPath) => {
+            if (typeof oldPath === "string" && mocks.leaseReleaseMutationHook) {
+                const hook = mocks.leaseReleaseMutationHook;
+                mocks.leaseReleaseMutationHook = null;
+                hook(oldPath);
+            }
+            return actual.renameSync(oldPath, newPath);
+        },
+        rmSync: (path, options) => {
+            if (typeof path === "string" && mocks.leaseReleaseMutationHook) {
+                const hook = mocks.leaseReleaseMutationHook;
+                mocks.leaseReleaseMutationHook = null;
+                hook(path);
+            }
+            return actual.rmSync(path, options);
+        },
+    };
+});
+vi.mock("node:child_process", async () => {
+    const actual = await vi.importActual("node:child_process");
+    return {
+        ...actual,
+        spawnSync: mocks.spawnSync,
+    };
+});
+vi.mock("socket.io-client", () => ({
+    io: mocks.io,
+}));
+vi.mock("../core-agent.js", () => ({
+    CoreAgent: mocks.coreAgentConstructor,
+}));
+vi.mock("../mcp-registration.js", () => ({
+    ensureAlanMcpRegistered: mocks.ensureAlanMcpRegistered,
+    verifyAlanMcpRegistered: mocks.verifyAlanMcpRegistered,
+}));
+vi.mock("../model-scan-runner.js", () => ({
+    runRuntimeModelScan: mocks.runRuntimeModelScan,
+}));
+vi.mock("../workspace-relocation.js", () => ({
+    discoverRelocatedWorkspace: mocks.discoverRelocatedWorkspace,
+    workspaceMatchesExpectedRepositories: mocks.workspaceMatchesExpectedRepositories,
+}));
+vi.mock("../workspace-run-lease.js", async (importOriginal) => {
+    // Keep the real pure lease-monitor helpers (applyLeaseCheckResult,
+    // isLeaseCheckDue, FRESH_LEASE_MONITOR_STATE) while stubbing the interval and
+    // the capture factory the daemon tests drive.
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        WORKSPACE_LEASE_CHECK_INTERVAL_MS: 10,
+        WorkspaceRunLease: { capture: mocks.captureWorkspaceRunLease },
+    };
+});
+vi.mock("@alan-ai/shared/node/provider-limits", () => ({
+    collectLocalAgentProviderLimits: mocks.collectLocalAgentProviderLimits,
+}));
+vi.mock("@alan-ai/shared/node/local-workspace", () => ({
+    resolveAlanDefaultWorkspacePath: () => mocks.defaultWorkspacePath,
+}));
+function seedCliBinaries(baseDir) {
+    const binDir = join(baseDir, "bin");
+    mkdirSync(binDir, { recursive: true });
+    for (const name of ["codex", "claude", "agy", "git"]) {
+        const path = join(binDir, name);
+        writeFileSync(path, "#!/bin/sh\n");
+        chmodSync(path, 0o755);
+    }
+    return binDir;
+}
+class TestSocket extends EventEmitter {
+    connected = true;
+    auth = {};
+    connectCalls = 0;
+    outbound = [];
+    disconnected = false;
+    acknowledgeWorkspaceRelocations = true;
+    emit(event, ...args) {
+        const rawPayload = args[0];
+        // Most daemon tests exercise unrelated runtime behavior. Model the current
+        // API contract by attaching valid per-run MCP metadata unless a test
+        // explicitly supplies alanMcp (including null for the rejection case).
+        const payload = event === "agent.execute" &&
+            rawPayload &&
+            typeof rawPayload === "object" &&
+            !("alanMcp" in rawPayload)
+            ? {
+                ...rawPayload,
+                alanMcp: {
+                    url: "https://api.alan.test/mcp",
+                    headers: { "x-alan-run-reference": "test-run-reference" },
+                    ...readinessContract,
+                },
+            }
+            : rawPayload;
+        const normalizedArgs = [payload, ...args.slice(1)];
+        this.outbound.push({ event, payload });
+        const emitted = super.emit(event, ...normalizedArgs);
+        const acknowledge = normalizedArgs[1];
+        if (event === "agent.event" && typeof acknowledge === "function") {
+            queueMicrotask(() => acknowledge({ ok: true }));
+        }
+        else if (event === "runtime.workspace.relocated" &&
+            this.acknowledgeWorkspaceRelocations &&
+            typeof acknowledge === "function") {
+            queueMicrotask(() => acknowledge({
+                ok: true,
+                persisted: true,
+            }));
+        }
+        return emitted;
+    }
+    disconnect() {
+        this.disconnected = true;
+    }
+    connect() {
+        this.connectCalls += 1;
+    }
+}
+async function waitForOutbound(socket, event) {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const item = socket.outbound.find((entry) => entry.event === event);
+        if (item) {
+            return item;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    throw new Error(`Timed out waiting for outbound event ${event}`);
+}
+describe("alan-agent daemon CLI helpers", () => {
+    let tempDir;
+    let configPath;
+    beforeEach(() => {
+        vi.resetModules();
+        vi.unstubAllGlobals();
+        vi.clearAllMocks();
+        mocks.leaseReleaseMutationHook = null;
+        tempDir = mkdtempSync(join(tmpdir(), "alan-agent-test-"));
+        mocks.defaultWorkspacePath = join(tempDir, ".alan", "workspace");
+        configPath = join(tempDir, "config.json");
+        process.env.ALAN_AGENT_CONFIG_PATH = configPath;
+        process.env.ALAN_MCP_READINESS_MODE = "off";
+        mocks.collectLocalAgentProviderLimits.mockResolvedValue({});
+        mocks.runRuntimeModelScan.mockResolvedValue(undefined);
+        mocks.discoverRelocatedWorkspace.mockReturnValue(null);
+        mocks.workspaceMatchesExpectedRepositories.mockReturnValue(true);
+        mocks.workspaceLeaseVerify.mockReturnValue(null);
+        mocks.captureWorkspaceRunLease.mockReturnValue({
+            lease: {
+                verify: mocks.workspaceLeaseVerify,
+                // The monitor now uses verifyDetailed(); derive it from the same verify
+                // mock. Failures here are treated as definitive (transient: false) so the
+                // existing lease-change tests still fail the run on the first observation.
+                verifyDetailed: () => ({ failure: mocks.workspaceLeaseVerify(), transient: false }),
+            },
+            failure: null,
+        });
+        mocks.agentRun.mockResolvedValue(undefined);
+        mocks.sendToolResponse.mockReturnValue(true);
+        mocks.ensureAlanMcpRegistered.mockResolvedValue({ ok: true, paths: [] });
+        mocks.verifyAlanMcpRegistered.mockResolvedValue({ ok: true, missing: [] });
+        mocks.coreAgentConstructor.mockImplementation(function MockCoreAgent(_presenter, runtime) {
+            return {
+                run: (...args) => {
+                    runtime?.onProviderSpawned?.(process.pid);
+                    return mocks.agentRun(...args);
+                },
+                kill: mocks.agentKill,
+                sendToolResponse: mocks.sendToolResponse,
+            };
+        });
+    });
+    afterEach(() => {
+        delete process.env.ALAN_AGENT_CONFIG_PATH;
+        delete process.env.ALAN_API_URL;
+        delete process.env.ALAN_WS_URL;
+        delete process.env.ALAN_AGENT_PROFILE;
+        delete process.env.ALAN_AGENT_ENDPOINTS_PATH;
+        delete process.env.ALAN_TEAM_ID;
+        delete process.env.ALAN_SETUP_TOKEN;
+        delete process.env.ALAN_CODEX_PATH;
+        delete process.env.ALAN_CLAUDE_PATH;
+        delete process.env.ALAN_ANTIGRAVITY_PATH;
+        delete process.env.ALAN_OPENCODE_PATH;
+        delete process.env.ALAN_MCP_READINESS_MODE;
+        rmSync(tempDir, { recursive: true, force: true });
+        vi.unstubAllGlobals();
+        vi.unstubAllEnvs();
+    });
+    it("discovers sanitized local capabilities without exposing binary paths", async () => {
+        const binDir = seedCliBinaries(tempDir);
+        process.env.PATH = binDir;
+        vi.stubEnv("SHELL", join(tempDir, "missing-shell"));
+        const { discoverCapabilities } = await import("../daemon.js");
+        const capabilities = discoverCapabilities();
+        expect(capabilities.hasGit).toBe(true);
+        expect(capabilities.hasTerminal).toBe(true);
+        expect(capabilities.supportsFilesystem).toBe(true);
+        expect(capabilities.agents).toHaveLength(10);
+        expect(capabilities.agents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                provider: "codex_app_server",
+                available: true,
+                models: [],
+            }),
+            expect.objectContaining({
+                provider: "claude_cli",
+                available: true,
+            }),
+        ]));
+        expect(capabilities.agents.every((agent) => agent.version === undefined)).toBe(true);
+        expect(JSON.stringify(capabilities)).not.toContain("/Users/");
+    });
+    it("maps a selected Project subfolder into the repository worktree", async () => {
+        const { resolveProjectWorktreePaths } = await import("../daemon.js");
+        const repoPath = join(tempDir, "repo");
+        const projectPath = join(repoPath, "apps", "web");
+        const worktreePath = join(tempDir, "repo-alan-worktrees", "task");
+        expect(resolveProjectWorktreePaths(projectPath, repoPath, worktreePath)).toEqual({
+            repoPath,
+            projectPath: join(worktreePath, "apps", "web"),
+        });
+        expect(resolveProjectWorktreePaths(repoPath, repoPath, worktreePath)).toEqual({
+            repoPath,
+            projectPath: worktreePath,
+        });
+        expect(() => resolveProjectWorktreePaths(join(tempDir, "another-repo"), repoPath, worktreePath)).toThrow("outside its Git repository");
+    });
+    it("refreshProviderVersions populates cached versions without discoverCapabilities blocking on spawnSync", async () => {
+        const binDir = join(tempDir, "bin");
+        mkdirSync(binDir, { recursive: true });
+        const codexPath = join(binDir, "codex");
+        writeFileSync(codexPath, "#!/bin/sh\necho 'codex-cli 9.9.9'\n");
+        chmodSync(codexPath, 0o755);
+        process.env.PATH = binDir;
+        process.env.ALAN_CODEX_PATH = codexPath;
+        vi.stubEnv("SHELL", join(tempDir, "missing-shell"));
+        const { discoverCapabilities, refreshProviderVersions } = await import("../daemon.js");
+        const before = discoverCapabilities();
+        expect(before.agents.find((agent) => agent.provider === "codex_app_server")?.version).toBe(undefined);
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+        await refreshProviderVersions();
+        const after = discoverCapabilities();
+        expect(after.agents.find((agent) => agent.provider === "codex_app_server")?.version).toBe("codex-cli 9.9.9");
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+    });
+    it("refreshProviderModels discovers OpenCode models without blocking discoverCapabilities", async () => {
+        const binDir = seedCliBinaries(tempDir);
+        const opencodePath = join(binDir, "opencode");
+        writeFileSync(opencodePath, [
+            "#!/bin/sh",
+            'if [ "$1 $2" = "models --json" ]; then',
+            '  printf \'%s\\n\' \'{"models":[{"id":"opencode/custom-free"}]}\'',
+            "  exit 0",
+            "fi",
+            "exit 1",
+            "",
+        ].join("\n"));
+        chmodSync(opencodePath, 0o755);
+        process.env.ALAN_OPENCODE_PATH = opencodePath;
+        process.env.PATH = binDir;
+        const { discoverCapabilities, refreshProviderModels } = await import("../daemon.js");
+        const before = discoverCapabilities();
+        expect(before.agents.find((agent) => agent.provider === "opencode_cli")?.models).toEqual([]);
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+        await refreshProviderModels(["opencode_cli"]);
+        const capabilities = discoverCapabilities();
+        expect(capabilities.agents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                provider: "opencode_cli",
+                available: true,
+                models: ["opencode/custom-free"],
+            }),
+        ]));
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+    });
+    it("refreshProviderModels discovers Antigravity models without blocking discoverCapabilities", async () => {
+        const binDir = seedCliBinaries(tempDir);
+        const agyPath = join(binDir, "agy");
+        writeFileSync(agyPath, [
+            "#!/bin/sh",
+            'if [ "$1 $2" = "models --json" ]; then',
+            "  printf '%s\\n' 'json not supported' >&2",
+            "  exit 1",
+            "fi",
+            'if [ "$1" = "models" ]; then',
+            "  printf '%s\\n' 'Antigravity 3.5 Flash (High)' 'Claude Sonnet 4.6 (Thinking)'",
+            "  exit 0",
+            "fi",
+            "exit 1",
+            "",
+        ].join("\n"));
+        chmodSync(agyPath, 0o755);
+        process.env.ALAN_ANTIGRAVITY_PATH = agyPath;
+        process.env.PATH = binDir;
+        const { discoverCapabilities, refreshProviderModels } = await import("../daemon.js");
+        const before = discoverCapabilities();
+        expect(before.agents.find((agent) => agent.provider === "antigravity_cli")?.models).toEqual([]);
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+        await refreshProviderModels(["antigravity_cli"]);
+        const capabilities = discoverCapabilities();
+        expect(capabilities.agents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                provider: "antigravity_cli",
+                available: true,
+                models: ["Antigravity 3.5 Flash (High)", "Claude Sonnet 4.6 (Thinking)"],
+            }),
+        ]));
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+    });
+    it("falls back to known free OpenCode models when model discovery fails", async () => {
+        const binDir = seedCliBinaries(tempDir);
+        const opencodePath = join(binDir, "opencode");
+        writeFileSync(opencodePath, "#!/bin/sh\nexit 1\n");
+        chmodSync(opencodePath, 0o755);
+        process.env.ALAN_OPENCODE_PATH = opencodePath;
+        process.env.PATH = binDir;
+        const { discoverCapabilities, refreshProviderModels } = await import("../daemon.js");
+        await refreshProviderModels(["opencode_cli"]);
+        const capabilities = discoverCapabilities();
+        expect(capabilities.agents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                provider: "opencode_cli",
+                available: true,
+                models: OPENCODE_ZEN_MODELS.map((model) => model.id),
+            }),
+        ]));
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+    });
+    it("refreshProviderModels probes codex models from CLI without spawnSync", async () => {
+        const binDir = seedCliBinaries(tempDir);
+        const codexPath = join(binDir, "codex");
+        writeFileSync(codexPath, [
+            "#!/bin/sh",
+            'if [ "$1" = "debug" ] && [ "$2" = "models" ]; then',
+            '  printf \'%s\' \'{"models":[{"slug":"gpt-5.5","visibility":"list"},{"slug":"gpt-5.3-codex-spark","visibility":"list"}]}\'',
+            "  exit 0",
+            "fi",
+            "exit 1",
+            "",
+        ].join("\n"));
+        chmodSync(codexPath, 0o755);
+        process.env.ALAN_CODEX_PATH = codexPath;
+        process.env.PATH = binDir;
+        const { discoverCapabilities, refreshProviderModels } = await import("../daemon.js");
+        await refreshProviderModels(["codex_app_server"]);
+        const capabilities = discoverCapabilities();
+        expect(capabilities.agents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                provider: "codex_app_server",
+                available: true,
+                models: ["gpt-5.5", "gpt-5.3-codex-spark"],
+            }),
+        ]));
+        expect(mocks.spawnSync).not.toHaveBeenCalled();
+    });
+    it("scanAgentCapabilities refreshes versions and models before returning capabilities", async () => {
+        const binDir = join(tempDir, "bin");
+        mkdirSync(binDir, { recursive: true });
+        const codexPath = join(binDir, "codex");
+        writeFileSync(codexPath, `#!/bin/sh
+if [ "$1" = "--version" ]; then echo 'codex-cli 9.9.9'; exit 0; fi
+if [ "$1" = "debug" ] && [ "$2" = "models" ]; then
+  echo '{"models":[{"slug":"gpt-5.5","visibility":"list"}]}'
+  exit 0
+fi
+exit 1
+`);
+        chmodSync(codexPath, 0o755);
+        process.env.ALAN_CODEX_PATH = codexPath;
+        process.env.PATH = binDir;
+        const { scanAgentCapabilities } = await import("../daemon.js");
+        const capabilities = await scanAgentCapabilities(["codex_app_server"]);
+        expect(capabilities.agents).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                provider: "codex_app_server",
+                available: true,
+                models: expect.arrayContaining(["gpt-5.5"]),
+            }),
+        ]));
+    });
+    it("setup registers a daemon runtime and persists only runtime config locally", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "CI Runtime",
+                },
+                runtimeToken: "alan_runtime_secret",
+                runtimeRenewalToken: "alan_runtime_renew_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon([
+            "--api-url",
+            "http://api.test",
+            "--ws-url",
+            "ws://ws.test",
+            "--token",
+            "alan_pat_secret",
+            "--name",
+            "CI Runtime",
+        ]);
+        expect(fetchMock).toHaveBeenCalledWith("http://api.test/public/runtimes", expect.objectContaining({
+            method: "POST",
+            headers: expect.objectContaining({
+                authorization: "Bearer alan_pat_secret",
+            }),
+        }));
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toMatchObject({
+            displayName: "CI Runtime",
+            runtimeKind: "machine",
+            hostKind: "daemon",
+            lifecycle: "durable",
+        });
+        expect(body).not.toHaveProperty("ownerType");
+        expect(body).not.toHaveProperty("visibility");
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved).toEqual({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            endpointProfile: "custom",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            runtimeRenewalToken: "alan_runtime_renew_secret",
+            localApiPort: 47831,
+            localApiToken: expect.any(String),
+            localServiceId: expect.any(String),
+            localServiceSecret: expect.any(String),
+            eventSpoolKey: expect.any(String),
+            installationId: expect.any(String),
+            displayName: "CI Runtime",
+        });
+        expect(readFileSync(configPath, "utf8")).not.toContain("alan_pat_secret");
+    });
+    it("retries transient setup registration failures with one stable attempt id", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: false,
+            status: 503,
+            text: async () => "temporarily unavailable",
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Retry Runtime",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon([
+            "--api-url",
+            "http://api.test",
+            "--ws-url",
+            "ws://ws.test",
+            "--setup-token",
+            "alan_setup_secret",
+            "--name",
+            "Retry Runtime",
+        ]);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        const firstBody = JSON.parse(fetchMock.mock.calls[0][1].body);
+        const secondBody = JSON.parse(fetchMock.mock.calls[1][1].body);
+        expect(firstBody.registrationAttemptId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+        expect(secondBody.registrationAttemptId).toBe(firstBody.registrationAttemptId);
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+        });
+    });
+    it("resumes the same setup attempt after local config replacement fails", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const successfulRegistration = {
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Resumed Runtime",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce(successfulRegistration)
+            .mockResolvedValueOnce(successfulRegistration);
+        vi.stubGlobal("fetch", fetchMock);
+        mkdirSync(configPath);
+        const { setupDaemon } = await import("../daemon.js");
+        const setupArgs = [
+            "--api-url",
+            "http://api.test",
+            "--ws-url",
+            "ws://ws.test",
+            "--setup-token",
+            "alan_setup_secret",
+            "--name",
+            "Resumed Runtime",
+        ];
+        await expect(setupDaemon(setupArgs)).rejects.toThrow();
+        rmSync(configPath, { recursive: true, force: true });
+        await setupDaemon(setupArgs);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        const firstBody = JSON.parse(fetchMock.mock.calls[0][1].body);
+        const secondBody = JSON.parse(fetchMock.mock.calls[1][1].body);
+        expect(secondBody.registrationAttemptId).toBe(firstBody.registrationAttemptId);
+        expect(existsSync(`${configPath}.setup-pending`)).toBe(false);
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+        });
+    });
+    it("setup uses install-script endpoint defaults when endpoint flags are omitted", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const endpointsPath = join(tempDir, "endpoints.json");
+        process.env.ALAN_AGENT_ENDPOINTS_PATH = endpointsPath;
+        writeFileSync(endpointsPath, JSON.stringify({
+            apiUrl: "https://preview-api.tryalan.ai",
+            wsUrl: "wss://preview-ws.tryalan.ai",
+            endpointProfile: "custom",
+        }));
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Installed Runtime",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon(["--setup-token", "alan_setup_secret", "--name", "Installed Runtime"]);
+        expect(fetchMock).toHaveBeenCalledWith("https://preview-api.tryalan.ai/public/runtimes/register-with-setup-token", expect.objectContaining({ method: "POST" }));
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved).toMatchObject({
+            apiUrl: "https://preview-api.tryalan.ai",
+            wsUrl: "wss://preview-ws.tryalan.ai",
+            endpointProfile: "custom",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+        });
+    });
+    it("setup fails fast without team and setup token", async () => {
+        const { setupDaemon } = await import("../daemon.js");
+        await expect(setupDaemon(["--team", "22222222-2222-4222-8222-222222222222"])).rejects.toThrow("setup requires --setup-token <token>");
+    });
+    it("setup can register with a short-lived runtime setup token without storing a PAT", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Headless CI",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon([
+            "--api-url",
+            "http://api.test",
+            "--ws-url",
+            "ws://ws.test",
+            "--setup-token",
+            "alan_setup_secret",
+            "--name",
+            "Headless CI",
+        ]);
+        expect(fetchMock).toHaveBeenCalledWith("http://api.test/public/runtimes/register-with-setup-token", expect.objectContaining({
+            method: "POST",
+            headers: { "content-type": "application/json" },
+        }));
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toMatchObject({
+            setupToken: "alan_setup_secret",
+            displayName: "Headless CI",
+            runtimeKind: "machine",
+            hostKind: "daemon",
+        });
+        expect(body).not.toHaveProperty("ownerType");
+        expect(body).not.toHaveProperty("visibility");
+        expect(body).not.toHaveProperty("token");
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved.runtimeToken).toBe("alan_runtime_secret");
+        expect(readFileSync(configPath, "utf8")).not.toContain("alan_setup_secret");
+    });
+    it("keeps one installation identity across repeated setup", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Renamed Laptop",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon(["--setup-token", "alan_setup_first", "--name", "Original Laptop"]);
+        const firstSaved = JSON.parse(readFileSync(configPath, "utf8"));
+        await setupDaemon(["--setup-token", "alan_setup_second", "--name", "Renamed Laptop"]);
+        const firstBody = JSON.parse(fetchMock.mock.calls[0][1].body);
+        const secondBody = JSON.parse(fetchMock.mock.calls[1][1].body);
+        expect(firstBody.metadata.installationId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+        expect(secondBody.metadata.installationId).toBe(firstBody.metadata.installationId);
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved.installationId).toBe(firstBody.metadata.installationId);
+        expect(saved.localApiToken).toBe(firstSaved.localApiToken);
+        expect(saved.localServiceId).toBe(firstSaved.localServiceId);
+        expect(saved.localServiceSecret).toBe(firstSaved.localServiceSecret);
+    });
+    it("setup can register a personal runtime with a setup token", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Personal Laptop",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon([
+            "--api-url",
+            "http://api.test",
+            "--ws-url",
+            "ws://ws.test",
+            "--setup-token",
+            "alan_setup_secret",
+            "--scope",
+            "user",
+            "--name",
+            "Personal Laptop",
+        ]);
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toMatchObject({
+            setupToken: "alan_setup_secret",
+            displayName: "Personal Laptop",
+        });
+        expect(body).not.toHaveProperty("ownerType");
+        expect(body).not.toHaveProperty("visibility");
+    });
+    it("continues an expired setup link through browser authorization", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: false,
+            status: 401,
+            text: async () => JSON.stringify({ error: "setup_token_expired" }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_secret",
+                userCode: "ABCD1234",
+                verificationUri: "https://app.tryalan.ai/device",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                runtime: { id: "11111111-1111-4111-8111-111111111111", displayName: "Laptop" },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon(["--setup-token", "alan_setup_expired", "--name", "Laptop"]);
+        expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+            "https://api.tryalan.ai/public/runtimes/register-with-setup-token",
+            "https://api.tryalan.ai/public/runtimes/device-authorizations",
+            "https://api.tryalan.ai/public/runtimes/device-authorizations/token",
+        ]);
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+        });
+        expect(existsSync(`${configPath}.setup-pending`)).toBe(false);
+    });
+    it("setup uses production endpoints by default for installable package users", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Prod Runtime",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon(["--setup-token", "alan_setup_secret"]);
+        expect(fetchMock).toHaveBeenCalledWith("https://api.tryalan.ai/public/runtimes/register-with-setup-token", expect.objectContaining({ method: "POST" }));
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved).toMatchObject({
+            apiUrl: "https://api.tryalan.ai",
+            wsUrl: "wss://ws.tryalan.ai",
+            endpointProfile: "production",
+        });
+    });
+    it("setup uses localhost only when explicitly requested with local profile", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Local Runtime",
+                },
+                runtimeToken: "alan_runtime_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { setupDaemon } = await import("../daemon.js");
+        await setupDaemon(["--profile", "local", "--setup-token", "alan_setup_secret"]);
+        expect(fetchMock).toHaveBeenCalledWith("http://localhost:8400/public/runtimes/register-with-setup-token", expect.objectContaining({ method: "POST" }));
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved).toMatchObject({
+            apiUrl: "http://localhost:8400",
+            wsUrl: "ws://localhost:8401",
+            endpointProfile: "local",
+        });
+    });
+    it("rejects startDaemon when an alan-agent daemon is already listening", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+        }));
+        const existing = createServer((req, res) => {
+            if (req.method === "GET" && req.url === "/status") {
+                res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
+                    configured: true,
+                    runtimeId: "11111111-1111-4111-8111-111111111111",
+                    wsUrl: "ws://ws.test",
+                    connected: true,
+                    activeRunIds: [],
+                    localApiPort: 47831,
+                    version: "test",
+                }));
+                return;
+            }
+            res.writeHead(404).end();
+        });
+        await new Promise((resolve) => existing.listen(0, "127.0.0.1", resolve));
+        const address = existing.address();
+        const port = typeof address === "object" && address ? address.port : 47831;
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const { startDaemon } = await import("../daemon.js");
+        await expect(startDaemon(["--local-api-port", String(port)])).rejects.toThrow("already in use");
+        expect(socket.disconnected).toBe(true);
+        await new Promise((resolve, reject) => {
+            existing.close((error) => (error ? reject(error) : resolve()));
+        });
+    });
+    it("runDaemon exits successfully when the local daemon is listening with a stale token", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "stale-token",
+        }));
+        const existing = createServer((req, res) => {
+            if (req.method === "GET" && req.url === "/status") {
+                res
+                    .writeHead(401, { "content-type": "application/json" })
+                    .end(JSON.stringify({ error: "Unauthorized" }));
+                return;
+            }
+            res.writeHead(404).end();
+        });
+        await new Promise((resolve) => existing.listen(0, "127.0.0.1", resolve));
+        const address = existing.address();
+        const port = typeof address === "object" && address ? address.port : 47831;
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { runDaemon } = await import("../daemon.js");
+        await runDaemon(["--local-api-port", String(port)]);
+        expect(mocks.io).not.toHaveBeenCalled();
+        expect(info).toHaveBeenCalledWith("[alan-agent] Daemon already running", expect.objectContaining({ port }));
+        await new Promise((resolve, reject) => {
+            existing.close((error) => (error ? reject(error) : resolve()));
+        });
+    });
+    it("adopts an owned local daemon but rejects a mismatched owner secret", async () => {
+        const serviceSecret = "owner-secret-shared-only-through-the-config-file";
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "incumbent-local-token-that-is-long-enough",
+            localServiceId: "service-owner-1",
+            localServiceSecret: serviceSecret,
+            installationId: "22222222-2222-4222-8222-222222222222",
+        }));
+        mocks.io.mockReturnValue(new TestSocket());
+        const { adoptConfiguredLocalDaemon, startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        try {
+            const runningConfig = JSON.parse(readFileSync(configPath, "utf8"));
+            writeFileSync(configPath, JSON.stringify({
+                ...runningConfig,
+                localApiPort: controller.localApiPort,
+                localApiToken: "stale-local-token-that-is-long-enough",
+                localServiceSecret: "wrong-owner-secret",
+            }));
+            await expect(adoptConfiguredLocalDaemon([])).resolves.toBeNull();
+            expect(JSON.parse(readFileSync(configPath, "utf8")).localApiToken).toBe("stale-local-token-that-is-long-enough");
+            writeFileSync(configPath, JSON.stringify({
+                ...JSON.parse(readFileSync(configPath, "utf8")),
+                localServiceSecret: serviceSecret,
+            }));
+            const adopted = await adoptConfiguredLocalDaemon([]);
+            expect(adopted).toMatchObject({
+                runtimeId: "11111111-1111-4111-8111-111111111111",
+                localServiceId: "service-owner-1",
+            });
+            expect(JSON.parse(readFileSync(configPath, "utf8")).localApiToken).toBe(controller.localApiToken);
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("runDaemon exits successfully when the local daemon is already running", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+        }));
+        const existing = createServer((req, res) => {
+            if (req.method === "GET" && req.url === "/status") {
+                res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
+                    configured: true,
+                    runtimeId: "11111111-1111-4111-8111-111111111111",
+                    wsUrl: "ws://ws.test",
+                    connected: true,
+                    activeRunIds: [],
+                    localApiPort: 47831,
+                    version: "test",
+                }));
+                return;
+            }
+            res.writeHead(404).end();
+        });
+        await new Promise((resolve) => existing.listen(0, "127.0.0.1", resolve));
+        const address = existing.address();
+        const port = typeof address === "object" && address ? address.port : 47831;
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { runDaemon } = await import("../daemon.js");
+        await runDaemon(["--local-api-port", String(port)]);
+        expect(mocks.io).not.toHaveBeenCalled();
+        expect(info).toHaveBeenCalledWith("[alan-agent] Daemon already running", expect.objectContaining({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+        }));
+        await new Promise((resolve, reject) => {
+            existing.close((error) => (error ? reject(error) : resolve()));
+        });
+    });
+    it("shared recovery redials before a run-safe restart and returns typed exhaustion", async () => {
+        const { runLocalDaemonRecoveryLadder } = await import("../daemon.js");
+        const restart = vi.fn().mockResolvedValue({ connected: true, activeRunCount: 0 });
+        const recovered = await runLocalDaemonRecoveryLadder({
+            initialStatus: { connected: false, activeRunCount: 0 },
+            getStatus: async () => ({ connected: false, activeRunCount: 0 }),
+            redial: async () => true,
+            restart,
+            blockingRunCount: (status) => status.activeRunCount ?? 0,
+            options: { connectTimeoutMs: 0, pollMs: 1 },
+        });
+        expect(restart).toHaveBeenCalledTimes(1);
+        expect(recovered).toMatchObject({ connected: true });
+        const busyRestart = vi.fn();
+        const busy = await runLocalDaemonRecoveryLadder({
+            initialStatus: { connected: false, activeRunCount: 2 },
+            getStatus: async () => ({ connected: false, activeRunCount: 2 }),
+            redial: async () => false,
+            restart: busyRestart,
+            blockingRunCount: (status) => status.activeRunCount ?? 0,
+            options: { connectTimeoutMs: 0, pollMs: 1 },
+        });
+        expect(busyRestart).not.toHaveBeenCalled();
+        expect(busy).toMatchObject({ recoveryCode: "needs_restart_busy", activeRunCount: 2 });
+        const restartRace = await runLocalDaemonRecoveryLadder({
+            initialStatus: { connected: false, activeRunCount: 0 },
+            getStatus: async () => ({ connected: false, activeRunCount: 1 }),
+            redial: async () => false,
+            restart: async () => ({ connected: false, activeRunCount: 1 }),
+            blockingRunCount: (status) => status.activeRunCount ?? 0,
+            options: { connectTimeoutMs: 0, pollMs: 1 },
+        });
+        expect(restartRace).toMatchObject({
+            recoveryCode: "needs_restart_busy",
+            activeRunCount: 1,
+        });
+        const exhausted = await runLocalDaemonRecoveryLadder({
+            initialStatus: { connected: false, activeRunCount: 0 },
+            getStatus: async () => ({ connected: false, activeRunCount: 0 }),
+            redial: async () => false,
+            restart: async () => ({ connected: false, activeRunCount: 0 }),
+            blockingRunCount: (status) => status.activeRunCount ?? 0,
+            options: { connectTimeoutMs: 0, pollMs: 1 },
+        });
+        expect(exhausted).toMatchObject({
+            connected: false,
+            recoveryCode: "daemon_recovery_failed",
+            error: expect.stringContaining("exhausted"),
+        });
+    });
+    it("maintenance leases expire safely and journal inspection includes pending starts", async () => {
+        const { acquireLocalDaemonMaintenanceLease, inspectLocalDaemonRunJournal, readLocalDaemonMaintenanceLease, releaseLocalDaemonMaintenanceLease, } = await import("../daemon.js");
+        const acquired = acquireLocalDaemonMaintenanceLease(configPath, "watchdog", 1_000);
+        expect(acquired.acquired).toBe(true);
+        expect(acquireLocalDaemonMaintenanceLease(configPath, "watchdog", 1_000).acquired).toBe(false);
+        releaseLocalDaemonMaintenanceLease(configPath, "wrong-id");
+        expect(readLocalDaemonMaintenanceLease(configPath)).not.toBeNull();
+        expect(readLocalDaemonMaintenanceLease(configPath, (acquired.lease.expiresAtMs ?? Date.now()) + 1)).toBeNull();
+        writeFileSync(`${configPath}.pending-runs.json`, JSON.stringify({ version: 1, entries: [{ runId: "pending", conversationId: "c" }] }));
+        expect(inspectLocalDaemonRunJournal(configPath)).toEqual({
+            safeToRestart: false,
+            activeRunCount: 1,
+        });
+    });
+    it("does not count a recovered interrupted run as active watchdog work", async () => {
+        const { inspectLocalDaemonRunJournal } = await import("../daemon.js");
+        const { RuntimeRunJournal } = await import("../run-journal.js");
+        const journalPath = `${configPath}.run-journal.json`;
+        writeFileSync(journalPath, JSON.stringify({
+            version: 1,
+            entries: [
+                {
+                    runId: "interrupted-run",
+                    conversationId: "interrupted-conversation",
+                    acceptedAtMs: Date.now() - 1_000,
+                },
+            ],
+        }));
+        const recovered = new RuntimeRunJournal(journalPath);
+        recovered.confirmRecoveryOwnership();
+        expect(recovered.recoveredRunIds()).toEqual(["interrupted-run"]);
+        expect(inspectLocalDaemonRunJournal(configPath)).toEqual({
+            safeToRestart: true,
+            activeRunCount: 0,
+        });
+    });
+    it("fails closed when an interrupted run entry is missing its durable identity", async () => {
+        const { inspectLocalDaemonRunJournal } = await import("../daemon.js");
+        writeFileSync(`${configPath}.run-journal.json`, JSON.stringify({
+            version: 1,
+            entries: [{ interruptedAtMs: Date.now() - 1_000 }],
+        }));
+        expect(inspectLocalDaemonRunJournal(configPath)).toEqual({
+            safeToRestart: false,
+            activeRunCount: 1,
+        });
+    });
+    it("clears pending starts inherited from a previous daemon session", async () => {
+        const pendingPath = `${configPath}.pending-runs.json`;
+        writeFileSync(pendingPath, JSON.stringify({
+            version: 1,
+            entries: [
+                {
+                    runId: "preflight-before-crash",
+                    conversationId: "conversation-before-crash",
+                    startedAtMs: Date.now(),
+                    daemonSessionId: "previous-daemon-session",
+                },
+            ],
+        }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const { inspectLocalDaemonRunJournal, startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            expect(existsSync(pendingPath)).toBe(false);
+            expect(inspectLocalDaemonRunJournal(configPath)).toEqual({
+                safeToRestart: true,
+                activeRunCount: 0,
+            });
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("does not let an expired pending start block watchdog recovery", async () => {
+        writeFileSync(`${configPath}.pending-runs.json`, JSON.stringify({
+            version: 1,
+            entries: [
+                {
+                    runId: "expired-preflight",
+                    conversationId: "expired-conversation",
+                    startedAtMs: Date.now() - 60 * 60_000,
+                    daemonSessionId: "stuck-daemon-session",
+                },
+            ],
+        }));
+        const { inspectLocalDaemonRunJournal } = await import("../daemon.js");
+        expect(inspectLocalDaemonRunJournal(configPath)).toEqual({
+            safeToRestart: true,
+            activeRunCount: 0,
+        });
+    });
+    it("does not delete a replacement maintenance lease while releasing an older owner", async () => {
+        const { acquireLocalDaemonMaintenanceLease, readLocalDaemonMaintenanceLease, releaseLocalDaemonMaintenanceLease, } = await import("../daemon.js");
+        const acquired = acquireLocalDaemonMaintenanceLease(configPath, "watchdog", 5_000);
+        const replacement = {
+            version: 1,
+            id: "replacement-owner",
+            reason: "credential_cleanup",
+            expiresAtMs: Date.now() + 60_000,
+        };
+        const leasePath = `${configPath}.maintenance-lease.json`;
+        mocks.leaseReleaseMutationHook = (mutationPath) => {
+            if (mutationPath !== leasePath)
+                return;
+            writeFileSync(leasePath, JSON.stringify(replacement), { mode: 0o600 });
+        };
+        releaseLocalDaemonMaintenanceLease(configPath, acquired.lease.id);
+        expect(readLocalDaemonMaintenanceLease(configPath)).toEqual(replacement);
+    });
+    it("does not delete a replacement lease while cleaning up an expired watchdog owner", async () => {
+        const { readLocalDaemonMaintenanceLease } = await import("../daemon.js");
+        const now = Date.now();
+        const expired = {
+            version: 1,
+            id: "expired-watchdog-owner",
+            reason: "watchdog",
+            expiresAtMs: now - 1,
+        };
+        const replacement = {
+            version: 1,
+            id: "replacement-cleanup-owner",
+            reason: "credential_cleanup",
+            expiresAtMs: null,
+        };
+        const leasePath = `${configPath}.maintenance-lease.json`;
+        writeFileSync(leasePath, JSON.stringify(expired), { mode: 0o600 });
+        mocks.leaseReleaseMutationHook = (mutationPath) => {
+            if (mutationPath !== leasePath)
+                return;
+            writeFileSync(leasePath, JSON.stringify(replacement), { mode: 0o600 });
+        };
+        expect(readLocalDaemonMaintenanceLease(configPath, now)).toBeNull();
+        expect(readLocalDaemonMaintenanceLease(configPath)).toEqual(replacement);
+    });
+    it("maintenance closes the pending-dispatch TOCTOU window before journal acceptance", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const { acquireLocalDaemonMaintenanceLease, inspectLocalDaemonRunJournal, startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "22222222-2222-4222-8222-222222222222",
+                runId: "33333333-3333-4333-8333-333333333333",
+                content: "Do not cross maintenance",
+            });
+            acquireLocalDaemonMaintenanceLease(configPath, "watchdog", 5_000);
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: expect.objectContaining({
+                        runId: "33333333-3333-4333-8333-333333333333",
+                        code: "runtime_maintenance_pending",
+                    }),
+                },
+            ])));
+            expect(mocks.agentRun).not.toHaveBeenCalled();
+            expect(inspectLocalDaemonRunJournal(configPath)).toEqual({
+                safeToRestart: true,
+                activeRunCount: 0,
+            });
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("CLI recovery restarts a stuck idle daemon only after redial verification fails", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret-that-is-long-enough-for-tests",
+        }));
+        const stuckSocket = new TestSocket();
+        stuckSocket.connected = false;
+        const replacementSocket = new TestSocket();
+        mocks.io.mockReturnValueOnce(stuckSocket).mockReturnValueOnce(replacementSocket);
+        vi.spyOn(console, "info").mockImplementation(() => { });
+        const { recoverDaemonConnection, startDaemon, stopDaemon } = await import("../daemon.js");
+        const original = await startDaemon(["--local-api-port", "0"]);
+        writeFileSync(configPath, JSON.stringify({
+            ...JSON.parse(readFileSync(configPath, "utf8")),
+            localApiPort: original.localApiPort,
+        }));
+        try {
+            const recovered = await recoverDaemonConnection([], {
+                connectTimeoutMs: 0,
+                pollMs: 1,
+            });
+            expect(stuckSocket.connectCalls).toBe(1);
+            expect(mocks.io).toHaveBeenCalledTimes(2);
+            expect(recovered).toMatchObject({ connected: true, running: true });
+        }
+        finally {
+            await stopDaemon([]);
+            await original.stop();
+        }
+    });
+    it("explains when the local daemon API port is already in use", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+        }));
+        const occupied = createServer();
+        await new Promise((resolve) => occupied.listen(0, "127.0.0.1", resolve));
+        const address = occupied.address();
+        const port = typeof address === "object" && address ? address.port : 47831;
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const { startDaemon } = await import("../daemon.js");
+        await expect(startDaemon(["--local-api-port", String(port)])).rejects.toThrow("already in use by another process");
+        expect(socket.disconnected).toBe(true);
+        expect(existsSync(`${configPath}.daemon-owner.json`)).toBe(false);
+        expect(existsSync(`${configPath}.maintenance-lease.json`)).toBe(false);
+        await new Promise((resolve, reject) => {
+            occupied.close((error) => (error ? reject(error) : resolve()));
+        });
+    });
+    it("does not interrupt a live run journal when a competing daemon loses local ownership", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+        }));
+        const runJournalPath = `${configPath}.run-journal.json`;
+        const liveJournal = {
+            version: 1,
+            entries: [
+                {
+                    runId: "live-run",
+                    conversationId: "live-conversation",
+                    acceptedAtMs: 1_000,
+                },
+            ],
+        };
+        writeFileSync(runJournalPath, JSON.stringify(liveJournal));
+        const occupied = createServer();
+        await new Promise((resolve) => occupied.listen(0, "127.0.0.1", resolve));
+        try {
+            const address = occupied.address();
+            const port = typeof address === "object" && address ? address.port : 47831;
+            mocks.io.mockReturnValue(new TestSocket());
+            const { startDaemon } = await import("../daemon.js");
+            await expect(startDaemon(["--local-api-port", String(port)])).rejects.toThrow("already in use by another process");
+            expect(JSON.parse(readFileSync(runJournalPath, "utf8"))).toEqual(liveJournal);
+        }
+        finally {
+            await new Promise((resolve, reject) => {
+                occupied.close((error) => (error ? reject(error) : resolve()));
+            });
+        }
+    });
+    it("rejects a same-config competitor before it can use an alternate ephemeral port", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+        }));
+        mocks.io.mockImplementation(() => new TestSocket());
+        const { startDaemon } = await import("../daemon.js");
+        const owner = await startDaemon(["--local-api-port", "0"]);
+        let competitor = null;
+        try {
+            const runJournalPath = `${configPath}.run-journal.json`;
+            const liveJournal = {
+                version: 1,
+                entries: [
+                    {
+                        runId: "live-run",
+                        conversationId: "live-conversation",
+                        acceptedAtMs: 1_000,
+                    },
+                ],
+            };
+            writeFileSync(runJournalPath, JSON.stringify(liveJournal));
+            let competitorError;
+            try {
+                competitor = await startDaemon(["--local-api-port", "0"]);
+            }
+            catch (error) {
+                competitorError = error;
+            }
+            expect(competitor).toBeNull();
+            expect(competitorError).toBeInstanceOf(Error);
+            expect(competitorError.message).toContain("already owns this daemon config");
+            expect(mocks.io).toHaveBeenCalledTimes(1);
+            expect(JSON.parse(readFileSync(runJournalPath, "utf8"))).toEqual(liveJournal);
+        }
+        finally {
+            await competitor?.stop();
+            await owner.stop();
+        }
+        expect(existsSync(`${configPath}.daemon-owner.json`)).toBe(false);
+        expect(existsSync(`${configPath}.maintenance-lease.json`)).toBe(false);
+    });
+    it("rejects an alternate-port start when a pre-lease daemon owns the stored endpoint", async () => {
+        const existing = createServer((req, res) => {
+            if (req.method === "GET" && req.url === "/status") {
+                res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
+                    configured: true,
+                    runtimeId: "11111111-1111-4111-8111-111111111111",
+                    wsUrl: "ws://ws.test",
+                    connected: true,
+                    activeRunIds: [],
+                    localApiPort: 0,
+                    localServiceId: "legacy-service-owner",
+                    daemonSessionId: "legacy-session",
+                    version: "test",
+                }));
+                return;
+            }
+            res.writeHead(404).end();
+        });
+        await new Promise((resolve) => existing.listen(0, "127.0.0.1", resolve));
+        let competitor = null;
+        try {
+            const address = existing.address();
+            const storedPort = typeof address === "object" && address ? address.port : 47831;
+            const storedConfig = {
+                runtimeId: "11111111-1111-4111-8111-111111111111",
+                runtimeToken: "alan_runtime_secret",
+                wsUrl: "ws://ws.test",
+                localApiPort: storedPort,
+                localApiToken: "local-secret",
+                localServiceId: "legacy-service-owner",
+            };
+            writeFileSync(configPath, JSON.stringify(storedConfig));
+            let competitorError;
+            try {
+                competitor = await (await import("../daemon.js")).startDaemon(["--local-api-port", "0"]);
+            }
+            catch (error) {
+                competitorError = error;
+            }
+            expect(competitor).toBeNull();
+            expect(competitorError).toBeInstanceOf(Error);
+            expect(competitorError.message).toContain("stored local endpoint already owns this daemon config");
+            expect(mocks.io).not.toHaveBeenCalled();
+            expect(JSON.parse(readFileSync(configPath, "utf8"))).toEqual(storedConfig);
+            expect(existsSync(`${configPath}.daemon-owner.json`)).toBe(false);
+            expect(existsSync(`${configPath}.maintenance-lease.json`)).toBe(false);
+        }
+        finally {
+            await competitor?.stop();
+            await new Promise((resolve, reject) => {
+                existing.close((error) => (error ? reject(error) : resolve()));
+            });
+        }
+    });
+    it("releases config ownership when the accepted-run journal cannot be validated", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+        }));
+        writeFileSync(`${configPath}.run-journal.json`, "not-json");
+        const { startDaemon } = await import("../daemon.js");
+        await expect(startDaemon(["--local-api-port", "0"])).rejects.toThrow("Cannot safely read accepted-run journal");
+        expect(mocks.io).not.toHaveBeenCalled();
+        expect(existsSync(`${configPath}.daemon-owner.json`)).toBe(false);
+        expect(existsSync(`${configPath}.maintenance-lease.json`)).toBe(false);
+    });
+    it("reclaims a stale daemon owner when its pid was reused and no runs are active", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+            localServiceId: "service-owner",
+        }));
+        writeFileSync(`${configPath}.daemon-owner.json`, JSON.stringify({
+            version: 1,
+            id: "reused-pid-owner",
+            daemonSessionId: "reused-pid-session",
+            pid: process.pid,
+            startedAtMs: 1_000,
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            localServiceId: "service-owner",
+            localApiPort: 0,
+            localApiToken: "local-secret",
+        }));
+        writeFileSync(`${configPath}.run-journal.json`, JSON.stringify({ version: 1, entries: [] }));
+        mocks.io.mockReturnValue(new TestSocket());
+        const controller = await (await import("../daemon.js")).startDaemon(["--local-api-port", "0"]);
+        try {
+            expect(JSON.parse(readFileSync(`${configPath}.daemon-owner.json`, "utf8"))).toMatchObject({
+                pid: process.pid,
+                runtimeId: "11111111-1111-4111-8111-111111111111",
+            });
+            expect(JSON.parse(readFileSync(`${configPath}.daemon-owner.json`, "utf8")).id).not.toBe("reused-pid-owner");
+        }
+        finally {
+            await controller.stop();
+        }
+        expect(existsSync(`${configPath}.daemon-owner.json`)).toBe(false);
+    });
+    it("preserves an unresponsive live owner when its run journal is active", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+            localServiceId: "service-owner",
+        }));
+        writeFileSync(`${configPath}.daemon-owner.json`, JSON.stringify({
+            version: 1,
+            id: "live-unresponsive-owner",
+            daemonSessionId: "live-unresponsive-session",
+            pid: process.pid,
+            startedAtMs: Date.now(),
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            localServiceId: "service-owner",
+            localApiPort: 0,
+            localApiToken: "local-secret",
+        }));
+        writeFileSync(`${configPath}.run-journal.json`, JSON.stringify({
+            version: 1,
+            entries: [
+                {
+                    runId: "live-run",
+                    conversationId: "live-conversation",
+                    acceptedAtMs: Date.now(),
+                },
+            ],
+        }));
+        mocks.io.mockReturnValue(new TestSocket());
+        const { startDaemon } = await import("../daemon.js");
+        await expect(startDaemon(["--local-api-port", "0"])).rejects.toThrow("already owns this daemon config");
+        expect(JSON.parse(readFileSync(`${configPath}.daemon-owner.json`, "utf8"))).toMatchObject({
+            id: "live-unresponsive-owner",
+        });
+        expect(mocks.io).not.toHaveBeenCalled();
+    });
+    it("reclaims a dead daemon owner before marking inherited runs interrupted", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret",
+            localServiceId: "service-owner",
+        }));
+        writeFileSync(`${configPath}.daemon-owner.json`, JSON.stringify({
+            version: 1,
+            id: "dead-owner",
+            daemonSessionId: "dead-session",
+            pid: 2_147_483_647,
+            startedAtMs: 1_000,
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            localServiceId: "service-owner",
+            localApiPort: 0,
+            localApiToken: "local-secret",
+        }));
+        const runJournalPath = `${configPath}.run-journal.json`;
+        writeFileSync(runJournalPath, JSON.stringify({
+            version: 1,
+            entries: [
+                {
+                    runId: "inherited-run",
+                    conversationId: "inherited-conversation",
+                    acceptedAtMs: 1_000,
+                },
+            ],
+        }));
+        mocks.io.mockReturnValue(new TestSocket());
+        const controller = await (await import("../daemon.js")).startDaemon(["--local-api-port", "0"]);
+        try {
+            expect(JSON.parse(readFileSync(`${configPath}.daemon-owner.json`, "utf8"))).toMatchObject({
+                pid: process.pid,
+                runtimeId: "11111111-1111-4111-8111-111111111111",
+            });
+            expect(JSON.parse(readFileSync(runJournalPath, "utf8"))).toMatchObject({
+                entries: [
+                    expect.objectContaining({ runId: "inherited-run", interruptedAtMs: expect.any(Number) }),
+                ],
+            });
+        }
+        finally {
+            await controller.stop();
+        }
+        expect(existsSync(`${configPath}.daemon-owner.json`)).toBe(false);
+    });
+    it("login starts browser device authorization, polls, and stores runtime config", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_secret",
+                userCode: "ABCD1234",
+                verificationUri: "http://app.test/runtime/device?code=ABCD1234",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: false,
+            status: 428,
+            json: async () => ({ error: "authorization_pending" }),
+            text: async () => JSON.stringify({ error: "authorization_pending" }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            status: 201,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Browser Login VM",
+                    teamId: "22222222-2222-4222-8222-222222222222",
+                },
+                runtimeToken: "alan_runtime_browser_secret",
+                runtimeRenewalToken: "alan_runtime_renew_browser_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await loginWithDeviceCode([
+            "--api-url",
+            "http://api.test",
+            "--ws-url",
+            "ws://ws.test",
+            "--name",
+            "Browser Login VM",
+            "--max-polls",
+            "3",
+        ]);
+        expect(fetchMock).toHaveBeenNthCalledWith(1, "http://api.test/public/runtimes/device-authorizations", expect.objectContaining({ method: "POST" }));
+        expect(fetchMock).toHaveBeenNthCalledWith(2, "http://api.test/public/runtimes/device-authorizations/token", expect.objectContaining({
+            method: "POST",
+            body: JSON.stringify({ deviceCode: "alan_device_secret" }),
+        }));
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        expect(info.mock.calls.some((call) => String(call[0]).includes("ABCD1234"))).toBe(true);
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved).toMatchObject({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            endpointProfile: "custom",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_browser_secret",
+            runtimeRenewalToken: "alan_runtime_renew_browser_secret",
+            displayName: "Browser Login VM",
+        });
+        expect(readFileSync(configPath, "utf8")).not.toContain("alan_device_secret");
+    });
+    it("resumes a still-valid browser authorization after login is abandoned", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_resume_secret",
+                userCode: "RESUME12",
+                verificationUri: "https://app.tryalan.ai/device?code=RESUME12",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: false,
+            status: 428,
+            text: async () => JSON.stringify({ error: "authorization_pending" }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            status: 201,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Resumed Laptop",
+                    teamId: "22222222-2222-4222-8222-222222222222",
+                },
+                runtimeToken: "alan_runtime_resumed_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await expect(loginWithDeviceCode(["--name", "Resumed Laptop", "--max-polls", "1"])).rejects.toThrow("timed out before approval");
+        const pendingPath = `${configPath}.device-auth-pending`;
+        expect(existsSync(pendingPath)).toBe(true);
+        expect(statSync(pendingPath).mode & 0o777).toBe(0o600);
+        await loginWithDeviceCode(["--name", "Resumed Laptop", "--max-polls", "1"]);
+        expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+            "https://api.tryalan.ai/public/runtimes/device-authorizations",
+            "https://api.tryalan.ai/public/runtimes/device-authorizations/token",
+            "https://api.tryalan.ai/public/runtimes/device-authorizations/token",
+        ]);
+        expect(existsSync(pendingPath)).toBe(false);
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_resumed_secret",
+        });
+    });
+    it("allows only one browser-login process to own and finalize resumable authorization", async () => {
+        let resolveStart;
+        const startResponse = new Promise((resolve) => {
+            resolveStart = resolve;
+        });
+        const fetchMock = vi.fn((url) => {
+            if (url.endsWith("/device-authorizations"))
+                return startResponse;
+            return Promise.resolve({
+                ok: false,
+                status: 428,
+                text: async () => JSON.stringify({ error: "authorization_pending" }),
+            });
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        const first = loginWithDeviceCode(["--name", "Exclusive Laptop", "--max-polls", "1"]);
+        await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
+        const second = loginWithDeviceCode(["--name", "Exclusive Laptop", "--max-polls", "1"]);
+        const secondResult = expect(second).rejects.toThrow("browser authorization is already in progress");
+        await Promise.resolve();
+        resolveStart({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_exclusive",
+                userCode: "EXCLUSIVE",
+                verificationUri: "https://app.tryalan.ai/device?code=EXCLUSIVE",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        });
+        await secondResult;
+        await expect(first).rejects.toThrow("timed out before approval");
+        expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+            "https://api.tryalan.ai/public/runtimes/device-authorizations",
+            "https://api.tryalan.ai/public/runtimes/device-authorizations/token",
+        ]);
+    });
+    it("does not finalize or clear browser credentials after sidecar ownership changes", async () => {
+        const pendingPath = `${configPath}.device-auth-pending`;
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_owner_change",
+                userCode: "OWNER123",
+                verificationUri: "https://app.tryalan.ai/device?code=OWNER123",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => {
+                const replacement = {
+                    ...JSON.parse(readFileSync(pendingPath, "utf8")),
+                    operationId: "replacement-login-owner",
+                };
+                writeFileSync(pendingPath, JSON.stringify(replacement), { mode: 0o600 });
+                return {
+                    runtime: { id: "11111111-1111-4111-8111-111111111111" },
+                    runtimeToken: "must-not-be-persisted",
+                };
+            },
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await expect(loginWithDeviceCode(["--max-polls", "1"])).rejects.toThrow("sidecar ownership was lost before finalization");
+        expect(existsSync(configPath)).toBe(false);
+        expect(JSON.parse(readFileSync(pendingPath, "utf8"))).toMatchObject({
+            operationId: "replacement-login-owner",
+        });
+    });
+    it("replaces an expired pending browser authorization", async () => {
+        writeFileSync(`${configPath}.device-auth-pending`, JSON.stringify({
+            apiUrl: "https://api.tryalan.ai",
+            deviceCode: "alan_device_expired",
+            userCode: "EXPIRED1",
+            verificationUri: "https://app.tryalan.ai/device?code=EXPIRED1",
+            expiresAt: new Date(Date.now() - 1_000).toISOString(),
+            intervalSeconds: 0,
+            installationId: "11111111-1111-4111-8111-111111111111",
+        }), { mode: 0o600 });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_replacement",
+                userCode: "REPLACE1",
+                verificationUri: "https://app.tryalan.ai/device?code=REPLACE1",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                runtime: { id: "11111111-1111-4111-8111-111111111111" },
+                runtimeToken: "alan_runtime_replacement",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await loginWithDeviceCode(["--max-polls", "1"]);
+        expect(fetchMock).toHaveBeenNthCalledWith(1, "https://api.tryalan.ai/public/runtimes/device-authorizations", expect.objectContaining({ method: "POST" }));
+        expect(fetchMock.mock.calls[1][1].body).toBe(JSON.stringify({ deviceCode: "alan_device_replacement" }));
+    });
+    it("cancels a pending browser authorization locally", async () => {
+        const pendingPath = `${configPath}.device-auth-pending`;
+        writeFileSync(pendingPath, "pending", { mode: 0o600 });
+        const fetchMock = vi.fn();
+        vi.stubGlobal("fetch", fetchMock);
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await loginWithDeviceCode(["--cancel"]);
+        expect(existsSync(pendingPath)).toBe(false);
+        expect(fetchMock).not.toHaveBeenCalled();
+        expect(info).toHaveBeenCalledWith("[alan-agent] Browser authorization canceled");
+    });
+    it("recovers login and cancellation from a corrupt browser-operation owner", async () => {
+        const operationPath = `${configPath}.device-auth-operation.json`;
+        const pendingPath = `${configPath}.device-auth-pending`;
+        writeFileSync(operationPath, '{"version":1,"id":', { mode: 0o600 });
+        writeFileSync(pendingPath, "abandoned", { mode: 0o600 });
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await loginWithDeviceCode(["--cancel"]);
+        expect(existsSync(operationPath)).toBe(false);
+        expect(existsSync(pendingPath)).toBe(false);
+        expect(info).toHaveBeenCalledWith("[alan-agent] Browser authorization canceled");
+        writeFileSync(operationPath, "not-json", { mode: 0o600 });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_after_corruption",
+                userCode: "RECOVER1",
+                verificationUri: "https://app.tryalan.ai/device?code=RECOVER1",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                runtime: { id: "11111111-1111-4111-8111-111111111111" },
+                runtimeToken: "alan_runtime_after_corruption",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        await loginWithDeviceCode(["--max-polls", "1"]);
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_after_corruption",
+        });
+        expect(existsSync(operationPath)).toBe(false);
+    });
+    it("preserves a valid browser-operation replacement raced over corrupt state", async () => {
+        const operationPath = `${configPath}.device-auth-operation.json`;
+        const replacement = {
+            version: 1,
+            id: "replacement-browser-operation",
+            expiresAtMs: Date.now() + 60_000,
+        };
+        writeFileSync(operationPath, "corrupt", { mode: 0o600 });
+        mocks.leaseReleaseMutationHook = (mutationPath) => {
+            if (mutationPath !== operationPath)
+                return;
+            writeFileSync(operationPath, JSON.stringify(replacement), { mode: 0o600 });
+        };
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await expect(loginWithDeviceCode(["--cancel"])).rejects.toThrow("browser authorization is already in progress");
+        expect(JSON.parse(readFileSync(operationPath, "utf8"))).toEqual(replacement);
+    });
+    it("login uses production endpoint defaults", async () => {
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                deviceCode: "alan_device_secret",
+                userCode: "ABCD1234",
+                verificationUri: "https://app.tryalan.ai/runtime/device?code=ABCD1234",
+                expiresAt: new Date(Date.now() + 60_000).toISOString(),
+                intervalSeconds: 0,
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            status: 201,
+            json: async () => ({
+                runtime: {
+                    id: "11111111-1111-4111-8111-111111111111",
+                    displayName: "Prod Login Runtime",
+                    teamId: "22222222-2222-4222-8222-222222222222",
+                },
+                runtimeToken: "alan_runtime_browser_secret",
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        vi.spyOn(console, "info").mockImplementation(() => { });
+        const { loginWithDeviceCode } = await import("../daemon.js");
+        await loginWithDeviceCode(["--max-polls", "1"]);
+        expect(fetchMock).toHaveBeenNthCalledWith(1, "https://api.tryalan.ai/public/runtimes/device-authorizations", expect.objectContaining({ method: "POST" }));
+        const saved = JSON.parse(readFileSync(configPath, "utf8"));
+        expect(saved).toMatchObject({
+            apiUrl: "https://api.tryalan.ai",
+            wsUrl: "wss://ws.tryalan.ai",
+            endpointProfile: "production",
+        });
+    });
+    it("setup preserves local config when runtime registration fails", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://existing.test",
+            runtimeId: "existing-runtime",
+            runtimeToken: "existing-token",
+        }));
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+            text: async () => "forbidden",
+        }));
+        const { setupDaemon } = await import("../daemon.js");
+        await expect(setupDaemon([
+            "--api-url",
+            "http://api.test",
+            "--team",
+            "22222222-2222-4222-8222-222222222222",
+            "--token",
+            "alan_pat_secret",
+        ])).rejects.toThrow("runtime registration failed: 403 forbidden");
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            apiUrl: "http://existing.test",
+            runtimeId: "existing-runtime",
+            runtimeToken: "existing-token",
+        });
+    });
+    it("daemon refuses to start without runtime identity, token, and websocket URL", async () => {
+        const { startDaemon } = await import("../daemon.js");
+        await expect(startDaemon(["--runtime-id", "11111111-1111-4111-8111-111111111111"])).rejects.toThrow("daemon requires runtimeId, runtime token, and wsUrl");
+        expect(mocks.io).not.toHaveBeenCalled();
+    });
+    it("startDaemon does not persist CLI identity or wsUrl overrides over stored config", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "https://api.real.test",
+            wsUrl: "wss://ws.real.test",
+            endpointProfile: "production",
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            runtimeToken: "alan_runtime_real",
+            localApiPort: 0,
+            localApiToken: "existing-local-token",
+        }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "runtime-override",
+            "--token",
+            "alan_runtime_override",
+            "--ws-url",
+            "ws://127.0.0.1:57613",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            expect(mocks.io).toHaveBeenCalledWith("ws://127.0.0.1:57613", expect.anything());
+            const saved = JSON.parse(readFileSync(configPath, "utf8"));
+            expect(saved).toMatchObject({
+                apiUrl: "https://api.real.test",
+                wsUrl: "wss://ws.real.test",
+                endpointProfile: "production",
+                runtimeId: "22222222-2222-4222-8222-222222222222",
+                runtimeToken: "alan_runtime_real",
+                localApiPort: 0,
+            });
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("self-heals a stored production config whose wsUrl contradicts the profile", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "https://api.tryalan.ai",
+            wsUrl: "ws://127.0.0.1:57613",
+            endpointProfile: "production",
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            runtimeToken: "alan_runtime_real",
+            localApiPort: 0,
+            localApiToken: "existing-local-token",
+        }));
+        writeFileSync(`${configPath}.run-journal.json`, JSON.stringify({
+            version: 1,
+            entries: [
+                {
+                    runId: "33333333-3333-4333-8333-333333333333",
+                    conversationId: "44444444-4444-4444-8444-444444444444",
+                    acceptedAtMs: Date.now(),
+                },
+            ],
+        }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        try {
+            expect(mocks.io).toHaveBeenCalledWith("wss://ws.tryalan.ai", expect.anything());
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("does not match its endpoint profile"), expect.objectContaining({ detail: expect.stringContaining("ws://127.0.0.1:57613") }));
+            // Runtime-only heal: the stored config keeps the bad value so the
+            // mismatch stays visible until the user re-runs setup.
+            const saved = JSON.parse(readFileSync(configPath, "utf8"));
+            expect(saved.wsUrl).toBe("ws://127.0.0.1:57613");
+            expect(saved.daemonEpoch).toBe(1);
+            // The degraded state is surfaced as a warn readiness check that does
+            // not block run acceptance.
+            socket.emit("connect");
+            const hello = await waitForOutbound(socket, "runtime.hello");
+            const runnerStatus = hello.payload.metadata.runnerStatus;
+            expect(runnerStatus.acceptingRuns).toBe(true);
+            expect(runnerStatus.daemonEpoch).toBe(1);
+            expect(runnerStatus).toMatchObject({
+                protocolVersion: 2,
+                protocolMinVersion: 1,
+                protocolMaxVersion: 2,
+            });
+            expect(runnerStatus.interruptedRunIds).toEqual(["33333333-3333-4333-8333-333333333333"]);
+            expect(runnerStatus.computerReadiness).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    key: "config_matches_profile",
+                    status: "warn",
+                    code: "config_endpoint_mismatch",
+                }),
+            ]));
+        }
+        finally {
+            warnSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("trusts explicit --ws-url overrides without profile validation", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "https://api.tryalan.ai",
+            wsUrl: "ws://127.0.0.1:57613",
+            endpointProfile: "production",
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            runtimeToken: "alan_runtime_real",
+            localApiPort: 0,
+            localApiToken: "existing-local-token",
+        }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--ws-url", "ws://ws.test", "--local-api-port", "0"]);
+        try {
+            expect(mocks.io).toHaveBeenCalledWith("ws://ws.test", expect.anything());
+            expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining("does not match its endpoint profile"), expect.anything());
+        }
+        finally {
+            warnSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("accepts stored endpoints that match a deployment's endpoints.json overrides", async () => {
+        writeFileSync(join(tempDir, "endpoints.json"), JSON.stringify({
+            apiUrl: "https://api.corp.example",
+            wsUrl: "wss://ws.corp.example",
+            endpointProfile: "production",
+        }));
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "https://api.corp.example",
+            wsUrl: "wss://ws.corp.example",
+            endpointProfile: "production",
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            runtimeToken: "alan_runtime_real",
+            localApiPort: 0,
+            localApiToken: "existing-local-token",
+        }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        try {
+            expect(mocks.io).toHaveBeenCalledWith("wss://ws.corp.example", expect.anything());
+            expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining("does not match its endpoint profile"), expect.anything());
+        }
+        finally {
+            warnSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("ignores stale endpoint defaults when stored production endpoints match the binary profile", async () => {
+        writeFileSync(join(tempDir, "endpoints.json"), JSON.stringify({
+            apiUrl: "https://api.tryalan.ai",
+            wsUrl: "wss://ws.tryalan.ai",
+            endpointProfile: "production",
+        }));
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "https://api.tryalan.ai",
+            wsUrl: "wss://ws.tryalan.ai",
+            endpointProfile: "production",
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            runtimeToken: "alan_runtime_real",
+            localApiPort: 0,
+            localApiToken: "existing-local-token",
+        }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        try {
+            expect(mocks.io).toHaveBeenCalledWith("wss://ws.tryalan.ai", expect.anything());
+            expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining("does not match its endpoint profile"), expect.anything());
+        }
+        finally {
+            warnSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("daemon connects as a runtime and hands accepted executions to CoreAgent", async () => {
+        const socket = new TestSocket();
+        const infoSpy = vi.spyOn(console, "info").mockImplementation(() => { });
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        const codexPath = join(binDir, "codex");
+        process.env.ALAN_CODEX_PATH = codexPath;
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        expect(mocks.io).toHaveBeenCalledWith("ws://ws.test", expect.objectContaining({
+            query: expect.objectContaining({
+                type: "runtime",
+                runtimeId: "11111111-1111-4111-8111-111111111111",
+                hostKind: "daemon",
+            }),
+            auth: { token: "alan_runtime_secret" },
+            transports: ["websocket"],
+        }));
+        socket.emit("connect");
+        await expect(waitForOutbound(socket, "runtime.hello")).resolves.toEqual(expect.objectContaining({
+            event: "runtime.hello",
+            payload: expect.objectContaining({
+                capabilities: expect.objectContaining({ supportsFilesystem: true }),
+                metadata: expect.objectContaining({
+                    platform: expect.any(String),
+                    arch: expect.any(String),
+                    agentVersion: expect.any(String),
+                    memoryBytes: expect.any(Number),
+                }),
+            }),
+        }));
+        socket.emit("agent.execute", {
+            conversationId: "conversation-missing-workspace",
+            runId: "run-missing-workspace",
+            content: "Run from a moved project",
+            backendKind: "codex",
+            projectPath: join(tempDir, "moved-workspace"),
+        });
+        expect(socket.outbound).toEqual(expect.arrayContaining([
+            {
+                event: "agent.rejected",
+                payload: expect.objectContaining({
+                    runId: "run-missing-workspace",
+                    code: "workspace_missing",
+                    message: expect.stringContaining("moved or removed"),
+                }),
+            },
+        ]));
+        expect(mocks.agentRun).not.toHaveBeenCalled();
+        const deniedStatus = await fetch(`http://127.0.0.1:${controller.localApiPort}/status`, {
+            headers: { authorization: `Bearer ${controller.localApiToken}` },
+        }).then((response) => response.json());
+        expect(deniedStatus.workspaceRecoveryPath).toBe(join(tempDir, "moved-workspace"));
+        const deniedRecheck = await fetch(`http://127.0.0.1:${controller.localApiPort}/workspace/recheck`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${controller.localApiToken}` },
+        }).then((response) => response.json());
+        expect(deniedRecheck).toMatchObject({
+            ok: false,
+            readiness: { code: "workspace_missing" },
+        });
+        const workspacePath = join(tempDir, "workspace");
+        mkdirSync(workspacePath, { recursive: true });
+        socket.emit("agent.execute", {
+            conversationId: "conversation-1",
+            runId: "run-1",
+            messageId: "message-1",
+            taskId: "task-1",
+            cloudEnvironmentId: "cloud-env-1",
+            content: "Ship the task",
+            backendKind: "codex",
+            teamId: "team-1",
+            projectPath: workspacePath,
+            maxIterations: 7,
+        });
+        await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-1" } }])), { timeout: 5_000 });
+        const recoveredStatus = await fetch(`http://127.0.0.1:${controller.localApiPort}/status`, {
+            headers: { authorization: `Bearer ${controller.localApiToken}` },
+        }).then((response) => response.json());
+        expect(recoveredStatus.workspaceRecoveryPath).toBeNull();
+        expect(mocks.coreAgentConstructor).toHaveBeenCalledWith(expect.any(Object), {
+            backendKind: "codex_app_server",
+            runtimeCommand: codexPath,
+            providerApiKey: undefined,
+            onProviderSpawned: expect.any(Function),
+        });
+        expect(mocks.agentRun).toHaveBeenCalledWith(expect.objectContaining({
+            task: "Ship the task",
+            cwd: workspacePath,
+            teamPath: workspacePath,
+            backendKind: "codex_app_server",
+            runtimeCommand: codexPath,
+            conversationId: "conversation-1",
+            taskId: "task-1",
+            teamId: "team-1",
+            maxIterations: 7,
+        }));
+        expect(infoSpy).toHaveBeenCalledWith("[alan-agent] Agent run accepted", expect.objectContaining({
+            taskId: "task-1",
+            conversationId: "conversation-1",
+            runId: "run-1",
+            messageId: "message-1",
+            cloudEnvironmentId: "cloud-env-1",
+            provider: "codex_app_server",
+            backendKind: "codex_app_server",
+            agentVersion: expect.any(String),
+        }));
+        socket.emit("agent.execute", {
+            conversationId: "conversation-1",
+            runId: "run-1",
+            content: "Duplicate",
+        });
+        expect(socket.outbound.filter((item) => item.event === "agent.accepted" &&
+            item.payload?.runId === "run-1")).toHaveLength(2);
+        expect(socket.outbound).not.toEqual(expect.arrayContaining([
+            {
+                event: "agent.rejected",
+                payload: expect.objectContaining({ runId: "run-1" }),
+            },
+        ]));
+        expect(mocks.agentRun).toHaveBeenCalledTimes(1);
+        socket.emit("agent.execute", {
+            conversationId: "different-conversation",
+            runId: "run-1",
+            content: "Conflicting duplicate",
+        });
+        expect(socket.outbound).toEqual(expect.arrayContaining([
+            {
+                event: "agent.rejected",
+                payload: expect.objectContaining({ runId: "run-1", code: "run_id_conflict" }),
+            },
+        ]));
+        expect(mocks.agentRun).toHaveBeenCalledTimes(1);
+        socket.emit("agent.abort", { runId: "run-1" });
+        expect(mocks.agentKill).toHaveBeenCalled();
+        expect(socket.outbound).toEqual(expect.arrayContaining([
+            {
+                event: "agent.event",
+                payload: expect.objectContaining({
+                    conversationId: "conversation-1",
+                    runId: "run-1",
+                    event: expect.objectContaining({
+                        type: "agent_run_finished",
+                        result: expect.objectContaining({
+                            error: "Interrupted by user",
+                            errorKind: "user",
+                            success: false,
+                        }),
+                    }),
+                }),
+            },
+        ]));
+        expect(socket.disconnected).toBe(false);
+        // A server-watchdog abort must carry a distinct, non-user-attributed error.
+        socket.emit("agent.execute", {
+            conversationId: "conversation-2",
+            runId: "run-2",
+            messageId: "message-2",
+            taskId: "task-2",
+            cloudEnvironmentId: "cloud-env-1",
+            content: "Second task",
+            backendKind: "codex",
+            teamId: "team-1",
+            projectPath: workspacePath,
+            maxIterations: 7,
+        });
+        await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-2" } }])), { timeout: 5_000 });
+        socket.emit("agent.abort", { runId: "run-2", reason: "watchdog_timeout" });
+        expect(socket.outbound).toEqual(expect.arrayContaining([
+            {
+                event: "agent.event",
+                payload: expect.objectContaining({
+                    conversationId: "conversation-2",
+                    runId: "run-2",
+                    event: expect.objectContaining({
+                        type: "agent_run_finished",
+                        result: expect.objectContaining({
+                            error: expect.stringContaining("stopped by the server"),
+                            errorKind: "watchdog_timeout",
+                            success: false,
+                        }),
+                    }),
+                }),
+            },
+        ]));
+        await controller.stop();
+        expect(socket.disconnected).toBe(true);
+    });
+    it("renews a rejected runtime token once and reconnects with the persisted replacement", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "old_runtime_secret",
+            runtimeRenewalToken: "alan_runtime_renew_secret",
+            localApiPort: 0,
+            localApiToken: "local-secret",
+        }));
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ runtimeToken: "alan_runtime_new_secret" }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        const rejection = Object.assign(new Error("Invalid runtime token"), {
+            data: { code: "invalid_runtime_token" },
+        });
+        socket.emit("connect_error", rejection);
+        socket.emit("connect_error", rejection);
+        await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledWith("http://api.test/public/runtimes/11111111-1111-4111-8111-111111111111/tokens/renew", expect.objectContaining({
+            method: "POST",
+            headers: {
+                authorization: "Bearer alan_runtime_renew_secret",
+                "content-type": "application/json",
+            },
+            body: "{}",
+        })));
+        await vi.waitFor(() => expect(JSON.parse(readFileSync(configPath, "utf8")).runtimeToken).toBe("alan_runtime_new_secret"));
+        await vi.waitFor(() => expect(socket.connectCalls).toBe(1));
+        expect(fetchMock.mock.calls.filter(([url]) => String(url).endsWith("/tokens/renew"))).toHaveLength(1);
+        expect(socket.auth).toEqual({ token: "alan_runtime_new_secret" });
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toMatchObject({
+            runtimeToken: "alan_runtime_new_secret",
+            runtimeRenewalToken: "alan_runtime_renew_secret",
+        });
+        await controller.stop();
+    });
+    it("reports a proven DNS failure through local daemon status", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "wss://ws.tryalan.ai",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect_error", Object.assign(new Error("getaddrinfo ENOTFOUND ws.tryalan.ai"), { code: "ENOTFOUND" }));
+            const response = await fetch(`http://127.0.0.1:${controller.localApiPort}/status`, {
+                headers: { authorization: `Bearer ${controller.localApiToken}` },
+            });
+            expect(await response.json()).toMatchObject({
+                lastConnectErrorCode: "network_dns_failure",
+            });
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("keeps a live-PID recovered run interrupted and duplicate-fenced after restart", async () => {
+        const firstSocket = new TestSocket();
+        mocks.io.mockReturnValue(firstSocket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const args = [
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ];
+        const firstController = await startDaemon(args);
+        firstSocket.emit("connect");
+        firstSocket.emit("agent.execute", {
+            conversationId: "conversation-durable",
+            runId: "run-durable",
+            content: "Execute exactly once",
+            backendKind: "codex",
+        });
+        await vi.waitFor(() => expect(firstSocket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-durable" } }])), { timeout: 5_000 });
+        expect(mocks.agentRun).toHaveBeenCalledTimes(1);
+        await vi.waitFor(() => {
+            const journal = JSON.parse(readFileSync(`${configPath}.run-journal.json`, "utf8"));
+            expect(journal.entries).toEqual(expect.arrayContaining([
+                expect.objectContaining({ runId: "run-durable", providerPid: process.pid }),
+            ]));
+        });
+        await firstController.stop();
+        const secondSocket = new TestSocket();
+        mocks.io.mockReturnValue(secondSocket);
+        const secondController = await startDaemon(args);
+        try {
+            secondSocket.emit("connect");
+            secondSocket.emit("agent.execute", {
+                conversationId: "conversation-durable",
+                runId: "run-durable",
+                content: "Redelivered after lost ACK",
+                backendKind: "codex",
+            });
+            await vi.waitFor(() => expect(secondSocket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: expect.objectContaining({
+                        runId: "run-durable",
+                        code: "run_interrupted_by_restart",
+                    }),
+                },
+            ])));
+            expect(mocks.agentRun).toHaveBeenCalledTimes(1);
+            secondSocket.emit("agent.execute", {
+                conversationId: "another-conversation",
+                runId: "run-durable",
+                content: "Conflicting redelivery after restart",
+                backendKind: "codex",
+            });
+            await vi.waitFor(() => expect(secondSocket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: expect.objectContaining({
+                        runId: "run-durable",
+                        code: "run_id_conflict",
+                    }),
+                },
+            ])));
+            expect(mocks.agentRun).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            await secondController.stop();
+        }
+    });
+    it("recovers a moved project by exact repository identity before provider spawn", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const missingPath = join(tempDir, "old-project-name");
+        const relocatedPath = join(tempDir, "new-project-name");
+        mkdirSync(relocatedPath, { recursive: true });
+        mocks.discoverRelocatedWorkspace.mockReturnValue(relocatedPath);
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-relocated",
+                runId: "run-relocated",
+                content: "Use the relocated project",
+                backendKind: "codex",
+                projectPath: missingPath,
+                repoLocalPaths: [
+                    {
+                        repoId: "repo-1",
+                        repoUrl: "https://github.com/alan-ai/alan.git",
+                        localPath: missingPath,
+                    },
+                ],
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-relocated" } }])));
+            expect(mocks.discoverRelocatedWorkspace).toHaveBeenCalledWith({
+                missingPath,
+                approvedWorkspacePaths: undefined,
+                expectedRepoUrls: ["https://github.com/alan-ai/alan.git"],
+            });
+            expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "runtime.workspace.relocated",
+                    payload: expect.objectContaining({
+                        conversationId: "conversation-relocated",
+                        runId: "run-relocated",
+                        previousPath: missingPath,
+                        canonicalPath: relocatedPath,
+                    }),
+                },
+            ]));
+            expect(mocks.agentRun).toHaveBeenCalledWith(expect.objectContaining({ cwd: relocatedPath, teamPath: relocatedPath }));
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("rejects an existing workspace that belongs to a different repository", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        mocks.workspaceMatchesExpectedRepositories.mockReturnValue(false);
+        const workspacePath = join(tempDir, "reused-project-path");
+        mkdirSync(workspacePath, { recursive: true });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-repository-mismatch",
+                runId: "run-repository-mismatch",
+                content: "Do not run in the wrong repository",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                localRepoUrls: ["https://github.com/alan-ai/expected.git"],
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: expect.objectContaining({
+                        runId: "run-repository-mismatch",
+                        code: "workspace_repository_mismatch",
+                    }),
+                },
+            ])));
+            expect(mocks.workspaceMatchesExpectedRepositories).toHaveBeenCalledWith({
+                workspacePath,
+                expectedRepoUrls: ["https://github.com/alan-ai/expected.git"],
+            });
+            expect(mocks.agentRun).not.toHaveBeenCalled();
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("rejects a multi-repo task worktree before agent execution", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const container = join(tempDir, "multi-repo-task");
+        const worktreeA = join(container, "repo-a");
+        const worktreeB = join(container, "repo-b");
+        mkdirSync(worktreeA, { recursive: true });
+        mkdirSync(worktreeB, { recursive: true });
+        const repoUrlA = "https://github.com/alan-ai/repo-a.git";
+        const repoUrlB = "https://github.com/alan-ai/repo-b.git";
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-multi-repo",
+                runId: "run-multi-repo",
+                content: "Work across both repos",
+                backendKind: "codex",
+                localRepoUrls: [repoUrlA, repoUrlB],
+                worktreeInfo: {
+                    worktreePath: worktreeA,
+                    branchName: "codex/task-a",
+                    allWorktrees: [
+                        { worktreePath: worktreeA, branchName: "codex/task-a" },
+                        { worktreePath: worktreeB, branchName: "codex/task-b" },
+                    ],
+                },
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: {
+                        runId: "run-multi-repo",
+                        message: "A task worktree requires exactly one Git repository.",
+                        code: "single_repository_worktree_required",
+                    },
+                },
+            ])), { timeout: 5_000 });
+            expect(mocks.workspaceMatchesExpectedRepositories).not.toHaveBeenCalled();
+            expect(mocks.agentRun).not.toHaveBeenCalled();
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("allows multiple repository paths for a shared checkout", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const projectPath = join(tempDir, "multi-repo-shared-checkout");
+        const repoA = join(projectPath, "repo-a");
+        const repoB = join(projectPath, "repo-b");
+        mkdirSync(repoA, { recursive: true });
+        mkdirSync(repoB, { recursive: true });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-multi-repo-shared",
+                runId: "run-multi-repo-shared",
+                content: "Work across both shared checkout repositories",
+                backendKind: "codex",
+                projectPath,
+                repoLocalPaths: [
+                    { repoUrl: "https://github.com/alan-ai/repo-a.git", localPath: repoA },
+                    { repoUrl: "https://github.com/alan-ai/repo-b.git", localPath: repoB },
+                ],
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-multi-repo-shared" } },
+            ])));
+            expect(mocks.agentRun).toHaveBeenCalled();
+            expect(socket.outbound.find((event) => event.event === "agent.rejected" &&
+                event.payload.runId === "run-multi-repo-shared")).toBeUndefined();
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("stops an active run with a typed recovery cause when its branch lease changes", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const workspacePath = join(tempDir, "leased-worktree");
+        mkdirSync(workspacePath, { recursive: true });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-branch-lease",
+                runId: "run-branch-lease",
+                content: "Keep work on the leased branch",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                worktreeInfo: {
+                    worktreePath: workspacePath,
+                    branchName: "codex/task-1",
+                },
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-branch-lease" } },
+            ])));
+            expect(mocks.captureWorkspaceRunLease).toHaveBeenCalledWith([
+                { workspacePath, expectedBranch: "codex/task-1" },
+            ]);
+            mocks.workspaceLeaseVerify.mockReturnValue({
+                code: "workspace_lease_branch_changed",
+                message: "The workspace branch changed from codex/task-1 to main while the run was active.",
+                workspacePath,
+                expectedBranch: "codex/task-1",
+                actualBranch: "main",
+            });
+            const presenter = mocks.coreAgentConstructor.mock.calls.at(-1)?.[0];
+            presenter.onToolUse("Bash", { command: "touch unsafe.txt" }, "tool-after-branch-change");
+            await vi.waitFor(() => expect(mocks.agentKill).toHaveBeenCalledTimes(1));
+            expect(socket.outbound.some((item) => item.event === "agent.event" &&
+                item.payload.event?.id ===
+                    "tool-after-branch-change")).toBe(false);
+            expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.event",
+                    payload: expect.objectContaining({
+                        conversationId: "conversation-branch-lease",
+                        runId: "run-branch-lease",
+                        event: expect.objectContaining({
+                            type: "application_problem",
+                            problem: expect.objectContaining({
+                                domain: "application",
+                                code: "app.workspace.missing",
+                            }),
+                        }),
+                    }),
+                },
+            ]));
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("reuses a durably remembered relocation after daemon restart until backend persistence", async () => {
+        const firstSocket = new TestSocket();
+        firstSocket.acknowledgeWorkspaceRelocations = false;
+        const secondSocket = new TestSocket();
+        secondSocket.acknowledgeWorkspaceRelocations = false;
+        mocks.io.mockReturnValueOnce(firstSocket).mockReturnValueOnce(secondSocket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const missingPath = join(tempDir, "old-project-name");
+        const relocatedPath = join(tempDir, "new-project-name");
+        mkdirSync(relocatedPath, { recursive: true });
+        mocks.discoverRelocatedWorkspace.mockReturnValue(relocatedPath);
+        const { startDaemon } = await import("../daemon.js");
+        const args = [
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ];
+        const firstController = await startDaemon(args);
+        firstSocket.emit("connect");
+        firstSocket.emit("agent.execute", {
+            conversationId: "conversation-relocated-1",
+            runId: "run-relocated-1",
+            content: "Find the moved project",
+            backendKind: "codex",
+            projectPath: missingPath,
+            localRepoUrls: ["https://github.com/alan-ai/alan.git"],
+        });
+        await vi.waitFor(() => expect(firstSocket.outbound).toEqual(expect.arrayContaining([
+            { event: "agent.accepted", payload: { runId: "run-relocated-1" } },
+        ])), { timeout: 5_000 });
+        expect(JSON.parse(readFileSync(configPath, "utf8")).workspaceRelocations).toEqual([
+            expect.objectContaining({ previousPath: missingPath, canonicalPath: relocatedPath }),
+        ]);
+        await firstController.stop();
+        mocks.discoverRelocatedWorkspace.mockClear();
+        mocks.workspaceMatchesExpectedRepositories.mockReturnValue(true);
+        const secondController = await startDaemon(args);
+        try {
+            secondSocket.emit("connect");
+            secondSocket.emit("agent.execute", {
+                conversationId: "conversation-relocated-2",
+                runId: "run-relocated-2",
+                content: "Reuse the moved project",
+                backendKind: "codex",
+                projectPath: missingPath,
+                localRepoUrls: ["https://github.com/alan-ai/alan.git"],
+            });
+            await vi.waitFor(() => expect(secondSocket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-relocated-2" } },
+            ])), { timeout: 5_000 });
+            expect(mocks.workspaceMatchesExpectedRepositories).toHaveBeenCalledWith({
+                workspacePath: relocatedPath,
+                expectedRepoUrls: ["https://github.com/alan-ai/alan.git"],
+            });
+            expect(mocks.discoverRelocatedWorkspace).not.toHaveBeenCalled();
+            expect(mocks.agentRun).toHaveBeenLastCalledWith(expect.objectContaining({ cwd: relocatedPath, teamPath: relocatedPath }));
+        }
+        finally {
+            await secondController.stop();
+        }
+    });
+    it("creates and runs inside the managed Alan workspace for a no-Project execution", async () => {
+        const socket = new TestSocket();
+        const infoSpy = vi.spyOn(console, "info").mockImplementation(() => { });
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            await waitForOutbound(socket, "runtime.hello");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-default",
+                runId: "run-default",
+                content: "Work without a project",
+                backendKind: "codex",
+                projectPath: ALAN_DEFAULT_WORKSPACE_URI,
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-default" } }])));
+            expect(mocks.agentRun).toHaveBeenCalledWith(expect.objectContaining({
+                cwd: mocks.defaultWorkspacePath,
+                teamPath: mocks.defaultWorkspacePath,
+            }));
+        }
+        finally {
+            infoSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("rejects a definitively signed-out provider before acceptance or spawn", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        const codexPath = join(binDir, "codex");
+        writeFileSync(codexPath, '#!/bin/sh\nif [ "$1 $2" = "login status" ]; then echo "Not logged in"; exit 1; fi\nexit 0\n');
+        chmodSync(codexPath, 0o755);
+        process.env.ALAN_CODEX_PATH = codexPath;
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        socket.emit("connect");
+        const workspacePath = join(tempDir, "workspace");
+        mkdirSync(workspacePath, { recursive: true });
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "conversation-provider-auth",
+                runId: "run-provider-auth",
+                content: "Run with a signed-out provider",
+                backendKind: "codex",
+                projectPath: workspacePath,
+            });
+            const rejected = await waitForOutbound(socket, "agent.rejected");
+            expect(rejected.payload).toEqual(expect.objectContaining({
+                runId: "run-provider-auth",
+                code: "provider_auth_required",
+                message: expect.stringContaining("codex login"),
+            }));
+            expect(socket.outbound).not.toContainEqual({
+                event: "agent.accepted",
+                payload: { runId: "run-provider-auth" },
+            });
+            expect(mocks.agentRun).not.toHaveBeenCalled();
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("registers per-run Alan MCP config before spawning and rejects a missing run contract", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        socket.emit("connect");
+        const workspacePath = join(tempDir, "workspace");
+        mkdirSync(workspacePath, { recursive: true });
+        const alanMcp = {
+            url: "https://api.alan.test/mcp",
+            headers: { Authorization: "Bearer alan_pat", "x-conversation-id": "conversation-mcp" },
+            ...readinessContract,
+        };
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "conversation-mcp",
+                runId: "run-mcp-1",
+                content: "Run with per-run MCP",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                alanMcp,
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-mcp-1" } }])));
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenCalledWith("codex_app_server", alanMcp, undefined);
+            expect(mocks.verifyAlanMcpRegistered).not.toHaveBeenCalled();
+            // Registration must happen before the CLI is handed the run.
+            expect(mocks.ensureAlanMcpRegistered.mock.invocationCallOrder[0]).toBeLessThan(mocks.agentRun.mock.invocationCallOrder[0]);
+            socket.emit("agent.execute", {
+                conversationId: "conversation-mcp-3",
+                runId: "run-mcp-3",
+                content: "Run without per-run MCP",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                alanMcp: null,
+            });
+            const rejected = await waitForOutbound(socket, "agent.rejected");
+            expect(rejected.payload).toEqual(expect.objectContaining({
+                runId: "run-mcp-3",
+                code: "mcp_config_invalid",
+                message: expect.stringContaining("run-scoped tools contract"),
+            }));
+            expect(socket.outbound).not.toContainEqual({
+                event: "agent.accepted",
+                payload: { runId: "run-mcp-3" },
+            });
+            expect(mocks.verifyAlanMcpRegistered).not.toHaveBeenCalled();
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("serializes per-run MCP writes only until each provider process starts", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const providerStarts = [];
+        mocks.coreAgentConstructor.mockImplementation(function MockCoreAgent(_presenter, runtime) {
+            return {
+                run: (...args) => {
+                    providerStarts.push(() => runtime?.onProviderSpawned?.(20_000 + providerStarts.length));
+                    return mocks.agentRun(...args);
+                },
+                kill: mocks.agentKill,
+                sendToolResponse: mocks.sendToolResponse,
+            };
+        });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        socket.emit("connect");
+        const workspacePath = join(tempDir, "workspace");
+        mkdirSync(workspacePath, { recursive: true });
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "conversation-org-a",
+                runId: "run-org-a",
+                content: "Run org-a",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                alanMcp: {
+                    url: "https://api.alan.test/mcp",
+                    headers: { "x-alan-run-reference": "capability-org-a" },
+                    ...readinessContract,
+                },
+            });
+            await vi.waitFor(() => expect(providerStarts).toHaveLength(1), { timeout: 5_000 });
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenCalledTimes(1);
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenNthCalledWith(1, "codex_app_server", {
+                url: "https://api.alan.test/mcp",
+                headers: { "x-alan-run-reference": "capability-org-a" },
+                ...readinessContract,
+            }, undefined);
+            socket.emit("agent.execute", {
+                conversationId: "conversation-org-b",
+                runId: "run-org-b",
+                content: "Run org-b",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                alanMcp: {
+                    url: "https://api.alan.test/mcp",
+                    headers: { "x-alan-run-reference": "capability-org-b" },
+                    ...readinessContract,
+                },
+            });
+            // Org B is queued behind the MCP config used by Org A until the first
+            // provider has spawned and inherited that configuration.
+            await Promise.resolve();
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenCalledTimes(1);
+            providerStarts[0]?.();
+            await vi.waitFor(() => expect(providerStarts).toHaveLength(2), { timeout: 5_000 });
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenCalledTimes(2);
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenNthCalledWith(2, "codex_app_server", {
+                url: "https://api.alan.test/mcp",
+                headers: { "x-alan-run-reference": "capability-org-b" },
+                ...readinessContract,
+            }, undefined);
+            providerStarts[1]?.();
+            expect(mocks.agentRun).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("keeps a delayed gated run duplicate-fenced beyond the inherited-artifact TTL", async () => {
+        let nowMs = 1_000;
+        const nowSpy = vi.spyOn(Date, "now").mockImplementation(() => nowMs);
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const providerStarts = [];
+        mocks.coreAgentConstructor.mockImplementation(function MockCoreAgent(_presenter, runtime) {
+            return {
+                run: (...args) => {
+                    providerStarts.push(() => runtime?.onProviderSpawned?.(30_000 + providerStarts.length));
+                    return mocks.agentRun(...args);
+                },
+                kill: mocks.agentKill,
+                sendToolResponse: mocks.sendToolResponse,
+            };
+        });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        socket.emit("connect");
+        const workspacePath = join(tempDir, "workspace");
+        mkdirSync(workspacePath, { recursive: true });
+        const execute = (runId, conversationId) => {
+            socket.emit("agent.execute", {
+                conversationId,
+                runId,
+                content: `Run ${runId}`,
+                backendKind: "codex",
+                projectPath: workspacePath,
+                alanMcp: {
+                    url: "https://api.alan.test/mcp",
+                    headers: { "x-conversation-id": conversationId },
+                    ...readinessContract,
+                },
+            });
+        };
+        try {
+            execute("run-gate-owner", "conversation-gate-owner");
+            await vi.waitFor(() => expect(providerStarts).toHaveLength(1), { timeout: 5_000 });
+            execute("run-delayed", "conversation-delayed");
+            const readDelayedFence = () => JSON.parse(readFileSync(`${configPath}.pending-runs.json`, "utf8")).entries.find((entry) => entry.runId === "run-delayed");
+            await vi.waitFor(() => expect(readDelayedFence()?.startedAtMs).toBe(1_000));
+            nowMs += 10 * 60_000 + 1;
+            execute("run-delayed", "conversation-delayed");
+            expect(readDelayedFence()?.startedAtMs).toBe(1_000);
+            providerStarts[0]?.();
+            await vi.waitFor(() => expect(providerStarts).toHaveLength(2), { timeout: 5_000 });
+            providerStarts[1]?.();
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            expect(providerStarts).toHaveLength(2);
+            expect(mocks.agentRun).toHaveBeenCalledTimes(2);
+            expect(mocks.ensureAlanMcpRegistered).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            nowSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("rejects local runs when required Alan MCP setup is unavailable", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const binDir = seedCliBinaries(tempDir);
+        process.env.ALAN_CODEX_PATH = join(binDir, "codex");
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.ensureAlanMcpRegistered.mockResolvedValue({
+            ok: false,
+            paths: [],
+            error: "config is read-only",
+        });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        socket.emit("connect");
+        const workspacePath = join(tempDir, "workspace");
+        mkdirSync(workspacePath, { recursive: true });
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "conversation-mcp-failure",
+                runId: "run-mcp-failure",
+                content: "Run without required tools",
+                backendKind: "codex",
+                projectPath: workspacePath,
+                alanMcp: {
+                    url: "https://api.alan.test/mcp",
+                    headers: { Authorization: "Bearer alan_pat" },
+                    ...readinessContract,
+                },
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: expect.objectContaining({
+                        runId: "run-mcp-failure",
+                        code: "mcp_config_invalid",
+                    }),
+                },
+            ])));
+            expect(socket.outbound).not.toContainEqual({
+                event: "agent.accepted",
+                payload: { runId: "run-mcp-failure" },
+            });
+            expect(mocks.agentRun).not.toHaveBeenCalled();
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("local daemon API reports status, protects endpoints, streams logs, and stops active runs", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            const baseUrl = `http://127.0.0.1:${controller.localApiPort}`;
+            const unauthorized = await fetch(`${baseUrl}/status`);
+            expect(unauthorized.status).toBe(401);
+            const missing = await fetch(`${baseUrl}/missing`, {
+                headers: { authorization: `Bearer ${controller.localApiToken}` },
+            });
+            expect(missing.status).toBe(404);
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-local-api",
+                content: "Keep running",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-local-api" } },
+            ])), { timeout: 5_000 });
+            const headers = { authorization: `Bearer ${controller.localApiToken}` };
+            const status = await fetch(`${baseUrl}/status`, { headers }).then((res) => res.json());
+            expect(status).toMatchObject({
+                configured: true,
+                runtimeId: "11111111-1111-4111-8111-111111111111",
+                connected: true,
+                activeRunIds: ["run-local-api"],
+                activeRunCount: 1,
+                // Concurrency is unbounded: an active run does not stop the computer
+                // from accepting more runs.
+                acceptingRuns: true,
+                recovering: false,
+                restartRecommended: false,
+                staleRunCount: 0,
+            });
+            expect(typeof status.lastRunActivityAtMs).toBe("number");
+            expect(status.disconnectedSinceMs).toBeNull();
+            const capabilities = await fetch(`${baseUrl}/capabilities`, { headers }).then((res) => res.json());
+            expect(capabilities).toMatchObject({ hasTerminal: true, supportsFilesystem: true });
+            const logs = await fetch(`${baseUrl}/logs`, { headers }).then((res) => res.json());
+            expect(logs.lines.some((line) => line.includes("accepted run=run-local-api"))).toBe(true);
+            const stopped = await fetch(`${baseUrl}/stop`, { method: "POST", headers }).then((res) => res.json());
+            expect(stopped).toEqual({ ok: true });
+            expect(mocks.agentKill).toHaveBeenCalled();
+            const afterStop = await fetch(`${baseUrl}/status`, { headers }).then((res) => res.json());
+            expect(afterStop.activeRunIds).toEqual([]);
+            expect(afterStop.activeRunCount).toBe(0);
+            expect(afterStop.acceptingRuns).toBe(true);
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("clears active local API runs when a continuation-mode provider reports query complete", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            const baseUrl = `http://127.0.0.1:${controller.localApiPort}`;
+            const headers = { authorization: `Bearer ${controller.localApiToken}` };
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-continuation",
+                content: "Keep provider process open",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-continuation" } },
+            ])), { timeout: 5_000 });
+            const activeStatus = await fetch(`${baseUrl}/status`, { headers }).then((res) => res.json());
+            expect(activeStatus).toMatchObject({
+                activeRunIds: ["run-continuation"],
+                activeRunCount: 1,
+                acceptingRuns: true,
+            });
+            const presenter = mocks.coreAgentConstructor.mock.calls.at(-1)?.[0];
+            presenter.onComplete({ success: true, summary: "done" });
+            const releasedStatus = await fetch(`${baseUrl}/status`, { headers }).then((res) => res.json());
+            expect(releasedStatus).toMatchObject({
+                activeRunIds: [],
+                activeRunCount: 0,
+                acceptingRuns: true,
+            });
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("clears stale active runs while disconnected and recommends restart after grace", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const nowSpy = vi.spyOn(Date, "now").mockReturnValue(1_000_000);
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            const baseUrl = `http://127.0.0.1:${controller.localApiPort}`;
+            const headers = { authorization: `Bearer ${controller.localApiToken}` };
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-stale",
+                content: "Keep running",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([{ event: "agent.accepted", payload: { runId: "run-stale" } }])), { timeout: 5_000 });
+            socket.connected = false;
+            socket.emit("disconnect", "transport close");
+            nowSpy.mockReturnValue(1_000_000 + 121_000);
+            const status = await fetch(`${baseUrl}/status`, { headers }).then((res) => res.json());
+            expect(mocks.agentKill).toHaveBeenCalled();
+            expect(status).toMatchObject({
+                connected: false,
+                activeRunIds: [],
+                activeRunCount: 0,
+                acceptingRuns: false,
+                recovering: false,
+                restartRecommended: true,
+            });
+        }
+        finally {
+            nowSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("clears stale active runs while connected after grace", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const nowSpy = vi.spyOn(Date, "now").mockReturnValue(1_000_000);
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            const baseUrl = `http://127.0.0.1:${controller.localApiPort}`;
+            const headers = { authorization: `Bearer ${controller.localApiToken}` };
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-stale-connected",
+                content: "Keep running",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-stale-connected" } },
+            ])), { timeout: 5_000 });
+            nowSpy.mockReturnValue(1_000_000 + 121_000);
+            const status = await fetch(`${baseUrl}/status`, { headers }).then((res) => res.json());
+            expect(mocks.agentKill).toHaveBeenCalled();
+            expect(status).toMatchObject({
+                connected: true,
+                activeRunIds: [],
+                activeRunCount: 0,
+                acceptingRuns: true,
+                recovering: false,
+                restartRecommended: false,
+                staleRunCount: 0,
+            });
+        }
+        finally {
+            nowSpy.mockRestore();
+            await controller.stop();
+        }
+    });
+    it("replays the real terminal event for a run that completes while disconnected, instead of a generic delivery_lost session_error", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        let resolveRun;
+        mocks.agentRun.mockReturnValue(new Promise((resolve) => {
+            resolveRun = () => resolve();
+        }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-completes-offline",
+                content: "Finish while offline",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-completes-offline" } },
+            ])), { timeout: 5_000 });
+            const presenter = mocks.coreAgentConstructor.mock.calls.at(-1)?.[0];
+            // Socket drops mid-run.
+            socket.connected = false;
+            socket.emit("disconnect", "transport close");
+            socket.outbound.length = 0;
+            // The CLI keeps working locally and actually finishes while the socket is down — this is
+            // the real event the fix must preserve instead of discarding it for a generic error.
+            presenter.onAssistantText("final answer produced while offline");
+            presenter.onComplete({ success: true, summary: "done offline" });
+            resolveRun?.();
+            await Promise.resolve();
+            await Promise.resolve();
+            // While still disconnected, no agent.event for this run should have gone out over the
+            // (dead) socket — the real events must be buffered, not fired into the void.
+            expect(socket.outbound.filter((item) => item.event === "agent.event" &&
+                item.payload.runId === "run-completes-offline")).toHaveLength(0);
+            // Reconnect.
+            socket.connected = true;
+            socket.emit("connect");
+            await vi.waitFor(() => {
+                const replayed = socket.outbound.filter((item) => item.event === "agent.event" &&
+                    item.payload.runId === "run-completes-offline");
+                expect(replayed).toHaveLength(3);
+            });
+            const events = socket.outbound.filter((item) => item.event === "agent.event");
+            const eventsForRun = events.filter((item) => item.payload.runId === "run-completes-offline");
+            // The real buffered events replay in order...
+            expect(eventsForRun.map((item) => item.payload.event.type)).toEqual([
+                "text",
+                "agent_run_finished",
+                "query_complete",
+            ]);
+            // ...and no generic delivery_lost session_error is sent for this run, since the daemon
+            // already knows — and told the server — how it actually ended.
+            expect(eventsForRun.some((item) => item.payload.event.type === "session_error" &&
+                item.payload.event.error?.includes("delivery was lost"))).toBe(false);
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("does NOT emit delivery_lost for a run still executing in the daemon after reconnect (issue #3)", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        let resolveRun;
+        mocks.agentRun.mockReturnValue(new Promise((resolve) => {
+            resolveRun = () => resolve();
+        }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("connect");
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-still-in-flight",
+                content: "Quiet build still running",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-still-in-flight" } },
+            ])), { timeout: 5_000 });
+            const presenter = mocks.coreAgentConstructor.mock.calls.at(-1)?.[0];
+            // Socket drops during a quiet stretch; the run keeps executing locally.
+            socket.connected = false;
+            socket.emit("disconnect", "transport close");
+            socket.outbound.length = 0;
+            // Reconnect while the run is still in-flight (never resolved). The daemon
+            // still holds it in activeAgents, so a synthetic delivery_lost here would
+            // fail a live run and wipe the API accumulator mid-turn — it must not fire.
+            socket.connected = true;
+            socket.emit("connect");
+            await Promise.resolve();
+            await Promise.resolve();
+            const deliveryLost = socket.outbound.filter((item) => item.event === "agent.event" &&
+                item.payload.runId === "run-still-in-flight" &&
+                item.payload.event?.type ===
+                    "session_error");
+            expect(deliveryLost).toHaveLength(0);
+            // The rest of the turn keeps streaming live and IS relayed (not discarded).
+            presenter.onAssistantText("output after reconnect");
+            resolveRun?.();
+            await vi.waitFor(() => expect(socket.outbound.some((item) => item.event === "agent.event" &&
+                item.payload.runId === "run-still-in-flight" &&
+                item.payload.event?.type === "text")).toBe(true));
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    describe("flushPendingDeliveryLostEvents (issue #3)", () => {
+        function makeHarness() {
+            const enqueued = [];
+            const terminalRunIds = new Set();
+            const eventOutbox = {
+                flush: vi.fn(),
+                hasTerminalEvent: (runId) => terminalRunIds.has(runId),
+                enqueue: (conversationId, runId, event) => enqueued.push({ conversationId, runId, event }),
+            };
+            const socket = { connected: true };
+            return { enqueued, terminalRunIds, eventOutbox, socket, pushLog: vi.fn() };
+        }
+        it("skips runs still active in the daemon and restores their stage", async () => {
+            const { flushPendingDeliveryLostEvents } = await import("../daemon.js");
+            const h = makeHarness();
+            const entry = { stage: "delivery_lost" };
+            const activeAgents = new Map([["run-alive", entry]]);
+            const pending = [{ conversationId: "conv-1", runId: "run-alive" }];
+            flushPendingDeliveryLostEvents({
+                socket: h.socket,
+                activeAgents,
+                pending,
+                eventOutbox: h.eventOutbox,
+                pushLog: h.pushLog,
+            });
+            expect(h.enqueued).toHaveLength(0);
+            // Stage restored so a later disconnect re-tracks the still-live run.
+            expect(entry.stage).toBe("running");
+            expect(pending).toHaveLength(0);
+        });
+        it("emits delivery_lost only for a run the daemon no longer has active and has no terminal", async () => {
+            const { flushPendingDeliveryLostEvents } = await import("../daemon.js");
+            const h = makeHarness();
+            const activeAgents = new Map();
+            const pending = [{ conversationId: "conv-2", runId: "run-gone" }];
+            flushPendingDeliveryLostEvents({
+                socket: h.socket,
+                activeAgents,
+                pending,
+                eventOutbox: h.eventOutbox,
+                pushLog: h.pushLog,
+            });
+            expect(h.enqueued.map((entry) => entry.event.type)).toEqual([
+                "application_problem",
+                "agent_run_finished",
+                "query_complete",
+            ]);
+            expect(h.enqueued[0]?.event).toMatchObject({
+                type: "application_problem",
+                problem: {
+                    domain: "application",
+                    code: "app.transport.disconnected",
+                },
+            });
+            expect(h.enqueued[1]?.event).toMatchObject({
+                type: "agent_run_finished",
+                failureDomain: "application",
+                causeProblemId: expect.any(String),
+            });
+            expect((h.enqueued[1]?.event).causeProblemId).toBe((h.enqueued[0]?.event).problem.id);
+        });
+        it("skips a run whose real terminal event was buffered", async () => {
+            const { flushPendingDeliveryLostEvents } = await import("../daemon.js");
+            const h = makeHarness();
+            h.terminalRunIds.add("run-finished");
+            const activeAgents = new Map();
+            const pending = [{ conversationId: "conv-3", runId: "run-finished" }];
+            flushPendingDeliveryLostEvents({
+                socket: h.socket,
+                activeAgents,
+                pending,
+                eventOutbox: h.eventOutbox,
+                pushLog: h.pushLog,
+            });
+            expect(h.enqueued).toHaveLength(0);
+        });
+    });
+    it("POST /shutdown stops the daemon and notifies whenExternallyStopped", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        const onStopped = vi.fn();
+        controller.whenExternallyStopped = onStopped;
+        const baseUrl = `http://127.0.0.1:${controller.localApiPort}`;
+        const headers = { authorization: `Bearer ${controller.localApiToken}` };
+        const shutdown = await fetch(`${baseUrl}/shutdown`, { method: "POST", headers }).then((res) => res.json());
+        expect(shutdown).toEqual({ ok: true });
+        await vi.waitFor(() => expect(onStopped).toHaveBeenCalled());
+        expect(socket.disconnected).toBe(true);
+    });
+    it("stopDaemon calls POST /shutdown on a running local daemon", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        const { startDaemon, stopDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: controller.runtimeId,
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiPort: controller.localApiPort,
+            localApiToken: controller.localApiToken,
+        }));
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        await stopDaemon([]);
+        expect(info).toHaveBeenCalledWith("[alan-agent] Daemon stopped", expect.objectContaining({
+            port: controller.localApiPort,
+        }));
+        await vi.waitFor(() => expect(socket.disconnected).toBe(true));
+    });
+    it("stopDaemon reports when no daemon is listening", async () => {
+        const freePort = await new Promise((resolve, reject) => {
+            const server = createServer();
+            server.listen(0, "127.0.0.1", () => {
+                const address = server.address();
+                const port = typeof address === "object" && address ? address.port : 0;
+                server.close((error) => (error ? reject(error) : resolve(port)));
+            });
+        });
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            wsUrl: "ws://ws.test",
+            localApiPort: freePort,
+            localApiToken: "local-secret",
+        }));
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { stopDaemon } = await import("../daemon.js");
+        await stopDaemon(["--local-api-port", String(freePort)]);
+        expect(info).toHaveBeenCalledWith("[alan-agent] No daemon listening", { port: freePort });
+    });
+    it("forwards browser tool responses to the active CoreAgent", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "conversation-1",
+                runId: "run-interactive",
+                content: "Wait for user input",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-interactive" } },
+            ])), { timeout: 5_000 });
+            socket.emit("agent.tool_response", {
+                runId: "run-interactive",
+                toolId: "tool-1",
+                response: "Approved",
+            });
+            expect(mocks.sendToolResponse).toHaveBeenCalledWith("tool-1", "Approved");
+            socket.emit("agent.tool_response", {
+                runId: "missing-run",
+                toolId: "missing-tool",
+                response: "Ignored",
+            });
+            const logs = await fetch(`http://127.0.0.1:${controller.localApiPort}/logs`, {
+                headers: { authorization: `Bearer ${controller.localApiToken}` },
+            }).then((res) => res.json());
+            expect(logs.lines.some((line) => line.includes("tool_response missed tool=missing-tool"))).toBe(true);
+            // A missed delivery must surface to the conversation as an error event,
+            // not just a daemon log line — otherwise the run hangs silently until a
+            // timeout while the user believes their answer was received.
+            const missedErrorEvent = socket.outbound.find((entry) => entry.event === "agent.event" &&
+                entry.payload?.event?.type ===
+                    "error" &&
+                entry.payload?.event?.message?.includes("could not be delivered"));
+            expect(missedErrorEvent).toBeDefined();
+            expect(missedErrorEvent?.payload?.conversationId).toBe("conversation-1");
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("scopes a browser tool_response to the matching conversation instead of fanning out", async () => {
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        mocks.spawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        // Give each CoreAgent instance its own sendToolResponse so we can see which run
+        // received the answer. Construction order matches agent.execute order below.
+        const instanceSends = [];
+        mocks.coreAgentConstructor.mockImplementation(function MockCoreAgent(_presenter, runtime) {
+            const sendToolResponse = vi.fn().mockReturnValue(true);
+            instanceSends.push(sendToolResponse);
+            return {
+                run: (...args) => {
+                    runtime?.onProviderSpawned?.(process.pid);
+                    return mocks.agentRun(...args);
+                },
+                kill: mocks.agentKill,
+                sendToolResponse,
+            };
+        });
+        const { startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon([
+            "--runtime-id",
+            "11111111-1111-4111-8111-111111111111",
+            "--token",
+            "alan_runtime_secret",
+            "--ws-url",
+            "ws://ws.test",
+            "--local-api-port",
+            "0",
+        ]);
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "conversation-a",
+                runId: "run-a",
+                content: "Run A",
+            });
+            socket.emit("agent.execute", {
+                conversationId: "conversation-b",
+                runId: "run-b",
+                content: "Run B",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                { event: "agent.accepted", payload: { runId: "run-a" } },
+                { event: "agent.accepted", payload: { runId: "run-b" } },
+            ])), { timeout: 5_000 });
+            expect(instanceSends).toHaveLength(2);
+            const [sendA, sendB] = instanceSends;
+            // Answer for conversation B, no runId (legacy runtime payload shape).
+            socket.emit("agent.tool_response", {
+                conversationId: "conversation-b",
+                toolId: "tool-b",
+                response: "Approved",
+            });
+            // Only B's agent receives it — A must not be touched.
+            expect(sendB).toHaveBeenCalledWith("tool-b", "Approved");
+            expect(sendA).not.toHaveBeenCalled();
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("logout removes only Alan-owned local credential artifacts without logging secrets", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "old_runtime_secret",
+        }));
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ runtimeToken: "new_runtime_secret" }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { rotateRuntimeToken, logoutDaemon } = await import("../daemon.js");
+        await rotateRuntimeToken(["--token", "alan_pat_secret"]);
+        expect(fetchMock).toHaveBeenCalledWith("http://api.test/public/runtimes/11111111-1111-4111-8111-111111111111/tokens/rotate", expect.objectContaining({
+            method: "POST",
+            headers: { authorization: "Bearer alan_pat_secret" },
+        }));
+        expect(JSON.parse(readFileSync(configPath, "utf8")).runtimeToken).toBe("new_runtime_secret");
+        const ownedArtifacts = [
+            `${configPath}.pending`,
+            `${configPath}.last-known-good`,
+            `${configPath}.setup-pending`,
+            `${configPath}.device-auth-pending`,
+            `${configPath}.device-auth-operation.json`,
+            `${configPath}.event-outbox.enc`,
+            `${configPath}.run-journal.json`,
+            `${configPath}.run-journal.json.pending`,
+            `${configPath}.pending-123-abcdef123456`,
+            `${configPath}.device-auth-pending.pending-123-abcdef123456`,
+            `${configPath}.device-auth-operation.json.pending-123-abcdef123456`,
+            `${configPath}.device-auth-operation.json.release-123-abcdef123456`,
+            `${configPath}.device-auth-operation.json.corrupt-123-abcdef123456`,
+            `${configPath}.maintenance-lease.json.release-123-abcdef123456`,
+            `${configPath}.event-outbox.enc.pending-123-abcdef123456`,
+        ];
+        for (const artifact of ownedArtifacts)
+            writeFileSync(artifact, "alan-owned", { mode: 0o600 });
+        const thirdPartyConfig = join(tempDir, ".claude.json");
+        const userOwnedSimilarName = `${configPath}.pending-user-owned`;
+        writeFileSync(thirdPartyConfig, JSON.stringify({ userOwned: true }));
+        writeFileSync(userOwnedSimilarName, "keep me");
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        await logoutDaemon();
+        expect(() => readFileSync(configPath, "utf8")).toThrow();
+        for (const artifact of ownedArtifacts)
+            expect(existsSync(artifact)).toBe(false);
+        expect(readFileSync(thirdPartyConfig, "utf8")).toContain("userOwned");
+        expect(readFileSync(userOwnedSimilarName, "utf8")).toBe("keep me");
+        expect(JSON.stringify(info.mock.calls)).not.toContain("new_runtime_secret");
+        expect(JSON.stringify(info.mock.calls)).not.toContain("alan_pat_secret");
+    });
+    it("defers logout while a run is active and fences new dispatches", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "runtime-secret-must-not-leak",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret-that-is-long-enough-for-tests",
+        }));
+        mocks.agentRun.mockReturnValue(new Promise(() => { }));
+        const socket = new TestSocket();
+        mocks.io.mockReturnValue(socket);
+        const { logoutDaemon, readLocalDaemonMaintenanceLease, startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        writeFileSync(configPath, JSON.stringify({
+            ...JSON.parse(readFileSync(configPath, "utf8")),
+            localApiPort: controller.localApiPort,
+        }));
+        try {
+            socket.emit("agent.execute", {
+                conversationId: "22222222-2222-4222-8222-222222222222",
+                runId: "33333333-3333-4333-8333-333333333333",
+                content: "Keep working",
+            });
+            await vi.waitFor(() => expect(mocks.agentRun).toHaveBeenCalledTimes(1));
+            const error = (await logoutDaemon([]).catch((caught) => caught));
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain("deferred while 1 active run");
+            expect(error.message).not.toContain("runtime-secret-must-not-leak");
+            expect(existsSync(configPath)).toBe(true);
+            expect(readLocalDaemonMaintenanceLease(configPath, Date.now() + 24 * 60 * 60_000)).toMatchObject({
+                reason: "credential_cleanup",
+            });
+            const drainingStatus = await fetch(`http://127.0.0.1:${controller.localApiPort}/status`, {
+                headers: { authorization: `Bearer ${controller.localApiToken}` },
+            }).then((response) => response.json());
+            expect(drainingStatus).toMatchObject({
+                acceptingRuns: false,
+                runnerStatus: expect.objectContaining({
+                    acceptingRuns: false,
+                    primaryMessage: "This computer is finishing logout.",
+                }),
+            });
+            socket.emit("agent.execute", {
+                conversationId: "44444444-4444-4444-8444-444444444444",
+                runId: "55555555-5555-4555-8555-555555555555",
+                content: "Do not start",
+            });
+            await vi.waitFor(() => expect(socket.outbound).toEqual(expect.arrayContaining([
+                {
+                    event: "agent.rejected",
+                    payload: expect.objectContaining({
+                        runId: "55555555-5555-4555-8555-555555555555",
+                        code: "runtime_logout_pending",
+                    }),
+                },
+            ])));
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("stops an idle daemon before removing its in-memory credentials", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "runtime-secret",
+            wsUrl: "ws://ws.test",
+            localApiToken: "local-secret-that-is-long-enough-for-tests",
+        }));
+        mocks.io.mockReturnValue(new TestSocket());
+        const { logoutDaemon, startDaemon } = await import("../daemon.js");
+        const controller = await startDaemon(["--local-api-port", "0"]);
+        writeFileSync(configPath, JSON.stringify({
+            ...JSON.parse(readFileSync(configPath, "utf8")),
+            localApiPort: controller.localApiPort,
+        }));
+        try {
+            await logoutDaemon([]);
+            expect(existsSync(configPath)).toBe(false);
+        }
+        finally {
+            await controller.stop();
+        }
+    });
+    it("doctor --sync pushes sanitized capabilities using the runtime token", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+        }));
+        const binDir = seedCliBinaries(tempDir);
+        process.env.PATH = binDir;
+        mocks.spawnSync.mockImplementation((command) => {
+            if (command.includes("codex"))
+                return { status: 0, stdout: "codex 1.2.3\n", stderr: "" };
+            if (command.includes("git"))
+                return { status: 0, stdout: "git version 2.50.0\n", stderr: "" };
+            return { status: 1, stdout: "", stderr: "not found" };
+        });
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                capabilities: {
+                    agents: [{ provider: "codex", available: true, version: "codex 1.2.3" }],
+                    hasGit: true,
+                },
+            }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { printDoctor } = await import("../daemon.js");
+        await printDoctor(["--sync"]);
+        expect(fetchMock).toHaveBeenCalledWith("http://api.test/public/runtimes/11111111-1111-4111-8111-111111111111/capabilities/self", expect.objectContaining({
+            method: "PATCH",
+            headers: {
+                authorization: "Bearer alan_runtime_secret",
+                "content-type": "application/json",
+            },
+        }));
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(JSON.stringify(body.capabilities)).not.toContain("/Users/");
+        expect(body.metadata).toEqual(expect.objectContaining({
+            platform: expect.any(String),
+            arch: expect.any(String),
+            agentVersion: expect.any(String),
+            memoryBytes: expect.any(Number),
+        }));
+        expect(JSON.parse(info.mock.calls.at(-1)[0])).toMatchObject({ synced: true });
+    });
+    it("status explains durable runtime config separately from ephemeral sessions", async () => {
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { printStatus } = await import("../daemon.js");
+        await printStatus();
+        expect(JSON.parse(info.mock.calls.at(-1)[0])).toMatchObject({
+            mode: "runtime",
+            configured: false,
+            localDaemonRunning: false,
+            apiUrl: null,
+            wsUrl: null,
+            note: expect.stringContaining("Cloud sandbox sessions are launched by Alan"),
+            warnings: [],
+        });
+    });
+    it("removes legacy tenant pointers whenever durable runtime config is read", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+            teamId: "legacy-team",
+            organizationId: "legacy-org",
+        }));
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        const { printStatus } = await import("../daemon.js");
+        await printStatus();
+        expect(JSON.parse(readFileSync(configPath, "utf8"))).toEqual({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "alan_runtime_secret",
+        });
+        expect(JSON.parse(info.mock.calls.at(-1)[0])).toMatchObject({ configured: true });
+    });
+    it("resolves the runtime config path at call time", async () => {
+        const { printStatus } = await import("../daemon.js");
+        const alternateConfigPath = join(tempDir, "alternate-config.json");
+        writeFileSync(alternateConfigPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            endpointProfile: "custom",
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            runtimeToken: "alan_runtime_secret",
+        }));
+        process.env.ALAN_AGENT_CONFIG_PATH = alternateConfigPath;
+        const info = vi.spyOn(console, "info").mockImplementation(() => { });
+        await printStatus();
+        expect(JSON.parse(info.mock.calls.at(-1)[0])).toMatchObject({
+            configured: true,
+            runtimeId: "22222222-2222-4222-8222-222222222222",
+            configPath: alternateConfigPath,
+            localDaemonRunning: false,
+        });
+    });
+    it("token revoke revokes server-side tokens and removes local runtime config", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "old_runtime_secret",
+        }));
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ ok: true }),
+        });
+        vi.stubGlobal("fetch", fetchMock);
+        const { revokeRuntimeToken } = await import("../daemon.js");
+        await revokeRuntimeToken(["--token", "alan_pat_secret"]);
+        expect(fetchMock).toHaveBeenCalledWith("http://api.test/public/runtimes/11111111-1111-4111-8111-111111111111/tokens/revoke", expect.objectContaining({
+            method: "POST",
+            headers: { authorization: "Bearer alan_pat_secret" },
+        }));
+        expect(() => readFileSync(configPath, "utf8")).toThrow();
+    });
+    it("keeps credentials and redacts the response body when token revoke fails", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "old_runtime_secret",
+        }));
+        vi.stubGlobal("fetch", vi
+            .fn()
+            .mockRejectedValueOnce(new Error("daemon absent"))
+            .mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            text: async () => "alan_pat_secret old_runtime_secret",
+        }));
+        const { revokeRuntimeToken } = await import("../daemon.js");
+        const error = (await revokeRuntimeToken(["--token", "alan_pat_secret"]).catch((caught) => caught));
+        expect(error.message).toBe("runtime token revoke failed: HTTP 500");
+        expect(error.message).not.toContain("alan_pat_secret");
+        expect(error.message).not.toContain("old_runtime_secret");
+        expect(JSON.parse(readFileSync(configPath, "utf8")).runtimeToken).toBe("old_runtime_secret");
+    });
+    it("does not overwrite the runtime token when token rotation fails", async () => {
+        writeFileSync(configPath, JSON.stringify({
+            apiUrl: "http://api.test",
+            wsUrl: "ws://ws.test",
+            runtimeId: "11111111-1111-4111-8111-111111111111",
+            runtimeToken: "old_runtime_secret",
+        }));
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+            ok: false,
+            status: 500,
+            text: async () => "alan_pat_secret old_runtime_secret",
+        }));
+        const { rotateRuntimeToken } = await import("../daemon.js");
+        await expect(rotateRuntimeToken(["--token", "alan_pat_secret"])).rejects.toThrow("runtime token rotation failed: HTTP 500");
+        expect(JSON.parse(readFileSync(configPath, "utf8")).runtimeToken).toBe("old_runtime_secret");
+    });
+});
+//# sourceMappingURL=daemon.test.js.map