@aiden-ade/sandbox-agent 0.1.60 → 0.1.62

package/dist/daemon.js

@@ -1,4711 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statfsSync, statSync, writeFileSync, } from "node:fs";
-import http from "node:http";
-import { arch, cpus, freemem, homedir, hostname, platform, release, totalmem } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { classifyCliErrorDetailed, createCliProblem } from "@alan-ai/agent-core";
-import { createAlanProblem } from "@alan-ai/shared/agent";
-import { isAlanDefaultWorkspace } from "@alan-ai/shared/constants";
-import { resolveAlanDefaultWorkspacePath } from "@alan-ai/shared/node/local-workspace";
-import { collectLocalAgentProviderLimits, } from "@alan-ai/shared/node/provider-limits";
-import { countNonStaleActiveRuns, deriveAcceptingRuns, isComputerReady, pickPrimaryReadinessIssue, RUNNER_RECOVERY_GRACE_MS, RUNNER_STATUS_MAX_SUPPORTED_PROTOCOL_VERSION, RUNNER_STATUS_MIN_SUPPORTED_PROTOCOL_VERSION, RUNNER_STATUS_PROTOCOL_VERSION, SYSTEM_ABORT_RUN_ERRORS, } from "@alan-ai/shared/runtime-runner-status";
-import { io } from "socket.io-client";
-import { BindingSwitchGitError, executeBindingSwitchGitRpc, isBindingSwitchGitMethod, } from "./binding-switch-git.js";
-import { canInstallProviderCli, ensureProviderCliInstalled } from "./cli-ensure-install.js";
-import { DISCOVERABLE_PROVIDER_KINDS, getDaemonCliEnvironment, resolveBackendRuntimeCommand, resolveCliExecutable, resolveProviderCliCommand, revalidateBackendRuntimeCommand, runCliVersionProbeAsync, } from "./cli-executable.js";
-import { buildComputerReadiness, inspectWorkspaceReadiness, WorkspaceAccessTracker, } from "./computer-readiness.js";
-import { CoreAgent } from "./core-agent.js";
-import { EncryptedEventOutbox, isBackgroundHeartbeat } from "./event-outbox.js";
-import { extractBrowserMediaPathHints, extractGeneratedImagesFromToolResult, extractSessionMediaFromToolResult, } from "./generated-images.js";
-import { scanLocalSkillsCached } from "./local-skill-scan.js";
-import { applyMigrationStash, preflightGitTree, preflightWorkspaceMigration, resolveDirtyTree, } from "./local-workspace-migration.js";
-import { prepareAlanMcpForRun } from "./mcp-readiness.js";
-import { unregisterAlanMcp } from "./mcp-registration.js";
-import { runRuntimeModelScan } from "./model-scan-runner.js";
-import { classifyTransportFailure } from "./network-diagnostics.js";
-import { ObservableMap } from "./observable-map.js";
-import { invalidateProviderAuthPreflight, looksLikeProviderAuthFailure, preflightProviderAuth, } from "./provider-auth-preflight.js";
-import { discoverProviderModels, supportsProviderModelDiscovery, } from "./provider-model-discovery.js";
-import { RuntimeRunJournal } from "./run-journal.js";
-import { RunStartGate } from "./run-start-gate.js";
-import { SleepInhibitor } from "./sleep-inhibitor.js";
-import { SuspensionDetector } from "./suspension-detector.js";
-// Re-exported so embedding apps (the Electron desktop) can contribute a
-// platform backend — notably Electron's `powerSaveBlocker`, which is the only
-// sleep-prevention mechanism reachable from Node on Windows.
-export { registerSleepInhibitorBackend, SLEEP_PREVENTION_DISABLED_ENV, } from "./sleep-inhibitor.js";
-import { buildModelsScanMetadata, setConnectedRuntimeSocket } from "./runtime-capabilities-sync.js";
-import { bindAgentConfigPathFromArgs, resolveAgentConfigPath, resolveEndpointProfileFromArgs, sanitizeAgentConfig, } from "./runtime-config.js";
-import { AGENT_VERSION } from "./version.js";
-import { discoverRelocatedWorkspace, workspaceMatchesExpectedRepositories, } from "./workspace-relocation.js";
-import { applyLeaseCheckResult, FRESH_LEASE_MONITOR_STATE, isLeaseCheckDue, WORKSPACE_LEASE_CHECK_INTERVAL_MS, WorkspaceRunLease, } from "./workspace-run-lease.js";
-const STAGING_API_URL = process.env.ALAN_STAGING_API_URL ?? "https://staging-api.tryalan.ai";
-const STAGING_WS_URL = process.env.ALAN_STAGING_WS_URL ?? "wss://alan-staging-ws.tryalan.ai";
-const PRODUCTION_API_URL = "https://api.tryalan.ai";
-const PRODUCTION_WS_URL = "wss://ws.tryalan.ai";
-const LOCAL_API_URL = "http://localhost:8400";
-const LOCAL_WS_URL = "ws://localhost:8401";
-function requiredString(params, key) {
-    const value = params[key];
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`${key} is required`);
-    }
-    return value;
-}
-const DIRTY_WORKSPACE_ACTIONS = new Set([
-    "move_via_stash",
-    "commit_wip",
-    "discard",
-    "leave",
-]);
-function parseDirtyWorkspaceResolution(value) {
-    if (value === undefined)
-        return undefined;
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("dirtyResolution must be an object");
-    }
-    const raw = value;
-    const parseAction = (key) => {
-        const action = raw[key];
-        if (action === undefined)
-            return undefined;
-        if (typeof action !== "string" ||
-            !DIRTY_WORKSPACE_ACTIONS.has(action)) {
-            throw new Error(`${key} is not a supported dirty workspace action`);
-        }
-        return action;
-    };
-    return {
-        sourceAction: parseAction("sourceAction"),
-        destinationAction: parseAction("destinationAction"),
-        sourceCommitMessage: typeof raw.sourceCommitMessage === "string" ? raw.sourceCommitMessage : undefined,
-        destinationCommitMessage: typeof raw.destinationCommitMessage === "string" ? raw.destinationCommitMessage : undefined,
-        confirmDiscard: raw.confirmDiscard === true,
-    };
-}
-function assertValidGitRef(ref, label) {
-    if (!ref || ref.startsWith("-") || ref.includes("\0")) {
-        throw new Error(`${label} is not a safe git ref`);
-    }
-    const result = spawnSync("git", ["check-ref-format", "--branch", ref], {
-        env: getDaemonCliEnvironment(),
-        encoding: "utf8",
-    });
-    if (result.status !== 0)
-        throw new Error(`${label} is not a valid git ref`);
-}
-function isPathContained(childPath, parentPath) {
-    const rel = relative(resolve(parentPath), resolve(childPath));
-    return rel === "" || (!isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`));
-}
-function assertPathContained(childPath, parentPath, label) {
-    if (!isPathContained(childPath, parentPath)) {
-        throw new Error(`${label} escapes allowed directory`);
-    }
-}
-function git(cwd, args) {
-    const result = spawnSync("git", args, {
-        cwd,
-        env: getDaemonCliEnvironment(),
-        encoding: "utf8",
-        maxBuffer: 10 * 1024 * 1024,
-    });
-    if (result.status !== 0) {
-        throw new Error((result.stderr || result.stdout || "git command failed").trim());
-    }
-    return result.stdout.trim();
-}
-function gitSafe(cwd, args) {
-    try {
-        return git(cwd, args);
-    }
-    catch {
-        return "";
-    }
-}
-function worktreeDir(projectPath) {
-    const resolved = resolve(projectPath);
-    return join(dirname(resolved), `${basename(resolved)}-alan-worktrees`);
-}
-function hasAlanWorktreeAncestor(targetPath) {
-    let cursor = resolve(targetPath);
-    while (true) {
-        if (basename(cursor).endsWith("-alan-worktrees"))
-            return true;
-        const parent = dirname(cursor);
-        if (parent === cursor)
-            return false;
-        cursor = parent;
-    }
-}
-function pathSegment(value) {
-    return (value
-        .toLowerCase()
-        .replace(/^alan\//, "")
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 64) || "task");
-}
-function repoName(repoUrl, localPath) {
-    return (repoUrl
-        .replace(/\.git$/, "")
-        .split("/")
-        .pop() ||
-        basename(localPath) ||
-        "repo");
-}
-function findWorktreeByBranch(repoPath, branchName) {
-    const output = gitSafe(repoPath, ["worktree", "list", "--porcelain"]);
-    const entries = output ? output.split("\n\n") : [];
-    for (const entry of entries) {
-        const lines = entry.split("\n");
-        const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
-        const branch = lines
-            .find((line) => line.startsWith("branch "))
-            ?.slice("branch ".length)
-            .replace("refs/heads/", "");
-        if (path && branch === branchName)
-            return path;
-    }
-    return null;
-}
-function ensureGitWorktree(input) {
-    assertValidGitRef(input.branchName, "branchName");
-    assertValidGitRef(input.baseBranch, "baseBranch");
-    const repoPath = resolve(input.repoPath);
-    const root = input.allowedRoot ?? worktreeDir(repoPath);
-    const existingPath = findWorktreeByBranch(input.repoPath, input.branchName);
-    if (existingPath) {
-        if (resolve(existingPath) === repoPath) {
-            throw new Error(`${input.branchName} is checked out in the shared checkout`);
-        }
-        return existingPath;
-    }
-    assertPathContained(input.worktreePath, root, "worktreePath");
-    mkdirSync(dirname(input.worktreePath), { recursive: true });
-    if (!gitSafe(input.repoPath, ["branch", "--list", input.branchName])) {
-        git(input.repoPath, ["branch", input.branchName, input.baseBranch]);
-    }
-    if (existsSync(input.worktreePath)) {
-        if (gitSafe(input.worktreePath, ["branch", "--show-current"]) === input.branchName) {
-            return input.worktreePath;
-        }
-        throw new Error("worktree path already exists for a different checkout");
-    }
-    git(input.repoPath, ["worktree", "add", input.worktreePath, input.branchName]);
-    return input.worktreePath;
-}
-export function resolveProjectWorktreePaths(projectPath, gitRoot, gitWorktreePath) {
-    const resolvedProjectPath = resolve(projectPath);
-    const resolvedGitRoot = resolve(gitRoot);
-    const projectRelativePath = relative(resolvedGitRoot, resolvedProjectPath);
-    if (projectRelativePath === ".." ||
-        projectRelativePath.startsWith(`..${sep}`) ||
-        isAbsolute(projectRelativePath)) {
-        throw new Error("The selected Project folder is outside its Git repository");
-    }
-    return {
-        repoPath: resolvedGitRoot,
-        projectPath: projectRelativePath
-            ? join(resolve(gitWorktreePath), projectRelativePath)
-            : resolve(gitWorktreePath),
-    };
-}
-export function preflightLocalWorkspaceMigration(params) {
-    const direction = params.direction;
-    if (direction !== "to-checkout" && direction !== "to-worktree") {
-        throw new Error("direction must be to-checkout or to-worktree");
-    }
-    const targets = Array.isArray(params.targets)
-        ? params.targets
-        : [];
-    if (targets.length !== 1) {
-        throw new Error("Dirty workspace migration currently supports exactly one repository");
-    }
-    const rawTarget = targets[0];
-    const projectPath = resolve(requiredString(rawTarget, "projectPath"));
-    const projectRootOutput = gitSafe(projectPath, ["rev-parse", "--show-toplevel"]);
-    if (!projectRootOutput) {
-        throw new Error("The selected Project folder is not inside a Git repository");
-    }
-    const projectRoot = resolve(projectRootOutput);
-    if (direction === "to-worktree") {
-        const result = preflightWorkspaceMigration({
-            direction: "checkout_to_worktree",
-            sourcePath: projectRoot,
-        }, git);
-        return {
-            direction,
-            source: result.source,
-            destination: null,
-            requiresResolution: result.source.isDirty,
-        };
-    }
-    const requestedWorktreePath = resolve(requiredString(rawTarget, "worktreePath"));
-    const worktreeRootOutput = gitSafe(requestedWorktreePath, ["rev-parse", "--show-toplevel"]);
-    if (!worktreeRootOutput) {
-        throw new Error("The task worktree is not a registered Git worktree");
-    }
-    const result = preflightWorkspaceMigration({
-        direction: "worktree_to_checkout",
-        sourcePath: resolve(worktreeRootOutput),
-        destinationPath: projectRoot,
-    }, git);
-    return {
-        direction,
-        source: result.source,
-        destination: result.destination,
-        requiresResolution: result.source.isDirty || Boolean(result.destination?.isDirty),
-    };
-}
-/**
- * Read-only git probe for the binding-switch "Current checkout" card. Accepts any
- * checkout root — a task worktree or the shared Project checkout — and reports a
- * dirty *count* only: porcelain paths deliberately never cross the relay.
- */
-export function statusLocalWorkspace(params) {
-    const requestedPath = resolve(requiredString(params, "worktreePath"));
-    const rootOutput = gitSafe(requestedPath, ["rev-parse", "--show-toplevel"]);
-    if (!rootOutput) {
-        throw new Error("The selected folder is not inside a Git repository");
-    }
-    const root = resolve(rootOutput);
-    const tree = preflightGitTree(root, git);
-    const headSha = gitSafe(root, ["rev-parse", "HEAD"]) || null;
-    // `@{upstream}` fails when the branch has no tracking ref; that is a real
-    // answer (hasUpstream: false), not a probe failure.
-    const upstream = gitSafe(root, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
-    const hasUpstream = upstream !== "";
-    let ahead = null;
-    let behind = null;
-    if (hasUpstream) {
-        const counts = gitSafe(root, ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]);
-        const [behindRaw, aheadRaw] = counts.split(/\s+/);
-        const parsedBehind = Number.parseInt(behindRaw ?? "", 10);
-        const parsedAhead = Number.parseInt(aheadRaw ?? "", 10);
-        behind = Number.isNaN(parsedBehind) ? null : parsedBehind;
-        ahead = Number.isNaN(parsedAhead) ? null : parsedAhead;
-    }
-    return {
-        branch: tree.currentBranch,
-        headSha,
-        dirty: tree.isDirty,
-        filesChanged: tree.dirtyFileCount,
-        ahead,
-        behind,
-        hasUpstream,
-    };
-}
-function ensureGitWorktreeWithDirtyResolution(input, resolution) {
-    const repoPath = resolve(input.repoPath);
-    const before = preflightGitTree(repoPath, git);
-    let sourceStash = null;
-    if (before.isDirty) {
-        const action = resolution?.sourceAction;
-        if (!action) {
-            throw new Error(`The Project checkout has ${before.dirtyFileCount} uncommitted file${before.dirtyFileCount === 1 ? "" : "s"}. Choose how to preserve them before moving into a worktree.`);
-        }
-        if (action === "commit_wip" && before.currentBranch !== input.baseBranch) {
-            throw new Error(`Commit as WIP would stay on "${before.currentBranch ?? "the current checkout"}", not the selected base "${input.baseBranch}". Choose Move changes with task instead.`);
-        }
-        const resolved = resolveDirtyTree({
-            cwd: repoPath,
-            action,
-            operation: "checkout-to-worktree",
-            confirmDiscard: resolution?.confirmDiscard,
-        }, { git });
-        sourceStash = resolved.stash;
-    }
-    const existingPath = findWorktreeByBranch(repoPath, input.branchName);
-    const worktreePath = ensureGitWorktree(input);
-    if (!sourceStash)
-        return worktreePath;
-    try {
-        applyMigrationStash({ cwd: worktreePath, stash: sourceStash }, git);
-        return worktreePath;
-    }
-    catch (error) {
-        // The destination was created solely for this migration. Restore it to a
-        // clean state and unregister it so a failed stash apply cannot strand an
-        // untracked dirty worktree. The named stash remains recoverable.
-        if (!existingPath) {
-            gitSafe(worktreePath, ["reset", "--hard", "HEAD"]);
-            gitSafe(worktreePath, ["clean", "-fd"]);
-            gitSafe(repoPath, ["worktree", "remove", worktreePath]);
-            gitSafe(repoPath, ["worktree", "prune"]);
-        }
-        throw error;
-    }
-}
-export function ensureWorktree(params) {
-    const input = {
-        projectPath: requiredString(params, "projectPath"),
-        taskId: requiredString(params, "taskId"),
-        branchName: requiredString(params, "branchName"),
-        baseBranch: typeof params.baseBranch === "string" ? params.baseBranch : undefined,
-        repoLocalPaths: Array.isArray(params.repoLocalPaths)
-            ? params.repoLocalPaths
-            : [],
-        dirtyResolution: parseDirtyWorkspaceResolution(params.dirtyResolution),
-    };
-    if ((input.repoLocalPaths?.length ?? 0) > 1) {
-        throw new Error("A task worktree requires exactly one Git repository.");
-    }
-    if (input.repoLocalPaths?.length) {
-        const taskRoot = join(worktreeDir(input.projectPath), `${pathSegment(input.branchName)}-${input.taskId.slice(0, 8)}`);
-        return {
-            worktrees: input.repoLocalPaths.map((repo) => {
-                const baseBranch = repo.branch || input.baseBranch || "main";
-                const worktreePath = ensureGitWorktreeWithDirtyResolution({
-                    repoPath: repo.localPath,
-                    worktreePath: join(taskRoot, pathSegment(repoName(repo.repoUrl, repo.localPath))),
-                    branchName: input.branchName,
-                    baseBranch,
-                    allowedRoot: worktreeDir(input.projectPath),
-                }, input.dirtyResolution);
-                return {
-                    repoId: repo.repoId ?? null,
-                    repoUrl: repo.repoUrl,
-                    worktreePath,
-                    branchName: input.branchName,
-                    baseBranch,
-                };
-            }),
-            ...(input.dirtyResolution ? { dirtyResolution: input.dirtyResolution } : {}),
-        };
-    }
-    const gitRoot = gitSafe(resolve(input.projectPath), ["rev-parse", "--show-toplevel"]);
-    if (!gitRoot) {
-        throw new Error("The selected Project folder is not inside a Git repository");
-    }
-    const repoPath = resolve(gitRoot);
-    const baseBranch = input.baseBranch || gitSafe(repoPath, ["branch", "--show-current"]) || "HEAD";
-    const taskRoot = join(worktreeDir(repoPath), `${pathSegment(input.branchName)}-${input.taskId.slice(0, 8)}`);
-    resolveProjectWorktreePaths(input.projectPath, repoPath, taskRoot);
-    const worktreePath = ensureGitWorktreeWithDirtyResolution({
-        repoPath,
-        worktreePath: taskRoot,
-        branchName: input.branchName,
-        baseBranch,
-    }, input.dirtyResolution);
-    const projectWorktreePath = resolveProjectWorktreePaths(input.projectPath, repoPath, worktreePath).projectPath;
-    return {
-        worktrees: [
-            {
-                worktreePath: projectWorktreePath,
-                branchName: input.branchName,
-                baseBranch,
-            },
-        ],
-        ...(input.dirtyResolution ? { dirtyResolution: input.dirtyResolution } : {}),
-    };
-}
-function listRegisteredWorktrees(cwd) {
-    return git(cwd, ["worktree", "list", "--porcelain"])
-        .split("\n\n")
-        .flatMap((entry) => {
-        const lines = entry.split("\n");
-        const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
-        if (!path)
-            return [];
-        return [
-            {
-                path: resolve(path),
-                branch: lines
-                    .find((line) => line.startsWith("branch "))
-                    ?.slice("branch ".length)
-                    .replace("refs/heads/", ""),
-            },
-        ];
-    });
-}
-/**
- * Remove stale task worktrees only after every target passes a non-destructive
- * preflight. The server supplies persisted worktree paths; the daemon derives
- * each linked worktree root from Git registration instead of trusting those
- * paths as removal roots.
- *
- * A retry after successful removal is accepted only when the now-missing path
- * is under an Alan-managed worktree directory.
- */
-export function removeWorktreesIfClean(params, removeGit = git) {
-    const projectPath = resolve(requiredString(params, "projectPath"));
-    const targets = Array.isArray(params.targets)
-        ? params.targets
-        : [];
-    if (targets.length === 0)
-        throw new Error("At least one worktree target is required");
-    const projectRootOutput = gitSafe(projectPath, ["rev-parse", "--show-toplevel"]);
-    const projectRoot = projectRootOutput ? resolve(projectRootOutput) : null;
-    const projectRegistrations = projectRoot ? listRegisteredWorktrees(projectRoot) : [];
-    const planned = targets.map((target) => {
-        const rawTarget = target;
-        const requestedPath = resolve(requiredString(rawTarget, "worktreePath"));
-        const branchName = requiredString(rawTarget, "branchName");
-        assertValidGitRef(branchName, "branchName");
-        const registrationSets = [];
-        if (projectRegistrations.length > 0)
-            registrationSets.push(projectRegistrations);
-        if (existsSync(requestedPath)) {
-            const requestedRoot = gitSafe(requestedPath, ["rev-parse", "--show-toplevel"]);
-            if (!requestedRoot) {
-                throw new Error(`The earlier task worktree is not a registered Git worktree: ${requestedPath}`);
-            }
-            const requestedRegistrations = listRegisteredWorktrees(resolve(requestedRoot));
-            if (!registrationSets.some((entries) => entries.length === requestedRegistrations.length &&
-                entries.every((entry, index) => entry.path === requestedRegistrations[index]?.path))) {
-                registrationSets.push(requestedRegistrations);
-            }
-        }
-        for (const registrations of registrationSets) {
-            const mainRoot = registrations[0]?.path;
-            const registeredTarget = registrations.find((entry) => requestedPath === entry.path || isPathContained(requestedPath, entry.path));
-            if (!registeredTarget || !mainRoot)
-                continue;
-            if (registeredTarget.path === mainRoot) {
-                throw new Error("Refusing to remove the Project's main checkout");
-            }
-            if (registeredTarget.branch !== branchName) {
-                throw new Error(`The registered worktree branch changed from "${branchName}" to "${registeredTarget.branch ?? "detached HEAD"}".`);
-            }
-            const allowedRoots = [
-                worktreeDir(mainRoot),
-                worktreeDir(projectPath),
-                ...(projectRoot ? [worktreeDir(projectRoot)] : []),
-            ];
-            if (!allowedRoots.some((root) => isPathContained(registeredTarget.path, root))) {
-                throw new Error("The registered worktree is outside an Alan-managed worktree directory");
-            }
-            if (git(registeredTarget.path, ["status", "--porcelain"]).trim()) {
-                throw new Error(`The earlier task worktree has uncommitted changes at ${requestedPath}. Commit or discard them before changing Project, branch, or worktree mode.`);
-            }
-            return {
-                requestedPath,
-                worktreeRoot: registeredTarget.path,
-                mainRoot,
-                branchName,
-                replayed: false,
-            };
-        }
-        if (!existsSync(requestedPath) && hasAlanWorktreeAncestor(requestedPath)) {
-            return {
-                requestedPath,
-                worktreeRoot: null,
-                mainRoot: null,
-                branchName,
-                replayed: true,
-            };
-        }
-        throw new Error(`The earlier task worktree is not safely registered and was not changed: ${requestedPath}`);
-    });
-    const removalRoots = planned.flatMap((target) => target.worktreeRoot && target.mainRoot
-        ? [{ worktreeRoot: target.worktreeRoot, mainRoot: target.mainRoot }]
-        : []);
-    if (new Set(removalRoots.map(({ worktreeRoot }) => worktreeRoot)).size !== removalRoots.length) {
-        throw new Error("Duplicate worktree targets were not changed");
-    }
-    for (const target of removalRoots) {
-        // Deliberately omit `-f`: Git performs a final clean-tree check at the
-        // mutation boundary and refuses a write racing with our earlier preflight.
-        removeGit(target.mainRoot, ["worktree", "remove", target.worktreeRoot]);
-        gitSafe(target.mainRoot, ["worktree", "prune"]);
-    }
-    return {
-        ok: true,
-        removed: planned.map(({ requestedPath, branchName, replayed }) => ({
-            worktreePath: requestedPath,
-            branchName,
-            replayed,
-        })),
-    };
-}
-/**
- * Move one clean task worktree back to its Project checkout.
- *
- * Paths may point at the Project's configured subdirectory rather than either
- * Git root. The daemon resolves and compares both relative subpaths before
- * mutation. A retry after a successful remove+checkout is idempotent, which
- * lets the API durably persist its prepared receipt after the filesystem move.
- */
-export function migrateWorktreeToCheckout(params, removeGit = git) {
-    const dirtyResolution = parseDirtyWorkspaceResolution(params.dirtyResolution);
-    const targets = Array.isArray(params.targets)
-        ? params.targets
-        : [];
-    if (targets.length !== 1) {
-        throw new Error("Multi-repository worktree migration is not supported; no repositories were changed.");
-    }
-    const target = targets[0];
-    const rawTarget = target;
-    const projectPath = resolve(requiredString(rawTarget, "projectPath"));
-    const requestedWorktreePath = resolve(requiredString(rawTarget, "worktreePath"));
-    const branch = requiredString(rawTarget, "branch");
-    assertValidGitRef(branch, "branch");
-    const projectRootOutput = gitSafe(projectPath, ["rev-parse", "--show-toplevel"]);
-    if (!projectRootOutput) {
-        throw new Error("The selected Project folder is not inside a Git repository");
-    }
-    const projectRoot = resolve(projectRootOutput);
-    const projectRelativePath = relative(projectRoot, projectPath);
-    if (projectRelativePath === ".." ||
-        projectRelativePath.startsWith(`..${sep}`) ||
-        isAbsolute(projectRelativePath)) {
-        throw new Error("The selected Project folder is outside its Git repository");
-    }
-    const registered = git(projectRoot, ["worktree", "list", "--porcelain"])
-        .split("\n\n")
-        .map((entry) => {
-        const lines = entry.split("\n");
-        return {
-            path: lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length),
-            branch: lines
-                .find((line) => line.startsWith("branch "))
-                ?.slice("branch ".length)
-                .replace("refs/heads/", ""),
-        };
-    });
-    const registeredTarget = registered.find(({ path, branch: registeredBranch }) => {
-        if (!path || registeredBranch !== branch)
-            return false;
-        const root = resolve(path);
-        return requestedWorktreePath === root || isPathContained(requestedWorktreePath, root);
-    });
-    const currentBranch = gitSafe(projectRoot, ["branch", "--show-current"]);
-    if (!registeredTarget?.path) {
-        if (currentBranch === branch) {
-            return {
-                ok: true,
-                replayed: true,
-                migrated: [{ ...target, projectPath, worktreePath: requestedWorktreePath, branch }],
-                ...(dirtyResolution ? { dirtyResolution } : {}),
-            };
-        }
-        throw new Error(`The task worktree is no longer registered and the Project is not on branch "${branch}".`);
-    }
-    const worktreeRoot = resolve(registeredTarget.path);
-    const worktreeRelativePath = relative(worktreeRoot, requestedWorktreePath);
-    if (worktreeRelativePath !== projectRelativePath) {
-        throw new Error("The configured Project and task worktree do not point at the same repository subdirectory.");
-    }
-    const allowedRoots = [worktreeDir(projectRoot), worktreeDir(projectPath)];
-    if (!allowedRoots.some((allowedRoot) => isPathContained(worktreeRoot, allowedRoot))) {
-        throw new Error("The task worktree escapes the Project worktree directory.");
-    }
-    if (!existsSync(worktreeRoot)) {
-        throw new Error(`Worktree directory not found: ${worktreeRoot}`);
-    }
-    const sourceBefore = preflightGitTree(worktreeRoot, git);
-    const destinationBefore = preflightGitTree(projectRoot, git);
-    if (sourceBefore.isDirty && !dirtyResolution?.sourceAction) {
-        throw new Error(`The task worktree has ${sourceBefore.dirtyFileCount} uncommitted file${sourceBefore.dirtyFileCount === 1 ? "" : "s"}. Choose how to preserve them before migrating.`);
-    }
-    if (destinationBefore.isDirty && !dirtyResolution?.destinationAction) {
-        throw new Error(`The Project checkout has ${destinationBefore.dirtyFileCount} uncommitted file${destinationBefore.dirtyFileCount === 1 ? "" : "s"}. Choose how to preserve them before migrating.`);
-    }
-    if (sourceBefore.isDirty && dirtyResolution?.sourceAction === "leave") {
-        throw new Error("Task worktree changes cannot be left behind when releasing the worktree.");
-    }
-    if (destinationBefore.isDirty && dirtyResolution?.destinationAction === "leave") {
-        throw new Error("Project checkout changes cannot stay in place while switching branches.");
-    }
-    const destinationResolved = destinationBefore.isDirty
-        ? resolveDirtyTree({
-            cwd: projectRoot,
-            action: dirtyResolution?.destinationAction ?? "leave",
-            operation: "worktree-to-checkout-destination",
-            confirmDiscard: dirtyResolution?.confirmDiscard,
-        }, { git })
-        : null;
-    const sourceResolved = sourceBefore.isDirty
-        ? resolveDirtyTree({
-            cwd: worktreeRoot,
-            action: dirtyResolution?.sourceAction ?? "leave",
-            operation: "worktree-to-checkout-source",
-            confirmDiscard: dirtyResolution?.confirmDiscard,
-        }, { git })
-        : null;
-    try {
-        git(projectRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
-    }
-    catch {
-        throw new Error(`The target branch "${branch}" is not available in the Project.`);
-    }
-    // Git's own clean-tree check is the final guard against writes racing with
-    // the preflight above. Never force a migration removal.
-    removeGit(projectRoot, ["worktree", "remove", worktreeRoot]);
-    gitSafe(projectRoot, ["worktree", "prune"]);
-    try {
-        git(projectRoot, ["checkout", branch]);
-    }
-    catch (checkoutError) {
-        try {
-            git(projectRoot, ["worktree", "add", worktreeRoot, branch]);
-            if (sourceResolved?.stash) {
-                applyMigrationStash({ cwd: worktreeRoot, stash: sourceResolved.stash }, git);
-            }
-            if (destinationResolved?.stash) {
-                applyMigrationStash({ cwd: projectRoot, stash: destinationResolved.stash }, git);
-            }
-        }
-        catch (restoreError) {
-            const checkoutMessage = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
-            const restoreMessage = restoreError instanceof Error ? restoreError.message : String(restoreError);
-            throw new Error(`Project checkout failed (${checkoutMessage}) and the task worktree could not be restored (${restoreMessage}).`);
-        }
-        const checkoutMessage = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
-        throw new Error(`Project checkout failed (${checkoutMessage}); restored the task worktree at ${worktreeRoot}.`);
-    }
-    if (sourceResolved?.stash) {
-        try {
-            applyMigrationStash({ cwd: projectRoot, stash: sourceResolved.stash }, git);
-        }
-        catch (applyError) {
-            // Return to the exact topology we started from. The source stash is
-            // applied back to the restored worktree; a destination stash is applied
-            // back to its original checkout branch. If either restore fails, the
-            // named stash remains recoverable and the error includes its OID.
-            gitSafe(projectRoot, ["reset", "--hard", "HEAD"]);
-            gitSafe(projectRoot, ["clean", "-fd"]);
-            try {
-                if (destinationBefore.currentBranch && destinationBefore.currentBranch !== branch) {
-                    git(projectRoot, ["checkout", destinationBefore.currentBranch]);
-                }
-                git(projectRoot, ["worktree", "add", worktreeRoot, branch]);
-                applyMigrationStash({ cwd: worktreeRoot, stash: sourceResolved.stash }, git);
-                if (destinationResolved?.stash) {
-                    applyMigrationStash({ cwd: projectRoot, stash: destinationResolved.stash }, git);
-                }
-            }
-            catch (restoreError) {
-                const applyMessage = applyError instanceof Error ? applyError.message : String(applyError);
-                const restoreMessage = restoreError instanceof Error ? restoreError.message : String(restoreError);
-                throw new Error(`Moving uncommitted changes failed (${applyMessage}); automatic workspace restoration also failed (${restoreMessage}). The named migration stash was preserved.`);
-            }
-            const applyMessage = applyError instanceof Error ? applyError.message : String(applyError);
-            throw new Error(`Moving uncommitted changes failed (${applyMessage}); the original worktree and checkout were restored.`);
-        }
-    }
-    return {
-        ok: true,
-        replayed: false,
-        migrated: [{ ...target, projectPath, worktreePath: requestedWorktreePath, branch }],
-        ...(dirtyResolution ? { dirtyResolution } : {}),
-    };
-}
-/**
- * Put a shared checkout onto the task's working branch (cut from baseBranch)
- * without creating a worktree. Best-effort and non-destructive: it never
- * touches a dirty tree and never aborts the run — if it cannot switch cleanly
- * the caller logs the reason and the agent runs on the current branch.
- */
-export function ensureSharedCheckoutBranch(input) {
-    assertValidGitRef(input.branchName, "branchName");
-    assertValidGitRef(input.baseBranch, "baseBranch");
-    const repoPath = resolve(input.repoPath);
-    if (gitSafe(repoPath, ["rev-parse", "--is-inside-work-tree"]) !== "true") {
-        return { checkedOut: false, reason: `${repoPath} is not a git work tree` };
-    }
-    // Already on the working branch — nothing to do.
-    if (gitSafe(repoPath, ["branch", "--show-current"]) === input.branchName) {
-        return { checkedOut: true };
-    }
-    // Never discard the user's uncommitted work in a shared checkout.
-    if (gitSafe(repoPath, ["status", "--porcelain"]) !== "") {
-        return { checkedOut: false, reason: "shared checkout has uncommitted changes" };
-    }
-    // Create the branch off the base ref the first time we see it. Resolve the
-    // base locally, falling back to the remote-tracking ref.
-    if (!gitSafe(repoPath, ["branch", "--list", input.branchName])) {
-        const localBase = gitSafe(repoPath, ["rev-parse", "--verify", "--quiet", input.baseBranch]);
-        const remoteBase = localBase
-            ? ""
-            : gitSafe(repoPath, ["rev-parse", "--verify", "--quiet", `origin/${input.baseBranch}`]);
-        const base = localBase ? input.baseBranch : remoteBase ? `origin/${input.baseBranch}` : "";
-        if (!base) {
-            return { checkedOut: false, reason: `base branch ${input.baseBranch} not found` };
-        }
-        git(repoPath, ["branch", input.branchName, base]);
-    }
-    git(repoPath, ["checkout", input.branchName]);
-    return { checkedOut: true };
-}
-export function resolveSharedCheckoutTargets(input) {
-    const fallbackBaseBranch = input.sharedCheckout.baseBranch || "main";
-    if (input.sharedCheckout.repos?.length) {
-        const repos = [];
-        for (const repo of input.sharedCheckout.repos) {
-            if (!repo.repoPath.trim())
-                continue;
-            repos.push({
-                repoPath: repo.repoPath,
-                baseBranch: repo.baseBranch?.trim() || fallbackBaseBranch,
-            });
-        }
-        if (repos.length > 0)
-            return repos;
-    }
-    const repoPaths = input.sharedCheckout.repoPaths && input.sharedCheckout.repoPaths.length > 0
-        ? input.sharedCheckout.repoPaths
-        : [input.cwd];
-    const repos = [];
-    for (const repoPath of repoPaths) {
-        if (!repoPath.trim())
-            continue;
-        repos.push({ repoPath, baseBranch: fallbackBaseBranch });
-    }
-    return repos;
-}
-export function resolveRuntimeCwd(payload) {
-    const multiRepoWorktree = payload.worktreeInfo?.allWorktrees?.[0]?.worktreePath;
-    if (multiRepoWorktree)
-        return dirname(multiRepoWorktree);
-    if (isAlanDefaultWorkspace(payload.projectPath))
-        return resolveAlanDefaultWorkspacePath();
-    return payload.worktreeInfo?.worktreePath ?? payload.projectPath ?? process.cwd();
-}
-function resolveWorkspaceRunLeaseTargets(payload, cwd, hasVerifiedRepository) {
-    if (isAlanDefaultWorkspace(payload.projectPath))
-        return [];
-    const allWorktrees = payload.worktreeInfo?.allWorktrees;
-    if (allWorktrees?.length) {
-        return allWorktrees.map((worktree) => ({
-            workspacePath: worktree.worktreePath,
-            expectedBranch: worktree.branchName,
-        }));
-    }
-    if (payload.worktreeInfo?.worktreePath) {
-        return [
-            {
-                workspacePath: payload.worktreeInfo.worktreePath,
-                expectedBranch: payload.worktreeInfo.branchName,
-            },
-        ];
-    }
-    if (payload.sharedCheckout?.branchName) {
-        return resolveSharedCheckoutTargets({ cwd, sharedCheckout: payload.sharedCheckout }).map(({ repoPath }) => ({
-            workspacePath: repoPath,
-            expectedBranch: payload.sharedCheckout?.branchName,
-        }));
-    }
-    return hasVerifiedRepository ? [{ workspacePath: cwd }] : [];
-}
-function correlationLogFields(input) {
-    return Object.fromEntries(Object.entries({
-        taskId: input.taskId,
-        conversationId: input.conversationId,
-        runId: input.runId,
-        messageId: input.messageId,
-        cloudEnvironmentId: input.cloudEnvironmentId,
-        provider: input.backendKind,
-        backendKind: input.backendKind,
-        agentVersion: input.agentVersion,
-    })
-        .filter((entry) => {
-        const value = entry[1];
-        return typeof value === "string" && value.trim().length > 0;
-    })
-        .map(([key, value]) => [key, value.trim()]));
-}
-export async function runLocalDaemonRecoveryLadder(input) {
-    const healthy = (status) => status.connected === true && !status.recovering && !status.restartRecommended;
-    const waitForRecovery = async () => {
-        const timeoutMs = input.options?.connectTimeoutMs ?? 12_000;
-        const pollMs = input.options?.pollMs ?? 500;
-        const deadline = Date.now() + timeoutMs;
-        let status = await input.getStatus();
-        while (Date.now() < deadline) {
-            if (healthy(status) || input.stopWaiting?.(status))
-                return status;
-            await sleep(pollMs);
-            status = await input.getStatus();
-        }
-        return status;
-    };
-    const needsRestartBusy = (status) => {
-        const count = input.blockingRunCount(status);
-        return {
-            ...status,
-            activeRunCount: count,
-            recoveryCode: "needs_restart_busy",
-            error: `Connection is broken and fixing it will interrupt ${count} active run${count === 1 ? "" : "s"}`,
-        };
-    };
-    let status = input.initialStatus;
-    if (healthy(status) || input.stopWaiting?.(status))
-        return status;
-    if (await input.redial().catch(() => false)) {
-        status = await waitForRecovery();
-        if (healthy(status) || input.stopWaiting?.(status))
-            return status;
-    }
-    if (input.blockingRunCount(status) > 0)
-        return needsRestartBusy(status);
-    try {
-        status = await input.restart();
-    }
-    catch (error) {
-        return {
-            ...status,
-            recoveryCode: "daemon_recovery_failed",
-            error: error instanceof Error ? error.message : "Local daemon restart failed",
-        };
-    }
-    if (healthy(status) || input.stopWaiting?.(status))
-        return status;
-    if (input.blockingRunCount(status) > 0)
-        return needsRestartBusy(status);
-    status = await waitForRecovery();
-    if (healthy(status) || input.stopWaiting?.(status))
-        return status;
-    if (input.blockingRunCount(status) > 0)
-        return needsRestartBusy(status);
-    return {
-        ...status,
-        recoveryCode: "daemon_recovery_failed",
-        error: "The local daemon exhausted its reconnect and safe-restart recovery budget.",
-    };
-}
-const LOCAL_SERVICE_OWNER_VERSION = 1;
-const LOCAL_SERVICE_CHALLENGE_TTL_MS = 5_000;
-function localServiceOwnerPayload(owner) {
-    return [
-        owner.version,
-        owner.serviceId,
-        owner.installationId,
-        owner.runtimeId,
-        owner.port,
-        owner.pid,
-        owner.startedAtMs,
-        owner.challenge,
-    ].join("\0");
-}
-function signLocalServiceOwner(secret, owner) {
-    return createHmac("sha256", secret).update(localServiceOwnerPayload(owner)).digest("hex");
-}
-function signLocalServiceAdoption(secret, serviceId, challenge) {
-    return createHmac("sha256", secret)
-        .update(["adopt", serviceId, challenge].join("\0"))
-        .digest("hex");
-}
-function equalHexDigest(actual, expected) {
-    if (!/^[a-f0-9]{64}$/i.test(actual) || !/^[a-f0-9]{64}$/i.test(expected))
-        return false;
-    return timingSafeEqual(Buffer.from(actual, "hex"), Buffer.from(expected, "hex"));
-}
-function parseLocalServiceOwner(value) {
-    if (!value || typeof value !== "object")
-        return null;
-    const owner = value;
-    if (owner.version !== LOCAL_SERVICE_OWNER_VERSION ||
-        typeof owner.serviceId !== "string" ||
-        typeof owner.installationId !== "string" ||
-        typeof owner.runtimeId !== "string" ||
-        typeof owner.port !== "number" ||
-        typeof owner.pid !== "number" ||
-        typeof owner.startedAtMs !== "number" ||
-        typeof owner.challenge !== "string" ||
-        typeof owner.signature !== "string") {
-        return null;
-    }
-    return owner;
-}
-async function probeLocalDaemonEndpoint(port, token, timeoutMs = 750) {
-    try {
-        const headers = {};
-        if (token)
-            headers.authorization = `Bearer ${token}`;
-        const response = await fetch(`http://127.0.0.1:${port}/status`, {
-            headers,
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (response.status === 401)
-            return { state: "listening_unauthorized" };
-        if (!response.ok)
-            return { state: "absent" };
-        const body = (await response.json());
-        if (!body.runtimeId)
-            return { state: "absent" };
-        return { state: "running", status: body };
-    }
-    catch {
-        return { state: "absent" };
-    }
-}
-export async function probeLocalDaemon(port, token, timeoutMs = 750) {
-    const probe = await probeLocalDaemonEndpoint(port, token, timeoutMs);
-    return probe.state === "running" ? probe.status : null;
-}
-async function adoptLocalDaemonControl(input) {
-    const timeoutMs = input.timeoutMs ?? 750;
-    try {
-        const ownerResponse = await fetch(`http://127.0.0.1:${input.port}/owner`, {
-            headers: { accept: "application/json" },
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!ownerResponse.ok)
-            return null;
-        const owner = parseLocalServiceOwner(await ownerResponse.json());
-        if (!owner ||
-            owner.serviceId !== input.serviceId ||
-            owner.port !== input.port ||
-            (input.installationId && owner.installationId !== input.installationId)) {
-            return null;
-        }
-        const { signature, ...unsignedOwner } = owner;
-        const expectedSignature = signLocalServiceOwner(input.serviceSecret, unsignedOwner);
-        if (!equalHexDigest(signature, expectedSignature))
-            return null;
-        const proof = signLocalServiceAdoption(input.serviceSecret, input.serviceId, owner.challenge);
-        const adoptionResponse = await fetch(`http://127.0.0.1:${input.port}/adopt`, {
-            method: "POST",
-            headers: {
-                accept: "application/json",
-                "x-alan-service-id": input.serviceId,
-                "x-alan-adoption-challenge": owner.challenge,
-                "x-alan-adoption-proof": proof,
-            },
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!adoptionResponse.ok)
-            return null;
-        const adopted = (await adoptionResponse.json());
-        if (typeof adopted.localApiToken !== "string" || adopted.localApiToken.length < 32)
-            return null;
-        const status = await probeLocalDaemon(input.port, adopted.localApiToken, timeoutMs);
-        if (!status || status.runtimeId !== owner.runtimeId)
-            return null;
-        return { localApiToken: adopted.localApiToken, status };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Reclaims local control only when this config proves it owns the incumbent
- * daemon. A process that merely occupies the port cannot trigger replacement
- * or learn the bearer token.
- */
-export async function adoptConfiguredLocalDaemon(args = []) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    const port = getLocalApiPort(args, stored);
-    if (stored.localApiToken) {
-        const existing = await probeLocalDaemon(port, stored.localApiToken);
-        if (existing)
-            return existing;
-    }
-    if (!stored.localServiceId || !stored.localServiceSecret)
-        return null;
-    const adopted = await adoptLocalDaemonControl({
-        port,
-        serviceId: stored.localServiceId,
-        serviceSecret: stored.localServiceSecret,
-        installationId: stored.installationId,
-    });
-    if (!adopted)
-        return null;
-    // Do not overwrite credentials that may have changed while the handshake
-    // was in flight. The owner identity itself must still match.
-    const latest = readConfig();
-    if (latest.localServiceId !== stored.localServiceId ||
-        latest.localServiceSecret !== stored.localServiceSecret) {
-        return null;
-    }
-    writeConfig({ ...latest, localApiPort: port, localApiToken: adopted.localApiToken });
-    return adopted.status;
-}
-export async function isLocalDaemonListening(port, token) {
-    const probe = await probeLocalDaemonEndpoint(port, token);
-    return probe.state !== "absent";
-}
-function describeOccupiedLocalDaemon(port) {
-    return (`local daemon API port ${port} is already in use. ` +
-        "If Alan desktop is open, it manages the daemon automatically. " +
-        "Quit Alan desktop or stop the existing daemon before starting another.");
-}
-/**
- * Last config path bound via bindAgentConfigPathFromArgs. Keeps late/async
- * daemon code on the active profile's config even if the supervisor restores
- * ALAN_AGENT_CONFIG_PATH after startup (the desktop supervisor does).
- */
-let boundAgentConfigPath = null;
-function bindConfigPath(args) {
-    boundAgentConfigPath = bindAgentConfigPathFromArgs(args);
-    return boundAgentConfigPath;
-}
-function getConfigPath() {
-    return (process.env.ALAN_AGENT_CONFIG_PATH ??
-        boundAgentConfigPath ??
-        resolveAgentConfigPath({ profile: "production" }));
-}
-function getEndpointDefaultsPath() {
-    return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? join(dirname(getConfigPath()), "endpoints.json");
-}
-function readConfig() {
-    const configPath = getConfigPath();
-    if (!existsSync(configPath))
-        return {};
-    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
-    const sanitized = sanitizeAgentConfig(parsed);
-    if (Object.keys(parsed).some((key) => !Object.hasOwn(sanitized, key))) {
-        writeConfig(sanitized);
-    }
-    return sanitized;
-}
-function readConfigForRegistration() {
-    try {
-        return readConfig();
-    }
-    catch {
-        // Registration is also the repair path for malformed/unreadable config.
-        return {};
-    }
-}
-function readEndpointDefaults() {
-    const endpointsPath = getEndpointDefaultsPath();
-    if (!existsSync(endpointsPath))
-        return {};
-    try {
-        return JSON.parse(readFileSync(endpointsPath, "utf8"));
-    }
-    catch {
-        return {};
-    }
-}
-function writeConfig(config) {
-    const configPath = getConfigPath();
-    mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
-    const pendingPath = `${configPath}.pending-${process.pid}-${randomBytes(6).toString("hex")}`;
-    try {
-        writeFileSync(pendingPath, JSON.stringify(sanitizeAgentConfig(config), null, 2), { mode: 0o600 });
-        chmodSync(pendingPath, 0o600);
-        renameSync(pendingPath, configPath);
-    }
-    finally {
-        rmSync(pendingPath, { force: true });
-    }
-}
-function maintenanceLeasePath(configPath) {
-    return `${configPath}.maintenance-lease.json`;
-}
-export function readLocalDaemonMaintenanceLease(configPath, nowMs = Date.now()) {
-    const path = maintenanceLeasePath(configPath);
-    if (!existsSync(path))
-        return null;
-    try {
-        const lease = JSON.parse(readFileSync(path, "utf8"));
-        if (lease.version !== 1 ||
-            typeof lease.id !== "string" ||
-            (lease.reason !== "credential_cleanup" &&
-                lease.reason !== "daemon_startup" &&
-                lease.reason !== "watchdog") ||
-            !((lease.reason === "credential_cleanup" && lease.expiresAtMs === null) ||
-                (typeof lease.expiresAtMs === "number" && Number.isFinite(lease.expiresAtMs)))) {
-            throw new Error("invalid maintenance lease");
-        }
-        // Credential cleanup is a durable drain intent, not a watchdog timeout. Old
-        // versions wrote a finite expiry, so ignore it for this reason during
-        // rolling upgrades as well as writing null for all new cleanup leases.
-        if (lease.reason !== "credential_cleanup" && lease.expiresAtMs <= nowMs) {
-            releaseOwnedJsonFile(path, lease.id);
-            return null;
-        }
-        return lease;
-    }
-    catch {
-        // A partial/corrupt lease must fail closed for one short watchdog window,
-        // not fence dispatch forever.
-        const fallback = {
-            version: 1,
-            id: "invalid",
-            reason: "watchdog",
-            expiresAtMs: nowMs + 5_000,
-        };
-        try {
-            writeFileSync(path, JSON.stringify(fallback), { mode: 0o600 });
-            chmodSync(path, 0o600);
-        }
-        catch {
-            // The in-memory fallback still fences this decision safely.
-        }
-        return fallback;
-    }
-}
-export function acquireLocalDaemonMaintenanceLease(configPath, reason, ttlMs = 5_000) {
-    const existing = readLocalDaemonMaintenanceLease(configPath);
-    if (existing)
-        return { acquired: false, lease: existing };
-    const lease = {
-        version: 1,
-        id: randomUUID(),
-        reason,
-        expiresAtMs: reason === "credential_cleanup"
-            ? null
-            : Date.now() + Math.max(1_000, Math.min(ttlMs, 60_000)),
-    };
-    const path = maintenanceLeasePath(configPath);
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    try {
-        writeFileSync(path, JSON.stringify(lease), { mode: 0o600, flag: "wx" });
-        chmodSync(path, 0o600);
-        return { acquired: true, lease };
-    }
-    catch (error) {
-        const raced = readLocalDaemonMaintenanceLease(configPath);
-        if (raced)
-            return { acquired: false, lease: raced };
-        throw error;
-    }
-}
-export function releaseLocalDaemonMaintenanceLease(configPath, leaseId) {
-    releaseOwnedJsonFile(maintenanceLeasePath(configPath), leaseId);
-}
-function daemonOwnerLeasePath(configPath) {
-    return `${configPath}.daemon-owner.json`;
-}
-function readLocalDaemonOwnerLease(configPath) {
-    const path = daemonOwnerLeasePath(configPath);
-    if (!existsSync(path))
-        return null;
-    try {
-        const lease = JSON.parse(readFileSync(path, "utf8"));
-        if (lease.version !== 1 ||
-            typeof lease.id !== "string" ||
-            typeof lease.daemonSessionId !== "string" ||
-            !Number.isSafeInteger(lease.pid) ||
-            lease.pid <= 0 ||
-            typeof lease.startedAtMs !== "number" ||
-            !Number.isFinite(lease.startedAtMs) ||
-            typeof lease.runtimeId !== "string" ||
-            typeof lease.localServiceId !== "string" ||
-            !Number.isSafeInteger(lease.localApiPort) ||
-            lease.localApiPort < 0 ||
-            lease.localApiPort > 65_535 ||
-            typeof lease.localApiToken !== "string" ||
-            lease.localApiToken.length === 0) {
-            throw new Error("invalid daemon owner lease");
-        }
-        return lease;
-    }
-    catch (error) {
-        throw new Error(`Cannot safely read daemon owner lease: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-async function acquireLocalDaemonOwnerLease(input) {
-    const existing = readLocalDaemonOwnerLease(input.configPath);
-    if (existing) {
-        const endpoint = existing.localApiPort > 0
-            ? await probeLocalDaemonEndpoint(existing.localApiPort, existing.localApiToken)
-            : { state: "absent" };
-        if (endpoint.state === "running") {
-            const matchesOwner = endpoint.status.runtimeId === existing.runtimeId &&
-                endpoint.status.localServiceId === existing.localServiceId &&
-                endpoint.status.daemonSessionId === existing.daemonSessionId;
-            if (!matchesOwner) {
-                throw new Error("Daemon owner lease does not match the authenticated local endpoint");
-            }
-            return { acquired: false, lease: existing };
-        }
-        if (endpoint.state === "listening_unauthorized") {
-            return { acquired: false, lease: existing };
-        }
-        // PID existence alone is not proof of daemon ownership: after a crash or
-        // reboot the OS can reuse the recorded PID for an unrelated process. The
-        // authenticated endpoint is authoritative. If it is absent, an apparently
-        // live owner only blocks takeover while accepted or pending work still
-        // needs protection. The startup maintenance lease already serializes this
-        // decision against another daemon that is concurrently starting.
-        const journal = inspectLocalDaemonRunJournal(input.configPath);
-        if (isProviderProcessAlive(existing.pid) && !journal.safeToRestart) {
-            return { acquired: false, lease: existing };
-        }
-        // The authenticated endpoint is absent and no live work prevents recovery.
-        // Replace the stale owner; the new owner confirms recovery only after bind.
-        releaseOwnedJsonFile(daemonOwnerLeasePath(input.configPath), existing.id);
-    }
-    if (!existing && input.storedLocalApiPort && input.storedLocalApiToken) {
-        const storedEndpoint = await probeLocalDaemonEndpoint(input.storedLocalApiPort, input.storedLocalApiToken);
-        if (storedEndpoint.state === "running") {
-            throw new Error("The stored local endpoint already owns this daemon config");
-        }
-        if (storedEndpoint.state === "listening_unauthorized") {
-            throw new Error("The stored local endpoint rejected this daemon config token");
-        }
-    }
-    const lease = {
-        version: 1,
-        id: randomUUID(),
-        daemonSessionId: input.daemonSessionId,
-        pid: process.pid,
-        startedAtMs: Date.now(),
-        runtimeId: input.runtimeId,
-        localServiceId: input.localServiceId,
-        localApiPort: input.localApiPort,
-        localApiToken: input.localApiToken,
-    };
-    const path = daemonOwnerLeasePath(input.configPath);
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    try {
-        writeFileSync(path, JSON.stringify(lease), { mode: 0o600, flag: "wx" });
-        chmodSync(path, 0o600);
-        return { acquired: true, lease };
-    }
-    catch (error) {
-        const raced = readLocalDaemonOwnerLease(input.configPath);
-        if (raced)
-            return { acquired: false, lease: raced };
-        throw error;
-    }
-}
-function updateLocalDaemonOwnerEndpoint(configPath, lease, localApiPort) {
-    const current = readLocalDaemonOwnerLease(configPath);
-    if (current?.id !== lease.id)
-        throw new Error("Daemon ownership changed before local API bind");
-    const updated = { ...lease, localApiPort };
-    const path = daemonOwnerLeasePath(configPath);
-    const pendingPath = `${path}.pending-${lease.id}`;
-    try {
-        writeFileSync(pendingPath, JSON.stringify(updated), { mode: 0o600 });
-        chmodSync(pendingPath, 0o600);
-        renameSync(pendingPath, path);
-        return updated;
-    }
-    finally {
-        rmSync(pendingPath, { force: true });
-    }
-}
-function releaseLocalDaemonOwnerLease(configPath, leaseId) {
-    releaseOwnedJsonFile(daemonOwnerLeasePath(configPath), leaseId);
-}
-/**
- * Atomically take the current pathname before inspecting ownership. A newer
- * replacement can therefore never be removed by an older owner's release.
- */
-function releaseOwnedJsonFile(path, ownerId, ownerField = "id") {
-    const releasePath = `${path}.release-${process.pid}-${randomBytes(6).toString("hex")}`;
-    try {
-        renameSync(path, releasePath);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-    try {
-        const content = readFileSync(releasePath, "utf8");
-        let capturedOwnerId = null;
-        try {
-            const captured = JSON.parse(content);
-            capturedOwnerId = typeof captured[ownerField] === "string" ? captured[ownerField] : null;
-        }
-        catch {
-            // Preserve an invalid replacement too; readers deliberately fail closed.
-        }
-        if (capturedOwnerId === ownerId)
-            return;
-        // Restore only if nobody acquired a still-newer lease in the short rename
-        // window. `wx` prevents this older release from overwriting that owner.
-        try {
-            writeFileSync(path, content, { mode: 0o600, flag: "wx" });
-            chmodSync(path, 0o600);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-        }
-    }
-    finally {
-        rmSync(releasePath, { force: true });
-    }
-}
-export function inspectLocalDaemonRunJournal(configPath) {
-    const nowMs = Date.now();
-    const path = `${configPath}.run-journal.json`;
-    const pendingPath = `${configPath}.pending-runs.json`;
-    try {
-        let activeRunCount = 0;
-        for (const artifact of [path, pendingPath]) {
-            if (!existsSync(artifact))
-                continue;
-            const parsed = JSON.parse(readFileSync(artifact, "utf8"));
-            if (parsed.version !== 1 || !Array.isArray(parsed.entries))
-                throw new Error("invalid journal");
-            if (artifact === path) {
-                activeRunCount += parsed.entries.filter((entry) => {
-                    if (!entry || typeof entry !== "object")
-                        throw new Error("invalid run journal entry");
-                    const journalEntry = entry;
-                    if (typeof journalEntry.runId !== "string" ||
-                        journalEntry.runId.length === 0 ||
-                        typeof journalEntry.conversationId !== "string" ||
-                        journalEntry.conversationId.length === 0 ||
-                        typeof journalEntry.acceptedAtMs !== "number" ||
-                        !Number.isFinite(journalEntry.acceptedAtMs)) {
-                        throw new Error("invalid run journal identity");
-                    }
-                    const interruptedAtMs = journalEntry.interruptedAtMs;
-                    if (interruptedAtMs === undefined)
-                        return true;
-                    if (typeof interruptedAtMs !== "number" || !Number.isFinite(interruptedAtMs)) {
-                        throw new Error("invalid interrupted journal marker");
-                    }
-                    return false;
-                }).length;
-                continue;
-            }
-            const legacyStartedAtMs = statSync(pendingPath).mtimeMs;
-            activeRunCount += parsed.entries.filter((entry) => {
-                if (!entry || typeof entry !== "object")
-                    throw new Error("invalid pending run entry");
-                const startedAtMs = entry.startedAtMs;
-                if (startedAtMs === undefined) {
-                    return nowMs - legacyStartedAtMs <= PENDING_RUN_START_TTL_MS;
-                }
-                if (typeof startedAtMs !== "number" || !Number.isFinite(startedAtMs)) {
-                    throw new Error("invalid pending run timestamp");
-                }
-                return nowMs - startedAtMs <= PENDING_RUN_START_TTL_MS;
-            }).length;
-        }
-        return { safeToRestart: activeRunCount === 0, activeRunCount };
-    }
-    catch {
-        return { safeToRestart: false, activeRunCount: 1 };
-    }
-}
-function pendingSetupIntentPath() {
-    return `${getConfigPath()}.setup-pending`;
-}
-function setupTokenHash(setupToken) {
-    return createHash("sha256").update(setupToken).digest("hex");
-}
-function getOrCreateSetupAttemptId(setupToken) {
-    const intentPath = pendingSetupIntentPath();
-    const tokenHash = setupTokenHash(setupToken);
-    if (existsSync(intentPath)) {
-        try {
-            const stored = JSON.parse(readFileSync(intentPath, "utf8"));
-            if (stored.setupTokenHash === tokenHash &&
-                typeof stored.registrationAttemptId === "string" &&
-                stored.registrationAttemptId.length > 0) {
-                return stored.registrationAttemptId;
-            }
-        }
-        catch {
-            // Replace malformed or stale setup intent below without touching active config.
-        }
-    }
-    const registrationAttemptId = randomUUID();
-    mkdirSync(dirname(intentPath), { recursive: true, mode: 0o700 });
-    const writePath = `${intentPath}.pending-${process.pid}-${randomBytes(6).toString("hex")}`;
-    try {
-        writeFileSync(writePath, JSON.stringify({ setupTokenHash: tokenHash, registrationAttemptId }, null, 2), { mode: 0o600 });
-        chmodSync(writePath, 0o600);
-        renameSync(writePath, intentPath);
-    }
-    finally {
-        rmSync(writePath, { force: true });
-    }
-    return registrationAttemptId;
-}
-function clearPendingSetupIntent() {
-    rmSync(pendingSetupIntentPath(), { force: true });
-}
-function pendingDeviceAuthorizationPath() {
-    return `${getConfigPath()}.device-auth-pending`;
-}
-function deviceAuthorizationOperationPath() {
-    return `${getConfigPath()}.device-auth-operation.json`;
-}
-function parseDeviceAuthorizationOperationContent(content) {
-    try {
-        const lease = JSON.parse(content);
-        if (lease.version !== 1 ||
-            typeof lease.id !== "string" ||
-            typeof lease.expiresAtMs !== "number" ||
-            !Number.isFinite(lease.expiresAtMs)) {
-            return null;
-        }
-        return lease;
-    }
-    catch {
-        return null;
-    }
-}
-function restoreCapturedFileUnlessReplaced(path, content) {
-    try {
-        writeFileSync(path, content, { mode: 0o600, flag: "wx" });
-        chmodSync(path, 0o600);
-    }
-    catch (error) {
-        if (error.code !== "EEXIST")
-            throw error;
-    }
-}
-function quarantineCorruptDeviceAuthorizationOperation(path) {
-    const quarantinePath = `${path}.corrupt-${process.pid}-${randomBytes(6).toString("hex")}`;
-    try {
-        renameSync(path, quarantinePath);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    try {
-        const capturedContent = readFileSync(quarantinePath, "utf8");
-        // The pathname may have been replaced after the failed parse but before
-        // this atomic capture. Preserve it if what we actually captured is valid.
-        if (parseDeviceAuthorizationOperationContent(capturedContent)) {
-            restoreCapturedFileUnlessReplaced(path, capturedContent);
-        }
-    }
-    finally {
-        rmSync(quarantinePath, { force: true });
-    }
-    if (!existsSync(path))
-        return null;
-    return parseDeviceAuthorizationOperationContent(readFileSync(path, "utf8"));
-}
-function readDeviceAuthorizationOperation() {
-    const path = deviceAuthorizationOperationPath();
-    if (!existsSync(path))
-        return null;
-    const parsed = parseDeviceAuthorizationOperationContent(readFileSync(path, "utf8"));
-    const lease = parsed ?? quarantineCorruptDeviceAuthorizationOperation(path);
-    if (!lease)
-        return null;
-    if (lease.expiresAtMs <= Date.now()) {
-        releaseOwnedJsonFile(path, lease.id);
-        return null;
-    }
-    return lease;
-}
-function acquireDeviceAuthorizationOperation() {
-    const existing = readDeviceAuthorizationOperation();
-    if (existing)
-        return null;
-    const lease = {
-        version: 1,
-        id: randomUUID(),
-        expiresAtMs: Date.now() + 60_000,
-    };
-    const path = deviceAuthorizationOperationPath();
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    try {
-        writeFileSync(path, JSON.stringify(lease), { mode: 0o600, flag: "wx" });
-        chmodSync(path, 0o600);
-        return lease;
-    }
-    catch (error) {
-        if (error.code === "EEXIST")
-            return null;
-        throw error;
-    }
-}
-function extendDeviceAuthorizationOperation(operationId, expiresAtMs) {
-    const current = readDeviceAuthorizationOperation();
-    if (current?.id !== operationId) {
-        throw new Error("browser authorization operation ownership was lost");
-    }
-    const path = deviceAuthorizationOperationPath();
-    const pendingPath = `${path}.pending-${process.pid}-${randomBytes(6).toString("hex")}`;
-    try {
-        writeFileSync(pendingPath, JSON.stringify({ ...current, expiresAtMs: Math.max(expiresAtMs, Date.now() + 60_000) }), { mode: 0o600 });
-        chmodSync(pendingPath, 0o600);
-        // The current operation is still unexpired, so a compliant peer cannot
-        // replace it between the owner check and this atomic renewal.
-        renameSync(pendingPath, path);
-    }
-    finally {
-        rmSync(pendingPath, { force: true });
-    }
-}
-function assertDeviceAuthorizationOperationOwner(operationId) {
-    if (readDeviceAuthorizationOperation()?.id !== operationId) {
-        throw new Error("browser authorization operation ownership was lost");
-    }
-}
-function clearPendingDeviceAuthorization(operationId) {
-    const path = pendingDeviceAuthorizationPath();
-    if (!operationId) {
-        rmSync(path, { force: true });
-        return;
-    }
-    if (!existsSync(path))
-        return;
-    try {
-        const pending = JSON.parse(readFileSync(path, "utf8"));
-        if (pending.operationId !== operationId)
-            return;
-    }
-    catch {
-        return;
-    }
-    releaseOwnedJsonFile(path, operationId, "operationId");
-}
-function readPendingDeviceAuthorization(apiUrl) {
-    const path = pendingDeviceAuthorizationPath();
-    if (!existsSync(path))
-        return null;
-    try {
-        const pending = JSON.parse(readFileSync(path, "utf8"));
-        const expiresAtMs = Date.parse(pending.expiresAt ?? "");
-        if (pending.apiUrl !== apiUrl ||
-            typeof pending.deviceCode !== "string" ||
-            typeof pending.userCode !== "string" ||
-            typeof pending.verificationUri !== "string" ||
-            typeof pending.installationId !== "string" ||
-            (pending.operationId !== undefined && typeof pending.operationId !== "string") ||
-            !Number.isFinite(pending.intervalSeconds) ||
-            !Number.isFinite(expiresAtMs) ||
-            expiresAtMs <= Date.now()) {
-            return null;
-        }
-        return pending;
-    }
-    catch {
-        return null;
-    }
-}
-function writePendingDeviceAuthorization(pending) {
-    const path = pendingDeviceAuthorizationPath();
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const writePath = `${path}.pending-${process.pid}-${randomBytes(6).toString("hex")}`;
-    try {
-        writeFileSync(writePath, JSON.stringify(pending, null, 2), { mode: 0o600 });
-        chmodSync(writePath, 0o600);
-        renameSync(writePath, path);
-    }
-    finally {
-        rmSync(writePath, { force: true });
-    }
-}
-function removeAlanOwnedLocalArtifacts() {
-    const configPath = getConfigPath();
-    const directory = dirname(configPath);
-    const configName = basename(configPath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const alanAtomicSidecarPattern = new RegExp(`^${configName}(?:|\\.setup-pending|\\.device-auth-pending|\\.device-auth-operation\\.json|\\.maintenance-lease\\.json|\\.event-outbox\\.enc)\\.(?:pending|release|corrupt)-\\d+-[a-f0-9]{12}$`);
-    // This is the complete Alan-owned local credential/state inventory. Keep
-    // third-party provider and MCP config outside this list: logout must never
-    // delete user-owned tool configuration.
-    const artifacts = new Set([
-        `${configPath}.pending`,
-        `${configPath}.last-known-good`,
-        pendingSetupIntentPath(),
-        pendingDeviceAuthorizationPath(),
-        deviceAuthorizationOperationPath(),
-        `${configPath}.event-outbox.enc`,
-        `${configPath}.run-journal.json`,
-        `${configPath}.run-journal.json.pending`,
-        `${configPath}.pending-runs.json`,
-        `${configPath}.pending-runs.json.pending`,
-        maintenanceLeasePath(configPath),
-    ]);
-    if (existsSync(directory)) {
-        for (const entry of readdirSync(directory)) {
-            if (alanAtomicSidecarPattern.test(entry))
-                artifacts.add(join(directory, entry));
-        }
-    }
-    for (const artifact of artifacts)
-        rmSync(artifact, { force: true });
-    // Remove the durable credential file last so a partial cleanup never leaves
-    // hidden credential sidecars behind while claiming logout succeeded.
-    rmSync(configPath, { force: true });
-}
-function argValue(args, name) {
-    const index = args.indexOf(name);
-    if (index === -1)
-        return undefined;
-    return args[index + 1];
-}
-function resolveEndpointProfile(args) {
-    const profile = resolveEndpointProfileFromArgs(args);
-    return profile;
-}
-function resolveEndpoints(args, stored = {}) {
-    const requestedProfile = resolveEndpointProfile(args);
-    const profileApiUrl = requestedProfile === "local"
-        ? LOCAL_API_URL
-        : requestedProfile === "staging"
-            ? STAGING_API_URL
-            : PRODUCTION_API_URL;
-    const profileWsUrl = requestedProfile === "local"
-        ? LOCAL_WS_URL
-        : requestedProfile === "staging"
-            ? STAGING_WS_URL
-            : PRODUCTION_WS_URL;
-    const endpointDefaults = readEndpointDefaults();
-    const apiUrl = argValue(args, "--api-url") ??
-        process.env.ALAN_API_URL ??
-        stored.apiUrl ??
-        endpointDefaults.apiUrl ??
-        profileApiUrl;
-    const wsUrl = argValue(args, "--ws-url") ??
-        process.env.ALAN_WS_URL ??
-        stored.wsUrl ??
-        endpointDefaults.wsUrl ??
-        profileWsUrl;
-    const endpointProfile = apiUrl === profileApiUrl && wsUrl === profileWsUrl
-        ? requestedProfile
-        : apiUrl === endpointDefaults.apiUrl &&
-            wsUrl === endpointDefaults.wsUrl &&
-            endpointDefaults.endpointProfile
-            ? endpointDefaults.endpointProfile
-            : "custom";
-    return { apiUrl, wsUrl, endpointProfile };
-}
-function isLocalEndpoint(url) {
-    return Boolean(url && /^(https?|wss?):\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(url));
-}
-/**
- * A stored config claiming the production or staging profile must point at
- * that profile's endpoints (or the deployment's endpoints.json overrides).
- * A corrupted config — e.g. production profile with an ephemeral localhost
- * wsUrl — previously made the daemon dial a dead socket forever while the
- * computer still looked Online in Settings.
- */
-function checkStoredEndpointConsistency(stored, endpointDefaults) {
-    const profile = stored.endpointProfile;
-    if (profile !== "production" && profile !== "staging")
-        return null;
-    const builtInApiUrl = profile === "production" ? PRODUCTION_API_URL : STAGING_API_URL;
-    const builtInWsUrl = profile === "production" ? PRODUCTION_WS_URL : STAGING_WS_URL;
-    if (stored.apiUrl === builtInApiUrl && stored.wsUrl === builtInWsUrl)
-        return null;
-    const defaultsMatchProfile = endpointDefaults.endpointProfile === profile;
-    const expectedApiUrl = (defaultsMatchProfile ? endpointDefaults.apiUrl : undefined) ?? builtInApiUrl;
-    const expectedWsUrl = (defaultsMatchProfile ? endpointDefaults.wsUrl : undefined) ?? builtInWsUrl;
-    const issues = [];
-    if (stored.wsUrl && stored.wsUrl !== expectedWsUrl) {
-        issues.push(`wsUrl ${stored.wsUrl} (expected ${expectedWsUrl})`);
-    }
-    if (stored.apiUrl && stored.apiUrl !== expectedApiUrl) {
-        issues.push(`apiUrl ${stored.apiUrl} (expected ${expectedApiUrl})`);
-    }
-    if (issues.length === 0)
-        return null;
-    return {
-        detail: `Stored config claims the ${profile} profile but has ${issues.join(" and ")}.`,
-        expectedWsUrl,
-        expectedApiUrl,
-    };
-}
-function getLocalApiPort(args, stored) {
-    const raw = argValue(args, "--local-api-port") ?? process.env.ALAN_AGENT_LOCAL_API_PORT;
-    if (raw)
-        return Number.parseInt(raw, 10);
-    const storedPort = stored.localApiPort;
-    if (storedPort && storedPort > 0)
-        return storedPort;
-    return 47831;
-}
-function sleep(ms) {
-    if (ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function normalizeBackendKind(backendKind) {
-    if (backendKind === "codex")
-        return "codex_app_server";
-    return backendKind;
-}
-function providerModelCacheKey(provider, executable) {
-    return `${provider}:${executable}`;
-}
-/**
- * Populated by refreshProviderVersions() on its own timer, never by
- * discoverCapabilities() itself — probing `--version` synchronously on every
- * heartbeat was the perf regression fixed in 726c388e3.
- */
-const providerVersionCache = new Map();
-const providerModelCache = new Map();
-const providerAvailabilitySeen = new Set();
-const providerProbesInFlight = new Map();
-const providerModelProbesInFlight = new Map();
-export const VERSION_REFRESH_INTERVAL_MS = 20 * 60 * 1000;
-function refreshSingleProviderVersion(provider, executable, env) {
-    const inFlight = providerProbesInFlight.get(provider);
-    if (inFlight)
-        return inFlight;
-    const probe = (async () => {
-        try {
-            const result = await runCliVersionProbeAsync(executable, env);
-            if (result.error || result.status !== 0)
-                return;
-            const version = (result.stdout || result.stderr).split("\n")[0]?.trim();
-            if (version)
-                providerVersionCache.set(provider, version);
-        }
-        finally {
-            providerProbesInFlight.delete(provider);
-        }
-    })();
-    providerProbesInFlight.set(provider, probe);
-    return probe;
-}
-export async function refreshProviderVersions() {
-    const env = getDaemonCliEnvironment();
-    await Promise.allSettled(DISCOVERABLE_PROVIDER_KINDS.map((provider) => {
-        const executable = resolveProviderCliCommand(provider, env);
-        if (!executable)
-            return Promise.resolve();
-        return refreshSingleProviderVersion(provider, executable, env);
-    }));
-}
-function refreshSingleProviderModels(provider, executable, env) {
-    if (!supportsProviderModelDiscovery(provider))
-        return Promise.resolve();
-    const cacheKey = providerModelCacheKey(provider, executable);
-    const inFlight = providerModelProbesInFlight.get(cacheKey);
-    if (inFlight)
-        return inFlight;
-    const probe = (async () => {
-        try {
-            const models = await discoverProviderModels(provider, executable, env);
-            if (models.length > 0 || !providerModelCache.has(cacheKey)) {
-                providerModelCache.set(cacheKey, models);
-            }
-        }
-        finally {
-            providerModelProbesInFlight.delete(cacheKey);
-        }
-    })();
-    providerModelProbesInFlight.set(cacheKey, probe);
-    return probe;
-}
-export async function refreshProviderModels(providers = DISCOVERABLE_PROVIDER_KINDS) {
-    const env = getDaemonCliEnvironment();
-    await Promise.allSettled(providers.map((provider) => {
-        const executable = resolveProviderCliCommand(provider, env);
-        if (!executable)
-            return Promise.resolve();
-        return refreshSingleProviderModels(provider, executable, env);
-    }));
-}
-/** One-shot capability scan for cloud boot hooks and `alan-agent scan-models`. */
-export async function scanAgentCapabilities(providers = [...DISCOVERABLE_PROVIDER_KINDS]) {
-    await refreshProviderVersions();
-    await refreshProviderModels(providers);
-    return discoverCapabilities();
-}
-export async function printScanModels(args) {
-    const json = args.includes("--json");
-    const providersFlag = args.find((arg) => arg.startsWith("--providers="));
-    const providers = providersFlag
-        ? providersFlag
-            .slice("--providers=".length)
-            .split(",")
-            .map((provider) => provider.trim())
-            .filter(Boolean)
-        : undefined;
-    const capabilities = await scanAgentCapabilities(providers ?? [...DISCOVERABLE_PROVIDER_KINDS]);
-    if (json) {
-        process.stdout.write(`${JSON.stringify(capabilities)}\n`);
-        return;
-    }
-    for (const agent of capabilities.agents ?? []) {
-        const modelSummary = agent.models?.length ? agent.models.join(", ") : "none";
-        process.stdout.write(`${agent.provider}: ${agent.available ? "available" : "missing"} models=[${modelSummary}]\n`);
-    }
-}
-function scheduleRuntimeModelScan(getBaseMetadata, options) {
-    const stored = readConfig();
-    if (!stored.runtimeId || !stored.runtimeToken || !stored.apiUrl)
-        return;
-    void runRuntimeModelScan({
-        refreshModels: refreshProviderModels,
-        getCapabilities: () => discoverCapabilities(),
-        getBaseMetadata: async () => (await getBaseMetadata()),
-        publishCredentials: {
-            apiUrl: stored.apiUrl,
-            runtimeId: stored.runtimeId,
-            runtimeToken: stored.runtimeToken,
-        },
-    }, options);
-}
-export function discoverCapabilities() {
-    const now = new Date().toISOString();
-    const env = getDaemonCliEnvironment();
-    return {
-        agents: DISCOVERABLE_PROVIDER_KINDS.map((provider) => {
-            const executable = resolveProviderCliCommand(provider, env);
-            const available = Boolean(executable);
-            if (available && executable && !providerAvailabilitySeen.has(provider)) {
-                providerAvailabilitySeen.add(provider);
-                void refreshSingleProviderVersion(provider, executable, env);
-            }
-            else if (!available) {
-                providerAvailabilitySeen.delete(provider);
-            }
-            const version = providerVersionCache.get(provider);
-            const models = executable
-                ? (providerModelCache.get(providerModelCacheKey(provider, executable)) ?? [])
-                : [];
-            return {
-                provider,
-                available,
-                ...(version ? { version } : {}),
-                models,
-                lastCheckedAt: now,
-            };
-        }),
-        hasGit: Boolean(resolveCliExecutable("git", env)),
-        hasTerminal: true,
-        supportsFilesystem: true,
-    };
-}
-const PENDING_RUN_START_TTL_MS = 10 * 60_000;
-class DurablePendingRunStarts extends Map {
-    path;
-    daemonSessionId;
-    startedAtByRunId = new Map();
-    constructor(path, daemonSessionId) {
-        super();
-        this.path = path;
-        this.daemonSessionId = daemonSessionId;
-    }
-    set(runId, conversationId) {
-        if (!this.startedAtByRunId.has(runId))
-            this.startedAtByRunId.set(runId, Date.now());
-        super.set(runId, conversationId);
-        this.persist();
-        return this;
-    }
-    delete(runId) {
-        const deleted = super.delete(runId);
-        if (deleted) {
-            this.startedAtByRunId.delete(runId);
-            this.persist();
-        }
-        return deleted;
-    }
-    /** Remove artifacts inherited from a previous process after local API ownership is proven. */
-    discardRecovered() {
-        this.persist();
-    }
-    persist() {
-        if (this.size === 0) {
-            rmSync(this.path, { force: true });
-            return;
-        }
-        const pendingPath = `${this.path}.pending`;
-        mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
-        try {
-            writeFileSync(pendingPath, JSON.stringify({
-                version: 1,
-                entries: [...this].map(([runId, conversationId]) => ({
-                    runId,
-                    conversationId,
-                    startedAtMs: this.startedAtByRunId.get(runId) ?? Date.now(),
-                    daemonSessionId: this.daemonSessionId,
-                })),
-            }), { mode: 0o600 });
-            chmodSync(pendingPath, 0o600);
-            renameSync(pendingPath, this.path);
-        }
-        finally {
-            rmSync(pendingPath, { force: true });
-        }
-    }
-}
-const RUNNER_RECOVERY_GRACE_MS_LOCAL = RUNNER_RECOVERY_GRACE_MS;
-const USER_INTERRUPTED_RESULT = {
-    success: false,
-    summary: "Interrupted by user",
-    filesModified: [],
-    planFilesCreated: [],
-    iterations: 0,
-    error: "Interrupted by user",
-    errorKind: "user",
-};
-/**
- * Build the terminal result for an aborted run. Only reason "user" may emit the
- * "Interrupted by user" text the UI renders as "Stopped by user"; system-initiated
- * aborts (watchdog timeout, dead provider, stalled runner) carry distinct messages.
- */
-function buildAbortResult(reason) {
-    if (reason === "user")
-        return USER_INTERRUPTED_RESULT;
-    const message = SYSTEM_ABORT_RUN_ERRORS[reason];
-    return {
-        success: false,
-        summary: message,
-        filesModified: [],
-        planFilesCreated: [],
-        iterations: 0,
-        error: message,
-        errorKind: reason,
-    };
-}
-function abortActiveAgent(entry, options) {
-    const awaitingAsk = (entry.presenter.pendingAskUserToolIds?.size ?? 0) > 0;
-    if (awaitingAsk && !options?.userInitiated) {
-        return;
-    }
-    const reason = options?.reason ?? (options?.userInitiated ? "user" : "runner_stalled");
-    entry.presenter.onComplete(buildAbortResult(reason));
-    entry.agent.kill();
-}
-function isProviderProcessAlive(pid) {
-    if (pid === null || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function buildActiveRunSlots(activeAgents, nowMs = Date.now()) {
-    return [...activeAgents.entries()].map(([runId, entry]) => {
-        const staleByGrace = nowMs - entry.lastActivityAtMs >= RUNNER_RECOVERY_GRACE_MS_LOCAL;
-        const staleByDeadPid = entry.providerPid !== null && !isProviderProcessAlive(entry.providerPid);
-        const stale = staleByGrace || staleByDeadPid;
-        return {
-            runId,
-            conversationId: entry.conversationId,
-            stage: entry.stage,
-            providerPid: entry.providerPid,
-            acceptedAtMs: entry.acceptedAtMs,
-            lastActivityAtMs: entry.lastActivityAtMs,
-            stale,
-        };
-    });
-}
-function buildRunnerStatusPayload(input) {
-    const nowMs = input.nowMs ?? Date.now();
-    const activeRuns = buildActiveRunSlots(input.activeAgents, nowMs);
-    const { activeRunCount, staleRunCount } = countNonStaleActiveRuns(activeRuns, nowMs);
-    const computerReadiness = buildComputerReadiness({
-        nowMs,
-        runtimeId: input.runtimeId,
-        endpointProfile: input.endpointProfile,
-        configPath: input.configPath,
-        configEndpointProfile: input.endpointProfile,
-        endpointMismatchDetail: input.endpointMismatchDetail,
-        connected: input.connected,
-        localApiHealthy: true,
-        runtimeAuthValid: input.runtimeAuthValid,
-        workspacePath: input.workspacePath,
-        providerAvailable: input.providerAvailable,
-        protocolCompatible: true,
-    });
-    // allowWarn: a warn is degraded-but-functional (e.g. self-healed endpoint
-    // mismatch) and must not block run acceptance.
-    const computerReady = isComputerReady(computerReadiness, { allowWarn: true });
-    const pastDisconnectGrace = input.disconnectedSinceMs !== null &&
-        nowMs - input.disconnectedSinceMs >= RUNNER_RECOVERY_GRACE_MS_LOCAL;
-    const restartRecommended = !input.connected && activeRunCount === 0 && staleRunCount === 0 && pastDisconnectGrace;
-    const recovering = !input.connected && !restartRecommended;
-    const acceptingRuns = deriveAcceptingRuns({
-        connected: input.connected,
-        activeRunCount,
-        computerReady,
-    });
-    const primaryIssue = pickPrimaryReadinessIssue(computerReadiness);
-    return {
-        daemonSessionId: input.daemonSessionId,
-        daemonEpoch: input.daemonEpoch,
-        heartbeatSeq: input.heartbeatSeq,
-        connected: input.connected,
-        acceptingRuns,
-        recovering,
-        restartRecommended,
-        activeRuns,
-        interruptedRunIds: input.interruptedRunIds ?? [],
-        activeRunCount,
-        staleRunCount,
-        lastRunActivityAtMs: activeRuns.reduce((latest, run) => {
-            const value = run.lastActivityAtMs ?? run.acceptedAtMs ?? null;
-            return value === null ? latest : latest === null ? value : Math.max(latest, value);
-        }, null),
-        disconnectedSinceMs: input.disconnectedSinceMs,
-        endpointProfile: input.endpointProfile,
-        configPath: input.configPath,
-        protocolVersion: RUNNER_STATUS_PROTOCOL_VERSION,
-        protocolMinVersion: RUNNER_STATUS_MIN_SUPPORTED_PROTOCOL_VERSION,
-        protocolMaxVersion: RUNNER_STATUS_MAX_SUPPORTED_PROTOCOL_VERSION,
-        computerReadiness,
-        primaryMessage: primaryIssue?.message,
-        primaryAction: primaryIssue?.action ?? null,
-    };
-}
-function summarizeRunnerStatus(input) {
-    const runnerStatus = buildRunnerStatusPayload(input);
-    if (input.maintenanceReason) {
-        runnerStatus.acceptingRuns = false;
-        runnerStatus.primaryMessage =
-            input.maintenanceReason === "credential_cleanup"
-                ? "This computer is finishing logout."
-                : "This computer is under short-lived maintenance.";
-        runnerStatus.primaryAction = null;
-    }
-    return {
-        activeRunIds: runnerStatus.activeRuns.map((run) => run.runId),
-        activeRunCount: runnerStatus.activeRunCount,
-        acceptingRuns: runnerStatus.acceptingRuns,
-        recovering: runnerStatus.recovering,
-        restartRecommended: runnerStatus.restartRecommended,
-        staleRunCount: runnerStatus.staleRunCount,
-        lastRunActivityAtMs: runnerStatus.lastRunActivityAtMs ?? null,
-        disconnectedSinceMs: runnerStatus.disconnectedSinceMs ?? null,
-        runnerStatus,
-    };
-}
-const DELIVERY_LOST_ERROR = "Runtime disconnected from backend; agent run delivery was lost";
-function buildApplicationRunFailure(input) {
-    const problem = createAlanProblem({
-        domain: "application",
-        code: input.code,
-        id: randomUUID(),
-        title: "Alan could not complete the agent run",
-        detail: input.detail,
-        occurredAt: new Date().toISOString(),
-        severity: "terminal",
-        scope: { conversationId: input.conversationId, runId: input.runId },
-        recovery: {
-            mode: input.code === "app.workspace.missing" ? "after_user_action" : "manual",
-            action: input.detail,
-            safe: false,
-        },
-        origin: { component: input.component, phase: input.phase },
-        transport: {
-            kind: input.phase === "delivery" ? "websocket" : "internal",
-        },
-    });
-    const result = {
-        success: false,
-        summary: input.detail,
-        filesModified: [],
-        planFilesCreated: [],
-        iterations: 0,
-        error: input.detail,
-    };
-    return {
-        problem,
-        result,
-        events: [
-            { type: "application_problem", problem },
-            {
-                type: "agent_run_finished",
-                result,
-                failureDomain: "application",
-                causeProblemId: problem.id,
-            },
-            // Legacy completion projection. Never author session_error for a new
-            // application-domain failure.
-            { type: "query_complete", result, ts: Date.now() },
-        ],
-    };
-}
-/**
- * On reconnect: replay the real events buffered for each run that produced activity while the
- * socket was down (Gap 1), then emit the generic delivery_lost session_error ONLY for runs the
- * daemon can no longer account for — i.e. gone from `activeAgents` with no buffered terminal.
- *
- * A run still present in `activeAgents` is alive by definition: the daemon is still executing it,
- * its remaining output will stream and terminate normally. Emitting a synthetic delivery_lost for
- * such a run fails a live run on the server and wipes the API accumulator mid-turn — the rest of
- * the turn then streams live but is never persisted (issue #3). Those runs are skipped here and
- * their stage is restored so a later disconnect re-tracks them.
- */
-export function flushPendingDeliveryLostEvents(input) {
-    if (!input.socket.connected)
-        return;
-    input.eventOutbox.flush(input.socket);
-    if (input.pending.length === 0)
-        return;
-    for (const item of input.pending) {
-        // A terminal event was already replayed above for this run — do not also send the generic
-        // delivery_lost error, which would overwrite a real (possibly successful) outcome.
-        if (input.eventOutbox.hasTerminalEvent(item.runId))
-            continue;
-        const activeEntry = input.activeAgents.get(item.runId);
-        if (activeEntry) {
-            // Still executing — do not fail it. Undo the disconnect-time stage flip so the next
-            // disconnect re-adds it to the pending set.
-            if (activeEntry.stage === "delivery_lost")
-                activeEntry.stage = "running";
-            continue;
-        }
-        const failure = buildApplicationRunFailure({
-            conversationId: item.conversationId,
-            runId: item.runId,
-            code: "app.transport.disconnected",
-            detail: DELIVERY_LOST_ERROR,
-            component: "agent-manager-daemon",
-            phase: "delivery",
-        });
-        for (const event of failure.events) {
-            input.eventOutbox.enqueue(item.conversationId, item.runId, event);
-        }
-        input.pushLog(`delivery_lost run=${item.runId}`);
-    }
-    input.eventOutbox.flush(input.socket);
-    input.pending.length = 0;
-}
-/** Exported for unit tests — periodic stale/dead-provider reconciliation. */
-export function reconcileActiveRuns(input) {
-    const nowMs = input.nowMs ?? Date.now();
-    for (const [runId, entry] of input.activeAgents.entries()) {
-        const staleByGrace = nowMs - entry.lastActivityAtMs >= RUNNER_RECOVERY_GRACE_MS_LOCAL;
-        const staleByDeadPid = entry.providerPid !== null && !isProviderProcessAlive(entry.providerPid);
-        const awaitingAsk = (entry.presenter.pendingAskUserToolIds?.size ?? 0) > 0;
-        if (!staleByGrace && !staleByDeadPid)
-            continue;
-        if (awaitingAsk && staleByGrace && !staleByDeadPid)
-            continue;
-        if (staleByDeadPid && awaitingAsk) {
-            // The provider process is gone while an ask is still displayed. We used to
-            // kill + drop the run with NO terminal event, so it zombied as `running`
-            // until the watchdog and the user's later answer landed nowhere (no live
-            // stdin, no terminal, no error). Emit a terminal now so the run finalizes:
-            // the ask card survives because its tool_use stays unanswered, and with the
-            // run no longer in-flight the answer re-dispatches as a fresh user turn
-            // (message_resume) instead of racing a dead stdin. The awaiting-ask abort
-            // guard is deliberately bypassed here — there is no live CLI left to keep
-            // stdin open for, unlike the live-provider staleByGrace case above.
-            entry.presenter.onComplete(buildAbortResult("provider_exited"));
-            entry.agent.kill();
-            input.activeAgents.delete(runId);
-            input.pushLog?.(`reconciled dead provider pid run=${runId} (awaiting ask — finalized for resume)`);
-            continue;
-        }
-        abortActiveAgent(entry, { reason: staleByDeadPid ? "provider_exited" : "runner_stalled" });
-        input.activeAgents.delete(runId);
-        if (staleByDeadPid) {
-            input.pushLog?.(`reconciled dead provider pid run=${runId}`);
-        }
-        else {
-            input.pushLog?.(`recovered stale run=${runId}`);
-        }
-    }
-}
-function collectRuntimeMetadata() {
-    const cpuList = cpus();
-    const metadata = {
-        platform: platform(),
-        arch: arch(),
-        osVersion: release(),
-        agentVersion: AGENT_VERSION,
-        memoryBytes: totalmem(),
-        memoryFreeBytes: freemem(),
-    };
-    if (cpuList.length > 0) {
-        metadata.cpuModel = cpuList[0]?.model;
-        metadata.cpuCores = cpuList.length;
-    }
-    try {
-        const disk = statfsSync(homedir());
-        metadata.diskFreeBytes = disk.bavail * disk.bsize;
-        metadata.diskTotalBytes = disk.blocks * disk.bsize;
-    }
-    catch {
-        // Disk stats are best-effort and may be unavailable in restricted runtimes.
-    }
-    return metadata;
-}
-async function collectRuntimeMetadataWithProviderLimits() {
-    const metadata = collectRuntimeMetadata();
-    try {
-        const agentProviderLimits = await collectLocalAgentProviderLimits(getDaemonCliEnvironment());
-        if (Object.keys(agentProviderLimits).length > 0) {
-            metadata.agentProviderLimits = agentProviderLimits;
-        }
-    }
-    catch {
-        // Best-effort only. Missing or expired provider credentials should not affect runtime presence.
-    }
-    return metadata;
-}
-export class RuntimePresenter {
-    socket;
-    conversationId;
-    runId;
-    eventOutbox;
-    cwd;
-    touchRunnerActivity;
-    onRunComplete;
-    onRunStarted;
-    verifyWorkspaceLease;
-    onProviderAuthFailure;
-    backendKind;
-    pendingAskUserToolIds;
-    emittedGeneratedImageKeys = new Set();
-    emittedSessionMediaKeys = new Set();
-    toolNamesById = new Map();
-    toolInputsById = new Map();
-    browserRecordingPathHints = new Set();
-    applicationProblem;
-    terminalFenced = false;
-    constructor(socket, conversationId, runId, eventOutbox, cwd, touchRunnerActivity, onRunComplete, onRunStarted, verifyWorkspaceLease, 
-    /** Drop sticky provider-auth ready when the CLI reports a clear sign-out. */
-    onProviderAuthFailure, backendKind = "unknown_cli") {
-        this.socket = socket;
-        this.conversationId = conversationId;
-        this.runId = runId;
-        this.eventOutbox = eventOutbox;
-        this.cwd = cwd;
-        this.touchRunnerActivity = touchRunnerActivity;
-        this.onRunComplete = onRunComplete;
-        this.onRunStarted = onRunStarted;
-        this.verifyWorkspaceLease = verifyWorkspaceLease;
-        this.onProviderAuthFailure = onProviderAuthFailure;
-        this.backendKind = backendKind;
-    }
-    emitEvent(event) {
-        if (this.terminalFenced)
-            return;
-        this.touchRunnerActivity?.();
-        // background_work heartbeats only prove liveness to a listener that is
-        // currently connected — while offline there is nobody to prove it to.
-        // Enqueuing them anyway would durably occupy outbox slots every ~10s for
-        // the whole offline stretch, flooding the per-run cap and evicting real
-        // transcript content (including `start`) ahead of reconnect. Drop it;
-        // another heartbeat follows in 10s and will be retried the same way.
-        if (isBackgroundHeartbeat(event) && !this.socket.connected)
-            return;
-        this.eventOutbox.enqueue(this.conversationId, this.runId, event);
-        this.eventOutbox.flush(this.socket);
-    }
-    failWorkspaceLease(failure) {
-        return this.failApplicationProblem({
-            code: "app.workspace.missing",
-            detail: failure.message,
-            component: "agent-manager-workspace-lease",
-            phase: "delivery",
-        });
-    }
-    failApplicationProblem(input) {
-        if (this.terminalFenced)
-            return false;
-        this.terminalFenced = true;
-        const failure = buildApplicationRunFailure({
-            conversationId: this.conversationId,
-            runId: this.runId,
-            ...input,
-        });
-        this.applicationProblem = failure.problem;
-        for (const event of failure.events) {
-            this.eventOutbox.enqueue(this.conversationId, this.runId, event);
-        }
-        this.eventOutbox.flush(this.socket);
-        this.onRunComplete?.();
-        return true;
-    }
-    isTerminalFenced() {
-        return this.terminalFenced;
-    }
-    onStart(config) {
-        this.onRunStarted?.();
-        this.emitEvent({ type: "start", task: config.task, ts: Date.now() });
-    }
-    onLog(message) {
-        console.error(message);
-    }
-    onNotice(kind, message) {
-        this.emitEvent({ type: "session_notice", kind, message, ts: Date.now() });
-    }
-    onAssistantText(text, parentToolUseId) {
-        this.emitEvent({
-            type: "text",
-            text,
-            ts: Date.now(),
-            ...(parentToolUseId ? { parentToolUseId } : {}),
-        });
-    }
-    onThinking(text, parentToolUseId) {
-        this.emitEvent({
-            type: "thinking",
-            text,
-            ts: Date.now(),
-            ...(parentToolUseId ? { parentToolUseId } : {}),
-        });
-    }
-    onToolUse(tool, input, toolId, parentToolUseId) {
-        if (this.verifyWorkspaceLease && !this.verifyWorkspaceLease())
-            return;
-        this.toolNamesById.set(toolId, tool);
-        this.toolInputsById.set(toolId, input);
-        for (const path of extractBrowserMediaPathHints(undefined, this.cwd, tool, {
-            toolInput: input,
-        })) {
-            this.browserRecordingPathHints.add(path);
-        }
-        this.emitEvent({
-            type: "tool_use",
-            id: toolId,
-            name: tool,
-            input,
-            ts: Date.now(),
-            ...(parentToolUseId ? { parentToolUseId } : {}),
-        });
-    }
-    onToolResult(toolId, content, isError, parentToolUseId) {
-        if (this.verifyWorkspaceLease && !this.verifyWorkspaceLease())
-            return;
-        this.emitEvent({
-            type: "tool_result",
-            id: toolId,
-            content,
-            ts: Date.now(),
-            ...(isError ? { is_error: true } : {}),
-            ...(parentToolUseId ? { parentToolUseId } : {}),
-        });
-        if (isError)
-            return;
-        const toolName = this.toolNamesById.get(toolId);
-        const toolInput = this.toolInputsById.get(toolId);
-        const options = { toolInput, pathHints: [...this.browserRecordingPathHints] };
-        for (const image of extractGeneratedImagesFromToolResult(toolId, content, this.cwd, toolName, options)) {
-            this.emitGeneratedImage(image);
-        }
-        for (const media of extractSessionMediaFromToolResult(toolId, content, this.cwd, toolName, options)) {
-            this.emitSessionMedia(media);
-            if (media.sourcePath)
-                this.browserRecordingPathHints.delete(media.sourcePath);
-        }
-    }
-    onGeneratedImage(image) {
-        this.emitGeneratedImage(image);
-    }
-    emitGeneratedImage(image) {
-        const key = image.sourceHash ?? `${image.sourcePath ?? image.id}:${image.size}`;
-        if (this.emittedGeneratedImageKeys.has(key))
-            return;
-        this.emittedGeneratedImageKeys.add(key);
-        this.emitEvent(image);
-    }
-    onSessionMedia(media) {
-        this.emitSessionMedia(media);
-    }
-    emitSessionMedia(media) {
-        const key = media.sourceHash ?? `${media.sourcePath ?? media.id}:${media.size}`;
-        if (this.emittedSessionMediaKeys.has(key))
-            return;
-        this.emittedSessionMediaKeys.add(key);
-        this.emitEvent(media);
-    }
-    onTurnComplete(content) {
-        this.emitEvent({ type: "turn_complete", content, ts: Date.now() });
-    }
-    onUsageUpdate(usage) {
-        this.emitEvent({ type: "usage", usage });
-    }
-    onAskUser(id, questions) {
-        this.emitEvent({ type: "ask_user", id, questions });
-    }
-    onTodoWrite(todos) {
-        this.emitEvent({ type: "todo_write", todos });
-    }
-    onExitPlanMode(id, input, planFilePath) {
-        this.emitEvent({
-            type: "exit_plan_mode",
-            id,
-            input,
-            ...(planFilePath ? { planFilePath } : {}),
-        });
-    }
-    onCheckpoint(id) {
-        this.emitEvent({ type: "checkpoint", id });
-    }
-    onActivity(status, evidence) {
-        this.emitEvent({ type: "activity", status, ts: Date.now(), ...(evidence ? { evidence } : {}) });
-    }
-    onOpenBrowserTab(browserId, url) {
-        this.emitEvent({ type: "open_browser_tab", browserId, ...(url ? { url } : {}) });
-    }
-    recordRawTranscript() {
-        // Durable daemon transcripts stay with the underlying CLI runtime.
-    }
-    onError(message, isAgentError = true) {
-        if (this.onProviderAuthFailure && looksLikeProviderAuthFailure(message)) {
-            this.onProviderAuthFailure();
-        }
-        // Parser/provider errors are observations. Some harnesses report a retryable
-        // error and then finish successfully; treating this callback as terminal
-        // prematurely releases the run and leaves a later success as a second
-        // terminal. The run finalizer below is the sole canonical terminal emitter.
-        if (isAgentError) {
-            const problem = createCliProblem(classifyCliErrorDetailed(message, 1), {
-                harness: this.backendKind,
-                phase: "stream",
-                finality: "observation",
-                outcomeCertainty: "effect_unknown",
-                scope: { conversationId: this.conversationId, runId: this.runId },
-            });
-            this.emitEvent({ type: "agent_problem_observed", problem });
-        }
-        else {
-            this.applicationProblem = createAlanProblem({
-                domain: "application",
-                code: /local path no longer exists/i.test(message)
-                    ? "app.workspace.missing"
-                    : "app.internal",
-                id: randomUUID(),
-                title: "Alan could not start the agent run",
-                detail: message,
-                occurredAt: new Date().toISOString(),
-                severity: "terminal",
-                scope: { conversationId: this.conversationId, runId: this.runId },
-                recovery: {
-                    mode: /local path no longer exists/i.test(message) ? "after_user_action" : "manual",
-                    action: message,
-                    safe: false,
-                },
-                origin: { component: "agent-manager", phase: "dispatch" },
-                transport: { kind: "internal" },
-            });
-            this.emitEvent({ type: "application_problem", problem: this.applicationProblem });
-        }
-        // Temporary nonterminal compatibility for consumers that still understand
-        // the old generic error event. `session_error` is intentionally not emitted
-        // here because legacy clients treat it as terminal.
-        this.emitEvent({ type: "error", message, isAgentError });
-    }
-    onComplete(result) {
-        this.emitEvent({
-            type: "agent_run_finished",
-            result,
-            ...(result.problem
-                ? { failureDomain: "agent_cli", causeProblemId: result.problem.id }
-                : this.applicationProblem
-                    ? {
-                        failureDomain: "application",
-                        causeProblemId: this.applicationProblem.id,
-                    }
-                    : {}),
-        });
-        // query_complete is the sole legacy completion projection. Do not author a
-        // parallel session_error: migrated clients would first retain the typed
-        // cause, then have it overwritten by the untyped compatibility event.
-        this.emitEvent({ type: "query_complete", result, ts: Date.now() });
-        this.onRunComplete?.();
-    }
-}
-export async function setupDaemon(args) {
-    bindConfigPath(args);
-    const previousConfig = readConfigForRegistration();
-    const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-    const teamId = argValue(args, "--team") ?? process.env.ALAN_TEAM_ID;
-    const setupToken = argValue(args, "--setup-token") ?? process.env.ALAN_RUNTIME_SETUP_TOKEN;
-    const token = argValue(args, "--token") ?? process.env.ALAN_SETUP_TOKEN;
-    const displayName = argValue(args, "--name") ?? hostname();
-    const scope = argValue(args, "--scope") ?? process.env.ALAN_RUNTIME_SCOPE ?? (setupToken ? "team" : "user");
-    const installationId = argValue(args, "--installation-id") ?? previousConfig.installationId ?? randomUUID();
-    if (scope !== "team" && scope !== "user") {
-        throw new Error("setup --scope must be either 'team' or 'user'");
-    }
-    if (!setupToken && !token) {
-        throw new Error("setup requires --setup-token <token> or --token <Alan access token>.\n" +
-            "For normal setup, copy the setup token from Alan and run: alan-agent setup --setup-token <token>\n" +
-            "For browser authorization, run: alan-agent login");
-    }
-    const registrationAttemptId = setupToken ? getOrCreateSetupAttemptId(setupToken) : randomUUID();
-    const registrationUrl = `${apiUrl}/public/runtimes${setupToken ? "/register-with-setup-token" : ""}`;
-    const registrationInit = {
-        method: "POST",
-        headers: {
-            "content-type": "application/json",
-            ...(setupToken ? {} : { authorization: `Bearer ${token}` }),
-        },
-        body: JSON.stringify({
-            ...(teamId ? { teamId } : {}),
-            ...(setupToken ? { setupToken, registrationAttemptId } : {}),
-            displayName,
-            hostname: hostname(),
-            runtimeKind: "machine",
-            managementKind: "user_managed",
-            hostKind: "daemon",
-            lifecycle: "durable",
-            capabilities: discoverCapabilities(),
-            metadata: {
-                ...(await collectRuntimeMetadataWithProviderLimits()),
-                installationId,
-            },
-        }),
-    };
-    let response;
-    let transportError;
-    for (let attempt = 1; attempt <= 3; attempt += 1) {
-        try {
-            response = await fetch(registrationUrl, registrationInit);
-            transportError = undefined;
-        }
-        catch (error) {
-            transportError = error;
-        }
-        const retriableStatus = response && (response.status === 408 || response.status === 429 || response.status >= 500);
-        if ((response && (!retriableStatus || response.ok)) || attempt === 3)
-            break;
-        await new Promise((resolve) => setTimeout(resolve, attempt * 100));
-    }
-    if (!response) {
-        const detail = transportError instanceof Error ? transportError.message : String(transportError);
-        throw new Error(`runtime registration failed: unable to reach Alan (${detail})`);
-    }
-    if (!response.ok) {
-        const responseBody = await response.text();
-        let errorCode;
-        try {
-            const parsed = JSON.parse(responseBody);
-            if (typeof parsed.error === "string")
-                errorCode = parsed.error;
-        }
-        catch {
-            // Preserve non-JSON server responses in the setup failure below.
-        }
-        if (setupToken && response.status === 401 && errorCode === "setup_token_expired") {
-            clearPendingSetupIntent();
-            console.info("[alan-agent] Setup link expired; continuing with browser authorization");
-            await loginWithDeviceCode(args);
-            return;
-        }
-        throw new Error(`runtime registration failed: ${response.status} ${responseBody}`);
-    }
-    const body = (await response.json());
-    writeConfig({
-        apiUrl,
-        wsUrl,
-        endpointProfile,
-        runtimeId: body.runtime.id,
-        runtimeToken: body.runtimeToken,
-        runtimeRenewalToken: body.runtimeRenewalToken,
-        localApiPort: getLocalApiPort(args, {}),
-        localApiToken: previousConfig.localApiToken ?? randomBytes(24).toString("hex"),
-        localServiceId: previousConfig.localServiceId ?? randomUUID(),
-        localServiceSecret: previousConfig.localServiceSecret ?? randomBytes(32).toString("base64url"),
-        eventSpoolKey: previousConfig.eventSpoolKey ?? randomBytes(32).toString("base64url"),
-        daemonEpoch: previousConfig.daemonEpoch,
-        displayName: body.runtime.displayName ?? displayName,
-        installationId,
-    });
-    if (setupToken)
-        clearPendingSetupIntent();
-    console.info("[alan-agent] Runtime registered", {
-        runtimeId: body.runtime.id,
-        configPath: getConfigPath(),
-    });
-}
-export async function loginWithDeviceCode(args) {
-    bindConfigPath(args);
-    const operation = acquireDeviceAuthorizationOperation();
-    if (!operation) {
-        throw new Error("browser authorization is already in progress in another Alan process; finish or cancel it first");
-    }
-    try {
-        if (args.includes("--cancel")) {
-            clearPendingDeviceAuthorization();
-            console.info("[alan-agent] Browser authorization canceled");
-            return;
-        }
-        const previousConfig = readConfigForRegistration();
-        const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-        const displayName = argValue(args, "--name") ?? hostname();
-        const maxPolls = Number.parseInt(argValue(args, "--max-polls") ?? "300", 10);
-        const resumed = readPendingDeviceAuthorization(apiUrl);
-        const installationId = resumed?.installationId ?? previousConfig.installationId ?? randomUUID();
-        let authorization = resumed
-            ? { ...resumed, operationId: operation.id }
-            : null;
-        if (!authorization) {
-            // This process owns the operation lease, so an invalid/expired abandoned
-            // sidecar can be removed before starting a replacement authorization.
-            clearPendingDeviceAuthorization();
-            const start = await fetch(`${apiUrl}/public/runtimes/device-authorizations`, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({
-                    displayName,
-                    hostname: hostname(),
-                    capabilities: discoverCapabilities(),
-                    metadata: {
-                        ...(await collectRuntimeMetadataWithProviderLimits()),
-                        installationId,
-                    },
-                }),
-                signal: AbortSignal.timeout(30_000),
-            });
-            if (!start.ok) {
-                throw new Error(`device authorization failed: ${start.status} ${await start.text()}`);
-            }
-            const started = (await start.json());
-            authorization = {
-                ...started,
-                apiUrl,
-                installationId,
-                operationId: operation.id,
-                intervalSeconds: Math.max(0, started.intervalSeconds ?? 2),
-            };
-            if (!Number.isFinite(Date.parse(authorization.expiresAt))) {
-                throw new Error("device authorization returned an invalid expiry");
-            }
-        }
-        else {
-            console.info("[alan-agent] Resuming browser authorization");
-        }
-        // Keep exclusive ownership through the authorization's complete lifetime,
-        // including a grace window for the final token exchange and config write.
-        extendDeviceAuthorizationOperation(operation.id, Date.parse(authorization.expiresAt) + 60_000);
-        writePendingDeviceAuthorization(authorization);
-        const intervalMs = authorization.intervalSeconds * 1000;
-        console.info(`[alan-agent] Open ${authorization.verificationUri}`);
-        console.info(`[alan-agent] Enter code ${authorization.userCode}`);
-        for (let attempt = 0; attempt < maxPolls; attempt += 1) {
-            if (attempt > 0)
-                await sleep(intervalMs);
-            if (Date.parse(authorization.expiresAt) <= Date.now()) {
-                clearPendingDeviceAuthorization(operation.id);
-                throw new Error("device authorization expired before approval; run alan-agent login again");
-            }
-            assertDeviceAuthorizationOperationOwner(operation.id);
-            const token = await fetch(`${apiUrl}/public/runtimes/device-authorizations/token`, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ deviceCode: authorization.deviceCode }),
-                signal: AbortSignal.timeout(30_000),
-            });
-            if (token.status === 428)
-                continue;
-            if (!token.ok) {
-                if (token.status === 400 || token.status === 401) {
-                    clearPendingDeviceAuthorization(operation.id);
-                }
-                throw new Error(`device authorization token exchange failed: ${token.status} ${await token.text()}`);
-            }
-            const body = (await token.json());
-            assertDeviceAuthorizationOperationOwner(operation.id);
-            const ownedPending = readPendingDeviceAuthorization(apiUrl);
-            if (ownedPending?.operationId !== operation.id) {
-                throw new Error("browser authorization sidecar ownership was lost before finalization");
-            }
-            writeConfig({
-                apiUrl,
-                wsUrl,
-                endpointProfile,
-                runtimeId: body.runtime.id,
-                runtimeToken: body.runtimeToken,
-                runtimeRenewalToken: body.runtimeRenewalToken,
-                localApiPort: getLocalApiPort(args, {}),
-                localApiToken: previousConfig.localApiToken ?? randomBytes(24).toString("hex"),
-                localServiceId: previousConfig.localServiceId ?? randomUUID(),
-                localServiceSecret: previousConfig.localServiceSecret ?? randomBytes(32).toString("base64url"),
-                eventSpoolKey: previousConfig.eventSpoolKey ?? randomBytes(32).toString("base64url"),
-                daemonEpoch: previousConfig.daemonEpoch,
-                displayName: body.runtime.displayName ?? displayName,
-                installationId,
-            });
-            clearPendingDeviceAuthorization(operation.id);
-            console.info("[alan-agent] Runtime registered", {
-                runtimeId: body.runtime.id,
-                configPath: getConfigPath(),
-            });
-            return;
-        }
-        throw new Error("device authorization timed out before approval");
-    }
-    finally {
-        releaseOwnedJsonFile(deviceAuthorizationOperationPath(), operation.id);
-    }
-}
-export async function startDaemon(args) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    const installationId = stored.installationId ?? randomUUID();
-    const configPath = getConfigPath();
-    const endpointProfile = stored.endpointProfile ?? resolveEndpointProfile(args);
-    const daemonSessionId = randomUUID();
-    let heartbeatSeq = 0;
-    const runtimeId = argValue(args, "--runtime-id") ?? process.env.ALAN_RUNTIME_ID ?? stored.runtimeId;
-    const runtimeTokenOverride = argValue(args, "--token") ?? process.env.ALAN_RUNTIME_TOKEN;
-    let runtimeToken = runtimeTokenOverride ?? stored.runtimeToken;
-    const runtimeRenewalToken = runtimeTokenOverride ? undefined : stored.runtimeRenewalToken;
-    const wsUrlOverride = argValue(args, "--ws-url") ?? process.env.ALAN_WS_URL;
-    // Explicit CLI/env overrides are trusted as-is; only the stored config is
-    // validated against its claimed profile and self-healed when it disagrees.
-    const endpointMismatch = wsUrlOverride
-        ? null
-        : checkStoredEndpointConsistency(stored, readEndpointDefaults());
-    let wsUrl = wsUrlOverride ?? stored.wsUrl;
-    if (endpointMismatch && stored.wsUrl && stored.wsUrl !== endpointMismatch.expectedWsUrl) {
-        console.warn("[alan-agent] Stored config does not match its endpoint profile — connecting with the profile endpoints instead. Re-run setup to repair the stored config.", { configPath: getConfigPath(), detail: endpointMismatch.detail });
-        wsUrl = endpointMismatch.expectedWsUrl;
-    }
-    let localApiPort = getLocalApiPort(args, stored);
-    const localApiToken = stored.localApiToken ?? randomBytes(24).toString("hex");
-    const localServiceId = stored.localServiceId ?? randomUUID();
-    const localServiceSecret = stored.localServiceSecret ?? randomBytes(32).toString("base64url");
-    const localServiceStartedAtMs = Date.now();
-    const eventSpoolKey = stored.eventSpoolKey ?? randomBytes(32).toString("base64url");
-    if (stored.daemonEpoch !== undefined &&
-        (!Number.isSafeInteger(stored.daemonEpoch) ||
-            stored.daemonEpoch < 0 ||
-            stored.daemonEpoch >= Number.MAX_SAFE_INTEGER)) {
-        throw new Error("daemon config contains an invalid durable epoch; repair the runtime config");
-    }
-    const daemonEpoch = (stored.daemonEpoch ?? 0) + 1;
-    if (!runtimeId || !runtimeToken || !wsUrl) {
-        throw new Error("daemon requires runtimeId, runtime token, and wsUrl. Run setup first or pass --runtime-id/--token/--ws-url.");
-    }
-    const startupLeaseResult = acquireLocalDaemonMaintenanceLease(configPath, "daemon_startup", 60_000);
-    if (!startupLeaseResult.acquired) {
-        throw new Error(startupLeaseResult.lease.reason === "credential_cleanup"
-            ? "Cannot start the daemon while credential cleanup is in progress"
-            : "Another process is already starting or maintaining this daemon config");
-    }
-    let ownerLeaseResult;
-    try {
-        ownerLeaseResult = await acquireLocalDaemonOwnerLease({
-            configPath,
-            daemonSessionId,
-            runtimeId,
-            localServiceId,
-            localApiPort,
-            localApiToken,
-            storedLocalApiPort: stored.localApiPort,
-            storedLocalApiToken: stored.localApiToken,
-        });
-    }
-    catch (error) {
-        releaseLocalDaemonMaintenanceLease(configPath, startupLeaseResult.lease.id);
-        throw error;
-    }
-    if (!ownerLeaseResult.acquired) {
-        releaseLocalDaemonMaintenanceLease(configPath, startupLeaseResult.lease.id);
-        throw new Error(`Another process already owns this daemon config (pid ${ownerLeaseResult.lease.pid})`);
-    }
-    let ownerLease = ownerLeaseResult.lease;
-    let startupLeaseHeld = true;
-    let ownerLeaseHeld = true;
-    const releaseStartupLease = () => {
-        if (!startupLeaseHeld)
-            return;
-        startupLeaseHeld = false;
-        releaseLocalDaemonMaintenanceLease(configPath, startupLeaseResult.lease.id);
-    };
-    const releaseOwnerLease = () => {
-        if (!ownerLeaseHeld)
-            return;
-        ownerLeaseHeld = false;
-        releaseLocalDaemonOwnerLease(configPath, ownerLease.id);
-    };
-    // Observable so anything derived from "is any run active?" stays correct.
-    // Membership changes from dispatch, completion, abort, reconnect
-    // reconciliation, the local HTTP API and shutdown; subscribing to the map
-    // itself means none of those sites can forget to update the derived state.
-    const activeAgents = new ObservableMap();
-    const pendingRunStarts = new DurablePendingRunStarts(`${configPath}.pending-runs.json`, daemonSessionId);
-    const maintenanceReason = () => readLocalDaemonMaintenanceLease(configPath)?.reason;
-    const runStartGate = new RunStartGate();
-    let disconnectedSinceMs = null;
-    let lastConnectError = null;
-    // Machine-readable code from the backend's socket.io middleware error
-    // (err.data.code), e.g. "invalid_runtime_token". Preferred over regex on the
-    // human-readable message; older servers that don't set it leave this null.
-    let lastConnectErrorCode = null;
-    const pendingDeliveryLost = [];
-    const currentCapabilities = () => discoverCapabilities();
-    const currentMetadata = async () => ({
-        ...(await collectRuntimeMetadataWithProviderLimits()),
-        installationId,
-    });
-    const recentLogs = [];
-    const pushLog = (message) => {
-        recentLogs.push(`${new Date().toISOString()} ${message}`);
-        if (recentLogs.length > 200)
-            recentLogs.splice(0, recentLogs.length - 200);
-    };
-    // Hold an OS sleep assertion for exactly as long as at least one run is
-    // active. Without this the machine idle-sleeps mid-run, freezing the socket,
-    // the heartbeat and the provider CLI together until the backend watchdog
-    // fails the run as unresponsive.
-    const sleepInhibitor = new SleepInhibitor({ log: pushLog });
-    activeAgents.onChange = () => {
-        sleepInhibitor.setActive(activeAgents.size > 0);
-    };
-    if (sleepInhibitor.backendNames().length > 0) {
-        pushLog(`sleep-inhibitor backends=${sleepInhibitor.backendNames().join(",")}`);
-    }
-    // Per-run Alan MCP config is written into shared CLI config (e.g.
-    // ~/.claude.json) at run start and carries a run-scoped x-alan-run-reference.
-    // It must be removed once no run needs it, or the inactive reference lingers
-    // and poisons unrelated local CLI sessions (401 "Inactive MCP run reference").
-    // Refcount by runId so concurrent runs sharing one home don't tear the entry
-    // out from under each other — only the last run out cleans up.
-    const alanMcpRegisteredRuns = new Set();
-    const alanMcpRegisteredBackends = new Set();
-    const finalizeAlanMcpForRun = (runId) => {
-        if (!alanMcpRegisteredRuns.delete(runId))
-            return;
-        if (alanMcpRegisteredRuns.size > 0)
-            return;
-        const backends = [...alanMcpRegisteredBackends];
-        alanMcpRegisteredBackends.clear();
-        void (async () => {
-            for (const backend of backends) {
-                try {
-                    const { removedPaths } = await unregisterAlanMcp(backend);
-                    if (removedPaths.length > 0) {
-                        pushLog(`mcp-unregistered backend=${backend} run=${runId}`);
-                    }
-                }
-                catch (err) {
-                    // Best-effort: the next run's registration overwrites the entry.
-                    pushLog(`mcp-unregister-failed backend=${backend} ${err.message}`);
-                }
-            }
-        })();
-    };
-    const workspaceAccessTracker = new WorkspaceAccessTracker();
-    const recheckWorkspaceIssue = () => {
-        const previousPath = workspaceAccessTracker.recoveryPath();
-        const readiness = workspaceAccessTracker.recheck();
-        if (previousPath && readiness?.ready)
-            pushLog(`workspace-access-restored path=${previousPath}`);
-        return workspaceAccessTracker.recoveryPath() ?? undefined;
-    };
-    let eventOutbox;
-    let runJournal;
-    try {
-        eventOutbox = new EncryptedEventOutbox(`${configPath}.event-outbox.enc`, eventSpoolKey, pushLog);
-        runJournal = new RuntimeRunJournal(`${configPath}.run-journal.json`);
-    }
-    catch (error) {
-        releaseOwnerLease();
-        releaseStartupLease();
-        throw error;
-    }
-    const workspaceRelocations = new Map();
-    for (const relocation of stored.workspaceRelocations ?? []) {
-        if (relocation?.conversationId &&
-            relocation.runId &&
-            relocation.previousPath &&
-            relocation.canonicalPath) {
-            workspaceRelocations.set(resolve(relocation.previousPath), relocation);
-        }
-    }
-    if (stored.localApiPort !== localApiPort ||
-        stored.localApiToken !== localApiToken ||
-        stored.localServiceId !== localServiceId ||
-        stored.localServiceSecret !== localServiceSecret ||
-        stored.eventSpoolKey !== eventSpoolKey ||
-        stored.daemonEpoch !== daemonEpoch ||
-        stored.installationId !== installationId) {
-        // Persist only local API details plus first-run identity. Identity/wsUrl
-        // overrides from CLI args or env are per-invocation and must never clobber
-        // an existing stored config for the active profile.
-        try {
-            writeConfig({
-                ...stored,
-                runtimeId: stored.runtimeId ?? runtimeId,
-                runtimeToken: stored.runtimeToken ?? runtimeToken,
-                wsUrl: stored.wsUrl ?? wsUrl,
-                localApiPort,
-                localApiToken,
-                localServiceId,
-                localServiceSecret,
-                eventSpoolKey,
-                daemonEpoch,
-                installationId,
-            });
-        }
-        catch (error) {
-            releaseOwnerLease();
-            releaseStartupLease();
-            throw error;
-        }
-    }
-    let socket;
-    try {
-        socket = io(wsUrl, {
-            query: { type: "runtime", runtimeId, hostKind: "daemon", agentVersion: AGENT_VERSION },
-            auth: { token: runtimeToken },
-            transports: ["websocket"],
-            reconnection: true,
-            reconnectionAttempts: Infinity,
-            reconnectionDelay: 1000,
-            reconnectionDelayMax: 5000,
-            timeout: 20_000,
-            upgrade: false,
-            extraHeaders: { "ngrok-skip-browser-warning": "1" },
-        });
-        setConnectedRuntimeSocket(socket);
-    }
-    catch (error) {
-        releaseOwnerLease();
-        releaseStartupLease();
-        throw error;
-    }
-    let runtimeRenewalInFlight = null;
-    const renewRuntimeLease = () => {
-        if (runtimeRenewalInFlight)
-            return runtimeRenewalInFlight;
-        const attempt = (async () => {
-            if (!stored.apiUrl || !runtimeRenewalToken)
-                return false;
-            let response = null;
-            let transportError = null;
-            for (let retry = 1; retry <= 3; retry += 1) {
-                try {
-                    response = await fetch(`${stored.apiUrl}/public/runtimes/${runtimeId}/tokens/renew`, {
-                        method: "POST",
-                        headers: {
-                            authorization: `Bearer ${runtimeRenewalToken}`,
-                            "content-type": "application/json",
-                        },
-                        body: "{}",
-                        signal: AbortSignal.timeout(10_000),
-                    });
-                    transportError = null;
-                }
-                catch (error) {
-                    response = null;
-                    transportError = error;
-                }
-                const retriable = !response || response.status === 408 || response.status === 429 || response.status >= 500;
-                if (!retriable || retry === 3)
-                    break;
-                await sleep(retry * 250);
-            }
-            if (!response) {
-                lastConnectErrorCode = "backend_unreachable";
-                lastConnectError = `Runtime renewal could not reach Alan: ${transportError instanceof Error ? transportError.message : String(transportError)}`;
-                pushLog(`runtime-renewal-transport-failed ${lastConnectError}`);
-                return false;
-            }
-            if (!response.ok) {
-                lastConnectErrorCode =
-                    response.status === 401
-                        ? "runtime_renewal_rejected"
-                        : response.status === 403
-                            ? "runtime_disabled"
-                            : response.status === 410
-                                ? "runtime_deleted"
-                                : response.status >= 500
-                                    ? "backend_unreachable"
-                                    : "runtime_renewal_failed";
-                lastConnectError = `Runtime renewal failed: ${response.status} ${await response.text()}`;
-                pushLog(`runtime-renewal-rejected ${lastConnectError}`);
-                return false;
-            }
-            const body = (await response.json());
-            if (typeof body.runtimeToken !== "string" || !body.runtimeToken.startsWith("alan_runtime_")) {
-                lastConnectErrorCode = "runtime_renewal_failed";
-                lastConnectError = "Runtime renewal returned an invalid access token";
-                pushLog("runtime-renewal-invalid-response");
-                return false;
-            }
-            const current = readConfig();
-            if (current.runtimeId !== runtimeId || current.runtimeRenewalToken !== runtimeRenewalToken) {
-                lastConnectErrorCode = "runtime_renewal_superseded";
-                lastConnectError = "Runtime credentials changed while renewal was in progress";
-                pushLog("runtime-renewal-superseded");
-                return false;
-            }
-            try {
-                writeConfig({ ...current, runtimeToken: body.runtimeToken });
-            }
-            catch (error) {
-                lastConnectErrorCode = "config_write_failed";
-                lastConnectError = `Runtime renewal could not save its replacement: ${error.message}`;
-                pushLog(`runtime-renewal-config-write-failed ${error.message}`);
-                return false;
-            }
-            runtimeToken = body.runtimeToken;
-            socket.auth = { token: body.runtimeToken };
-            lastConnectError = null;
-            lastConnectErrorCode = null;
-            pushLog("runtime-renewal-succeeded");
-            socket.connect();
-            return true;
-        })();
-        runtimeRenewalInFlight = attempt;
-        void attempt
-            .finally(() => {
-            if (runtimeRenewalInFlight === attempt)
-                runtimeRenewalInFlight = null;
-        })
-            .catch(() => { });
-        return attempt;
-    };
-    const relocationInFlight = new Set();
-    const persistWorkspaceRelocations = () => {
-        const current = readConfig();
-        writeConfig({
-            ...current,
-            workspaceRelocations: workspaceRelocations.size > 0 ? [...workspaceRelocations.values()] : undefined,
-        });
-    };
-    const flushWorkspaceRelocations = () => {
-        if (!socket.connected)
-            return;
-        for (const [key, relocation] of workspaceRelocations) {
-            if (relocationInFlight.has(key))
-                continue;
-            relocationInFlight.add(key);
-            socket.emit("runtime.workspace.relocated", relocation, (result) => {
-                relocationInFlight.delete(key);
-                if (!result?.ok || !result.persisted)
-                    return;
-                const current = workspaceRelocations.get(key);
-                if (current?.canonicalPath !== relocation.canonicalPath)
-                    return;
-                workspaceRelocations.delete(key);
-                try {
-                    persistWorkspaceRelocations();
-                    pushLog(`workspace-relocation-persisted path=${relocation.canonicalPath}`);
-                }
-                catch (error) {
-                    workspaceRelocations.set(key, relocation);
-                    pushLog(`workspace-relocation-ack-save-failed ${error.message}`);
-                }
-            });
-        }
-    };
-    const emitRunnerPresence = () => {
-        if (!socket.connected)
-            return;
-        reconcileActiveRuns({ activeAgents, pushLog });
-        heartbeatSeq += 1;
-        const runnerSummary = summarizeRunnerStatus({
-            connected: socket.connected,
-            activeAgents,
-            disconnectedSinceMs,
-            daemonSessionId,
-            daemonEpoch,
-            heartbeatSeq,
-            interruptedRunIds: runJournal.recoveredRunIds(),
-            endpointProfile,
-            configPath,
-            runtimeId,
-            runtimeAuthValid: Boolean(runtimeToken),
-            endpointMismatchDetail: endpointMismatch?.detail ?? null,
-            workspacePath: recheckWorkspaceIssue(),
-            maintenanceReason: maintenanceReason(),
-        });
-        void currentMetadata().then((metadata) => {
-            socket.emit("runtime.heartbeat", {
-                capabilities: currentCapabilities(),
-                metadata: {
-                    ...metadata,
-                    runnerStatus: runnerSummary.runnerStatus,
-                },
-            });
-        });
-    };
-    const heartbeat = setInterval(() => {
-        if (!socket.connected)
-            return;
-        emitRunnerPresence();
-        flushWorkspaceRelocations();
-    }, 15_000);
-    // Report host suspension to the backend.
-    //
-    // Sleep prevention cannot win every time (lid close on battery, forced
-    // sleep), and when the host freezes so does the socket, the heartbeat above
-    // and the provider CLI. The backend sees only silence and fails the run as
-    // unresponsive. Telling it "I was frozen for N ms" lets it grant the runtime
-    // a grace window instead of blaming the agent for a gap it did not cause.
-    //
-    // The wake is held until the socket is actually up: the suspension that needs
-    // reporting is precisely the one that killed the connection, so emitting
-    // eagerly would drop the message exactly when it matters.
-    let pendingWakeGapMs = null;
-    const flushWakeGap = () => {
-        if (pendingWakeGapMs === null || !socket.connected)
-            return;
-        const gapMs = pendingWakeGapMs;
-        pendingWakeGapMs = null;
-        socket.emit("runtime.wake", { gapMs });
-        pushLog(`runtime-wake reported gapMs=${gapMs}`);
-    };
-    const suspensionDetector = new SuspensionDetector({
-        onSuspensionDetected: (gapMs) => {
-            // Keep the longest gap if several elapse before we reconnect.
-            pendingWakeGapMs = Math.max(pendingWakeGapMs ?? 0, gapMs);
-            pushLog(`host-suspension detected gapMs=${gapMs}`);
-            flushWakeGap();
-        },
-    });
-    suspensionDetector.start();
-    void refreshProviderVersions();
-    const versionRefresh = setInterval(() => {
-        void refreshProviderVersions();
-    }, VERSION_REFRESH_INTERVAL_MS);
-    // How many consecutive TRANSIENT lease-probe failures (git slow/failed while
-    // the workspace path still exists) are tolerated before the run is failed.
-    // Definitive changes (path/repo/worktree/branch swap, genuinely-missing path)
-    // still fail on the first observation. See notes/agent-daemon-app-nap.md for
-    // why this — not a caffeinate/App-Nap exemption — is the right fix for OS
-    // throttling of the monitor's own timers.
-    const parsedMaxTransient = Number(process.env.ALAN_WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES);
-    const WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES = Number.isFinite(parsedMaxTransient) && parsedMaxTransient >= 1
-        ? Math.floor(parsedMaxTransient)
-        : 3;
-    const WORKSPACE_LEASE_FAILURE_BACKOFF_BASE_MS = 1_000;
-    const WORKSPACE_LEASE_FAILURE_BACKOFF_MAX_MS = 15_000;
-    const stopRunForWorkspaceLease = (runId, entry, failure) => {
-        entry.stage = "failed";
-        if (!entry.presenter.failWorkspaceLease(failure))
-            return;
-        entry.agent.kill();
-        activeAgents.delete(runId);
-        pushLog(`workspace-lease-lost run=${runId} code=${failure.code}`);
-    };
-    const leaseCheckPolicy = {
-        maxTransientFailures: WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES,
-        backoffBaseMs: WORKSPACE_LEASE_FAILURE_BACKOFF_BASE_MS,
-        backoffMaxMs: WORKSPACE_LEASE_FAILURE_BACKOFF_MAX_MS,
-    };
-    const verifyActiveWorkspaceLease = (runId, entry, nowMs) => {
-        const lease = entry.workspaceLease;
-        if (!lease)
-            return true;
-        const state = entry.leaseCheck ?? { ...FRESH_LEASE_MONITOR_STATE };
-        entry.leaseCheck = state;
-        // Backoff: under sustained transient failure, probe less often than every
-        // second so a contended disk / coalesced timer is not hammered each tick.
-        if (!isLeaseCheckDue(state, nowMs))
-            return true;
-        const decision = applyLeaseCheckResult({
-            state,
-            detailed: lease.verifyDetailed(),
-            nowMs,
-            policy: leaseCheckPolicy,
-        });
-        entry.leaseCheck = decision.state;
-        if (decision.action === "fail" && decision.failure) {
-            stopRunForWorkspaceLease(runId, entry, decision.failure);
-            return false;
-        }
-        if (decision.action === "transient" && decision.failure) {
-            pushLog(`workspace-lease-transient run=${runId} streak=${decision.state.transientStreak}/${WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES} code=${decision.failure.code} backoff_ms=${decision.backoffMs ?? 0}`);
-        }
-        return true;
-    };
-    const workspaceLeaseMonitor = setInterval(() => {
-        const nowMs = Date.now();
-        for (const [runId, entry] of activeAgents) {
-            verifyActiveWorkspaceLease(runId, entry, nowMs);
-        }
-    }, WORKSPACE_LEASE_CHECK_INTERVAL_MS);
-    workspaceLeaseMonitor.unref?.();
-    socket.on("connect", () => {
-        disconnectedSinceMs = null;
-        lastConnectError = null;
-        lastConnectErrorCode = null;
-        setConnectedRuntimeSocket(socket);
-        pushLog(`connected runtime=${runtimeId}`);
-        console.info("[alan-agent] Daemon connected", { runtimeId, wsUrl, version: AGENT_VERSION });
-        flushWorkspaceRelocations();
-        flushPendingDeliveryLostEvents({
-            socket,
-            activeAgents,
-            pending: pendingDeliveryLost,
-            eventOutbox,
-            pushLog,
-        });
-        reconcileActiveRuns({ activeAgents, pushLog });
-        void currentMetadata().then((metadata) => {
-            const runnerSummary = summarizeRunnerStatus({
-                connected: true,
-                activeAgents,
-                disconnectedSinceMs,
-                daemonSessionId,
-                daemonEpoch,
-                heartbeatSeq,
-                interruptedRunIds: runJournal.recoveredRunIds(),
-                endpointProfile,
-                configPath,
-                runtimeId,
-                runtimeAuthValid: Boolean(runtimeToken),
-                endpointMismatchDetail: endpointMismatch?.detail ?? null,
-                workspacePath: recheckWorkspaceIssue(),
-                maintenanceReason: maintenanceReason(),
-            });
-            socket.emit("runtime.hello", {
-                capabilities: currentCapabilities(),
-                metadata: {
-                    ...metadata,
-                    runnerStatus: runnerSummary.runnerStatus,
-                },
-            });
-            // Emitted after hello so the backend has already marked this runtime
-            // online and can attribute the wake to a known connection.
-            flushWakeGap();
-            scheduleRuntimeModelScan(() => Promise.resolve(metadata));
-        });
-    });
-    let lastConnectErrorLogAt = 0;
-    socket.on("connect_error", (error) => {
-        if (!socket.connected && disconnectedSinceMs === null)
-            disconnectedSinceMs = Date.now();
-        lastConnectError = error.message;
-        const errorCode = error?.data?.code;
-        // Middleware rejections carry a server code. A connect_error without one is
-        // a transport/service reachability failure, not evidence that the local
-        // daemon or Computer is broken.
-        lastConnectErrorCode =
-            typeof errorCode === "string" ? errorCode : classifyTransportFailure(error);
-        pushLog(`connect_error ${error.message}${lastConnectErrorCode ? ` code=${lastConnectErrorCode}` : ""}`);
-        if (lastConnectErrorCode === "invalid_runtime_token" && runtimeRenewalToken) {
-            void renewRuntimeLease().catch((renewalError) => {
-                lastConnectErrorCode = "runtime_renewal_failed";
-                lastConnectError = `Runtime renewal failed unexpectedly: ${renewalError.message}`;
-                pushLog(`runtime-renewal-unexpected-failure ${renewalError.message}`);
-            });
-            return;
-        }
-        const now = Date.now();
-        if (now - lastConnectErrorLogAt < 5000)
-            return;
-        lastConnectErrorLogAt = now;
-        const wsHint = isLocalEndpoint(wsUrl)
-            ? ` Nothing is listening at ${wsUrl}. For local dev run setup with --profile local and start the stack (WS on ws://localhost:8401).`
-            : ` Verify wsUrl in ${getConfigPath()} and that you can reach ${wsUrl}.`;
-        console.warn("[alan-agent] Daemon connection error:", `${error.message}.${wsHint}`);
-    });
-    socket.on("disconnect", (reason) => {
-        setConnectedRuntimeSocket(null);
-        relocationInFlight.clear();
-        eventOutbox.disconnect();
-        if (disconnectedSinceMs === null)
-            disconnectedSinceMs = Date.now();
-        pushLog(`disconnected ${reason}`);
-        console.info("[alan-agent] Daemon disconnected:", reason);
-        for (const [runId, entry] of activeAgents.entries()) {
-            if (entry.stage === "completed" ||
-                entry.stage === "failed" ||
-                entry.stage === "aborted" ||
-                entry.stage === "delivery_lost") {
-                continue;
-            }
-            entry.stage = "delivery_lost";
-            pendingDeliveryLost.push({ conversationId: entry.conversationId, runId });
-        }
-    });
-    socket.on("desktop:rpc", async (message) => {
-        if (!message?.id || !message.method)
-            return;
-        try {
-            const params = message.params ?? {};
-            const result = message.method === "worktree.ensure"
-                ? ensureWorktree(params)
-                : message.method === "worktree.remove_if_clean"
-                    ? removeWorktreesIfClean(params)
-                    : message.method === "worktree.migrate_to_checkout"
-                        ? migrateWorktreeToCheckout(params)
-                        : message.method === "worktree.migration_preflight"
-                            ? preflightLocalWorkspaceMigration(params)
-                            : message.method === "worktree.status"
-                                ? statusLocalWorkspace(params)
-                                : isBindingSwitchGitMethod(message.method)
-                                    ? await executeBindingSwitchGitRpc(message.method, params)
-                                    : (() => {
-                                        throw new Error(`Method not found: ${message.method}`);
-                                    })();
-            socket.emit("desktop:rpc", { jsonrpc: "2.0", id: message.id, result });
-        }
-        catch (error) {
-            const stableCode = error instanceof BindingSwitchGitError ? error.code : "runtime_operation_failed";
-            const stableDetails = error instanceof BindingSwitchGitError ? error.details : undefined;
-            socket.emit("desktop:rpc", {
-                jsonrpc: "2.0",
-                id: message.id,
-                error: {
-                    code: -32000,
-                    message: error.message,
-                    data: { ...stableDetails, code: stableCode },
-                },
-            });
-        }
-    });
-    socket.on("agent.execute", async (payload) => {
-        if (!payload?.runId || !payload.conversationId || typeof payload.content !== "string") {
-            return;
-        }
-        const isTaskWorkspacePayload = Boolean(payload.worktreeInfo?.worktreePath || payload.worktreeInfo?.allWorktrees?.length);
-        if ((payload.worktreeInfo?.allWorktrees?.length ?? 0) > 1 ||
-            (isTaskWorkspacePayload && (payload.repoLocalPaths?.length ?? 0) > 1)) {
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: "A task worktree requires exactly one Git repository.",
-                code: "single_repository_worktree_required",
-            });
-            return;
-        }
-        const existingRun = activeAgents.get(payload.runId);
-        if (existingRun) {
-            if (existingRun.conversationId !== payload.conversationId) {
-                socket.emit("agent.rejected", {
-                    runId: payload.runId,
-                    message: "Run ID is already bound to another conversation",
-                    code: "run_id_conflict",
-                });
-                return;
-            }
-            // The backend may redeliver after the original acceptance ACK is lost.
-            // Re-acknowledge the existing execution without spawning a second agent.
-            pushLog(`duplicate dispatch re-acknowledged run=${payload.runId}`);
-            socket.emit("agent.accepted", { runId: payload.runId });
-            return;
-        }
-        const preflightingConversationId = pendingRunStarts.get(payload.runId);
-        if (preflightingConversationId) {
-            if (preflightingConversationId !== payload.conversationId) {
-                socket.emit("agent.rejected", {
-                    runId: payload.runId,
-                    message: "Run ID is already bound to another conversation",
-                    code: "run_id_conflict",
-                });
-            }
-            return;
-        }
-        const recoveredRun = runJournal.get(payload.runId);
-        if (recoveredRun) {
-            if (recoveredRun.conversationId !== payload.conversationId) {
-                socket.emit("agent.rejected", {
-                    runId: payload.runId,
-                    message: "Run ID is already bound to another conversation",
-                    code: "run_id_conflict",
-                });
-                return;
-            }
-            const recovery = runJournal.assessRecovery(payload.runId, (pid) => isProviderProcessAlive(pid));
-            pushLog(`recovered dispatch fenced run=${payload.runId} recovery=${recovery?.reason ?? "unknown"}${recovery && "providerPid" in recovery ? ` pid=${recovery.providerPid}` : ""}`);
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: "This run was interrupted by a daemon restart and will not be executed twice.",
-                code: "run_interrupted_by_restart",
-            });
-            return;
-        }
-        const maintenanceLease = readLocalDaemonMaintenanceLease(configPath);
-        if (maintenanceLease) {
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: maintenanceLease.reason === "credential_cleanup"
-                    ? "This computer is finishing logout and cannot start another run."
-                    : "This computer is under short-lived maintenance; retry shortly.",
-                code: maintenanceLease.reason === "credential_cleanup"
-                    ? "runtime_logout_pending"
-                    : "runtime_maintenance_pending",
-            });
-            return;
-        }
-        const backendKind = normalizeBackendKind(payload.backendKind);
-        let runtimeCommand = resolveBackendRuntimeCommand(backendKind ?? payload.backendKind);
-        if (!runtimeCommand && backendKind) {
-            // A cached negative resolution is never authoritative for a run: startup
-            // provider discovery can probe a CLI before the sandbox's deferred
-            // installer drops the binary, and that miss must not reject runs after
-            // the binary lands. Drop the cache entry and re-resolve from disk.
-            runtimeCommand = revalidateBackendRuntimeCommand(backendKind);
-        }
-        if (!runtimeCommand && backendKind && canInstallProviderCli(backendKind)) {
-            // Fresh sandboxes install provider CLIs DEFERRED (~40-90s after agents can
-            // start), so an early run can race the installer and hit a missing binary.
-            // Install the pinned CLI on demand (at most once per daemon lifetime) and
-            // re-resolve before rejecting the run. No presenter exists pre-accept, so
-            // installation progress surfaces through the daemon log only. Fence the
-            // runId while awaiting so a backend redelivery of the same dispatch does
-            // not start a second execution once the install completes.
-            pendingRunStarts.set(payload.runId, payload.conversationId);
-            try {
-                const installed = await ensureProviderCliInstalled(backendKind, {
-                    notify: (message) => {
-                        pushLog(message);
-                        console.info(`[alan-agent] ${message}`);
-                    },
-                });
-                if (installed) {
-                    runtimeCommand = revalidateBackendRuntimeCommand(backendKind);
-                }
-            }
-            finally {
-                pendingRunStarts.delete(payload.runId);
-            }
-        }
-        if (!runtimeCommand && backendKind) {
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: `CLI command not found for ${backendKind}. Install the provider CLI and restart the daemon.`,
-                code: "provider_unavailable",
-            });
-            return;
-        }
-        let cwd = resolveRuntimeCwd(payload);
-        const explicitWorkspacePath = payload.projectPath ??
-            payload.worktreeInfo?.worktreePath ??
-            payload.worktreeInfo?.allWorktrees?.[0]?.worktreePath;
-        const workspaceRequired = Boolean(explicitWorkspacePath);
-        if (isAlanDefaultWorkspace(payload.projectPath)) {
-            try {
-                mkdirSync(cwd, { recursive: true });
-            }
-            catch {
-                // inspectWorkspaceReadiness below preserves the filesystem cause.
-            }
-        }
-        let workspaceReadiness = inspectWorkspaceReadiness(workspaceRequired ? cwd : undefined);
-        const expectedRepoUrls = [
-            ...(payload.repoLocalPaths ?? [])
-                .filter((repo) => explicitWorkspacePath ? resolve(repo.localPath) === resolve(explicitWorkspacePath) : false)
-                .map((repo) => repo.repoUrl),
-            ...(payload.localRepoUrls ?? []),
-        ];
-        if (workspaceReadiness.code === "workspace_missing" &&
-            explicitWorkspacePath &&
-            !payload.worktreeInfo) {
-            const previousPath = resolve(explicitWorkspacePath);
-            const remembered = workspaceRelocations.get(previousPath);
-            const rememberedPath = remembered?.canonicalPath;
-            const relocated = rememberedPath &&
-                workspaceMatchesExpectedRepositories({
-                    workspacePath: rememberedPath,
-                    expectedRepoUrls,
-                })
-                ? resolve(rememberedPath)
-                : discoverRelocatedWorkspace({
-                    missingPath: explicitWorkspacePath,
-                    approvedWorkspacePaths: payload.approvedWorkspacePaths,
-                    expectedRepoUrls,
-                });
-            if (relocated) {
-                if (!remembered || resolve(remembered.canonicalPath) !== relocated) {
-                    workspaceRelocations.set(previousPath, {
-                        conversationId: payload.conversationId,
-                        runId: payload.runId,
-                        previousPath,
-                        canonicalPath: relocated,
-                    });
-                    try {
-                        persistWorkspaceRelocations();
-                    }
-                    catch (error) {
-                        workspaceRelocations.delete(previousPath);
-                        socket.emit("agent.rejected", {
-                            runId: payload.runId,
-                            message: `Recovered project path could not be saved safely: ${error.message}`,
-                            code: "workspace_relocation_persist_failed",
-                        });
-                        return;
-                    }
-                }
-                cwd = relocated;
-                workspaceReadiness = inspectWorkspaceReadiness(cwd);
-                pushLog(`workspace-relocated run=${payload.runId} path=${relocated}`);
-                flushWorkspaceRelocations();
-            }
-        }
-        if (workspaceReadiness.ready && expectedRepoUrls.length > 0 && !isAlanDefaultWorkspace(cwd)) {
-            // For multi-worktree tasks the cwd is the non-git parent CONTAINER of the
-            // per-repo worktrees (resolveRuntimeCwd → dirname(allWorktrees[0])), so a
-            // git-identity check on the cwd itself always fails. Verify each worktree
-            // path instead — every one must resolve to an expected repository. Single
-            // (or no) worktree tasks fall back to checking the cwd directly.
-            const worktreePaths = payload.worktreeInfo?.allWorktrees
-                ?.map((worktree) => worktree.worktreePath)
-                .filter((worktreePath) => Boolean(worktreePath));
-            const repositoryMismatch = worktreePaths && worktreePaths.length > 0
-                ? worktreePaths.some((worktreePath) => !workspaceMatchesExpectedRepositories({
-                    workspacePath: worktreePath,
-                    expectedRepoUrls,
-                }))
-                : !workspaceMatchesExpectedRepositories({ workspacePath: cwd, expectedRepoUrls });
-            if (repositoryMismatch) {
-                socket.emit("agent.rejected", {
-                    runId: payload.runId,
-                    message: "This folder belongs to a different repository. Choose the correct project folder and try again.",
-                    code: "workspace_repository_mismatch",
-                });
-                return;
-            }
-        }
-        if (workspaceRequired)
-            workspaceAccessTracker.track(cwd, workspaceReadiness);
-        const runnerSummary = summarizeRunnerStatus({
-            connected: socket.connected,
-            activeAgents,
-            disconnectedSinceMs,
-            daemonSessionId,
-            daemonEpoch,
-            heartbeatSeq,
-            interruptedRunIds: runJournal.recoveredRunIds(),
-            endpointProfile,
-            configPath,
-            runtimeId,
-            runtimeAuthValid: Boolean(runtimeToken),
-            endpointMismatchDetail: endpointMismatch?.detail ?? null,
-            workspacePath: recheckWorkspaceIssue(),
-            maintenanceReason: maintenanceReason(),
-            nowMs: Date.now(),
-        });
-        if (!socket.connected) {
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: "Daemon is disconnected from backend",
-                code: "ws_disconnected",
-            });
-            return;
-        }
-        if (!runnerSummary.acceptingRuns) {
-            const primaryIssue = pickPrimaryReadinessIssue(runnerSummary.runnerStatus.computerReadiness ?? []);
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: primaryIssue?.message ??
-                    (runnerSummary.activeRunCount > 0
-                        ? "Daemon is busy with an active run"
-                        : "Daemon is not ready to accept runs"),
-                code: primaryIssue?.code ??
-                    (runnerSummary.activeRunCount > 0 ? "runner_busy" : "runner_not_ready"),
-            });
-            return;
-        }
-        if (!workspaceReadiness.ready) {
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: workspaceReadiness.message,
-                code: workspaceReadiness.code ?? "workspace_missing",
-            });
-            return;
-        }
-        pendingRunStarts.set(payload.runId, payload.conversationId);
-        const rawReleaseRunStart = await runStartGate.acquire();
-        let runStartReleased = false;
-        const releaseRunStart = () => {
-            if (runStartReleased)
-                return;
-            runStartReleased = true;
-            rawReleaseRunStart();
-        };
-        if (!socket.connected) {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: "Daemon disconnected while preparing the provider",
-                code: "ws_disconnected",
-            });
-            return;
-        }
-        const correlation = correlationLogFields({
-            taskId: payload.taskId ?? payload.taskMeta?.id,
-            conversationId: payload.conversationId,
-            runId: payload.runId,
-            messageId: payload.messageId,
-            cloudEnvironmentId: payload.cloudEnvironmentId,
-            backendKind,
-            agentVersion: AGENT_VERSION,
-        });
-        const alanMcp = payload.alanMcp;
-        if (!alanMcp) {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            pushLog(`mcp-contract-missing run=${payload.runId}`);
-            console.warn("[alan-agent] Run-scoped Alan MCP contract is missing", correlation);
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: "Alan did not receive the run-scoped tools contract. Start a new run and try again.",
-                code: "mcp_config_invalid",
-            });
-            return;
-        }
-        // Auth status (~3s for Cursor) and MCP file prep used to run sequentially
-        // before accept. Overlap them; MCP registration itself is file-first so it
-        // no longer awaits a live `mcp list` on the critical path.
-        const authPromise = backendKind && runtimeCommand && !payload.providerApiKey
-            ? preflightProviderAuth({
-                backendKind,
-                executable: runtimeCommand,
-                env: getDaemonCliEnvironment(),
-            }).catch(() => ({ status: "unknown" }))
-            : Promise.resolve({ status: "unknown" });
-        const mcpPromise = backendKind
-            ? prepareAlanMcpForRun(backendKind, alanMcp, {
-                // Observe mode resolves after the run has already been accepted, so
-                // the verdict is logged here rather than folded into the result.
-                onObservedResult: (failure) => {
-                    pushLog(`mcp-readiness-observed run=${payload.runId} code=${failure.code}`);
-                    console.warn("[alan-agent] Alan MCP readiness observed failure", {
-                        ...correlation,
-                        code: failure.code,
-                        stage: failure.stage,
-                    });
-                },
-            })
-            : Promise.resolve(null);
-        const [providerAuth, mcpOutcome] = await Promise.all([authPromise, mcpPromise]);
-        if (providerAuth.status === "auth_required") {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: providerAuth.message ?? "The selected provider requires sign-in.",
-                code: "provider_auth_required",
-            });
-            return;
-        }
-        if (backendKind && mcpOutcome && !mcpOutcome.ok) {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            const readinessCode = mcpOutcome.code;
-            pushLog(`mcp-readiness-failed run=${payload.runId} code=${readinessCode}`);
-            console.warn("[alan-agent] Required Alan MCP readiness failed", {
-                ...correlation,
-                code: readinessCode,
-                stage: mcpOutcome.stage,
-            });
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: mcpOutcome.message,
-                code: readinessCode.replace(/^app\./, "").replaceAll(".", "_"),
-            });
-            return;
-        }
-        if (backendKind && alanMcp && mcpOutcome && mcpOutcome.ok && "paths" in mcpOutcome) {
-            pushLog(`mcp-ready run=${payload.runId} verification=${"verification" in mcpOutcome ? mcpOutcome.verification : "file"}`);
-            console.info("[alan-agent] Alan MCP ready for run", {
-                ...correlation,
-                paths: mcpOutcome.paths,
-                verification: "verification" in mcpOutcome ? mcpOutcome.verification : "file",
-                providerLoadStatus: "providerLoadStatus" in mcpOutcome ? mcpOutcome.providerLoadStatus : undefined,
-            });
-        }
-        // Close the TOCTOU window for a dispatch that began preflight just before
-        // an external watchdog acquired maintenance. No journal/provider side
-        // effects have started yet, so it is safe to reject here.
-        const maintenanceLeaseBeforeJournal = readLocalDaemonMaintenanceLease(configPath);
-        if (maintenanceLeaseBeforeJournal) {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: maintenanceLeaseBeforeJournal.reason === "credential_cleanup"
-                    ? "This computer is finishing logout and cannot start another run."
-                    : "This computer is under short-lived maintenance; retry shortly.",
-                code: maintenanceLeaseBeforeJournal.reason === "credential_cleanup"
-                    ? "runtime_logout_pending"
-                    : "runtime_maintenance_pending",
-            });
-            return;
-        }
-        try {
-            runJournal.record({
-                runId: payload.runId,
-                conversationId: payload.conversationId,
-                acceptedAtMs: Date.now(),
-            });
-        }
-        catch {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            pushLog(`run-journal-write-failed run=${payload.runId}`);
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: "Alan could not safely record this run before starting it. Check disk access.",
-                code: "run_journal_unavailable",
-            });
-            return;
-        }
-        socket.emit("agent.accepted", { runId: payload.runId });
-        pushLog(`accepted run=${payload.runId}`);
-        console.info("[alan-agent] Agent run accepted", correlation);
-        // Shared-checkout runs (no worktree): put the checkout(s) onto the task's
-        // working branch cut from base, so the agent never commits onto the base
-        // branch directly. Best-effort — a dirty tree is left untouched.
-        if (!payload.worktreeInfo?.worktreePath && payload.sharedCheckout?.branchName) {
-            const repoTargets = resolveSharedCheckoutTargets({
-                cwd,
-                sharedCheckout: payload.sharedCheckout,
-            });
-            for (const { repoPath, baseBranch } of repoTargets) {
-                try {
-                    const result = ensureSharedCheckoutBranch({
-                        repoPath,
-                        branchName: payload.sharedCheckout.branchName,
-                        baseBranch,
-                    });
-                    if (!result.checkedOut) {
-                        pushLog(`shared-branch skipped run=${payload.runId} ${repoPath}: ${result.reason}`);
-                    }
-                }
-                catch (error) {
-                    pushLog(`shared-branch error run=${payload.runId} ${repoPath} ${error.message}`);
-                }
-            }
-        }
-        const workspaceLeaseCapture = WorkspaceRunLease.capture(resolveWorkspaceRunLeaseTargets(payload, cwd, expectedRepoUrls.length > 0));
-        if (workspaceLeaseCapture.failure) {
-            const failure = workspaceLeaseCapture.failure;
-            const runFailure = buildApplicationRunFailure({
-                conversationId: payload.conversationId,
-                runId: payload.runId,
-                code: "app.workspace.missing",
-                detail: failure.message,
-                component: "agent-manager-workspace-lease",
-                phase: "dispatch",
-            });
-            for (const event of runFailure.events) {
-                eventOutbox.enqueue(payload.conversationId, payload.runId, event);
-            }
-            eventOutbox.flush(socket);
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            try {
-                runJournal.remove(payload.runId);
-            }
-            catch {
-                pushLog(`run-journal-remove-failed run=${payload.runId}`);
-            }
-            pushLog(`workspace-lease-unavailable run=${payload.runId} code=${failure.code}`);
-            return;
-        }
-        const nowMs = Date.now();
-        const touchActivity = () => {
-            const entry = activeAgents.get(payload.runId);
-            if (entry)
-                entry.lastActivityAtMs = Date.now();
-        };
-        const releaseActiveRun = () => {
-            if (!activeAgents.delete(payload.runId))
-                return;
-            console.info("[alan-agent] Agent run finished", correlation);
-        };
-        const presenter = new RuntimePresenter(socket, payload.conversationId, payload.runId, eventOutbox, cwd, touchActivity, releaseActiveRun, () => {
-            const entry = activeAgents.get(payload.runId);
-            if (entry)
-                entry.stage = "running";
-        }, () => {
-            const entry = activeAgents.get(payload.runId);
-            return entry ? verifyActiveWorkspaceLease(payload.runId, entry, Date.now()) : false;
-        }, () => {
-            if (backendKind && runtimeCommand) {
-                invalidateProviderAuthPreflight(backendKind, runtimeCommand);
-            }
-        }, backendKind);
-        let agent;
-        try {
-            agent = new CoreAgent(presenter, {
-                backendKind,
-                runtimeCommand,
-                providerApiKey: payload.providerApiKey,
-                onProviderSpawned: (pid) => {
-                    releaseRunStart();
-                    const entry = activeAgents.get(payload.runId);
-                    if (!entry)
-                        return;
-                    entry.providerPid = pid;
-                    entry.stage = "provider_started";
-                    entry.lastActivityAtMs = Date.now();
-                    try {
-                        runJournal.recordProviderSpawned(payload.runId, pid, entry.lastActivityAtMs);
-                    }
-                    catch {
-                        // The accepted binding is already durable and continues to fence
-                        // redelivery. PID evidence is diagnostic only, so never kill or
-                        // fail a running provider because this optional update failed.
-                        pushLog(`run-journal-provider-evidence-write-failed run=${payload.runId}`);
-                    }
-                },
-            });
-        }
-        catch (error) {
-            pendingRunStarts.delete(payload.runId);
-            releaseRunStart();
-            try {
-                runJournal.remove(payload.runId);
-            }
-            catch {
-                pushLog(`run-journal-remove-failed run=${payload.runId}`);
-            }
-            const message = error instanceof Error ? error.message : String(error);
-            socket.emit("agent.rejected", {
-                runId: payload.runId,
-                message: `Provider startup failed: ${message}`,
-                code: "provider_start_failed",
-            });
-            return;
-        }
-        activeAgents.set(payload.runId, {
-            agent,
-            presenter,
-            lastActivityAtMs: nowMs,
-            acceptedAtMs: nowMs,
-            stage: "provider_starting",
-            providerPid: null,
-            conversationId: payload.conversationId,
-            workspaceLease: workspaceLeaseCapture.lease,
-        });
-        pendingRunStarts.delete(payload.runId);
-        // Track the per-run Alan MCP registration only now that every early-return
-        // gate has passed and the run is committed to agent.run(); its .finally()
-        // is the single teardown site, so the refcount can never leak.
-        if (payload.alanMcp && backendKind) {
-            alanMcpRegisteredRuns.add(payload.runId);
-            alanMcpRegisteredBackends.add(backendKind);
-        }
-        void agent
-            .run({
-            task: payload.content,
-            maxIterations: payload.maxIterations ?? 50,
-            teamPath: cwd,
-            cwd,
-            backendKind,
-            runtimeCommand,
-            agentId: payload.agentId,
-            agentPrompt: payload.agentPrompt,
-            mode: (payload.mode ?? "agent"),
-            selectedModel: payload.model,
-            selectedContextWindow: payload.selectedContextWindow ?? null,
-            selectedEffortLevel: payload.selectedEffortLevel ?? null,
-            providerSessionId: payload.providerSessionId,
-            resumeFallbackContext: payload.resumeFallbackContext,
-            taskMeta: payload.taskMeta,
-            prMeta: payload.prMeta,
-            conversationId: payload.conversationId,
-            alanMcp: payload.alanMcp,
-            taskId: payload.taskId ?? payload.taskMeta?.id,
-            teamId: payload.teamId,
-            currentUser: payload.currentUser,
-            workflowTools: payload.workflowTools,
-            images: payload.images,
-            files: payload.files,
-        })
-            .catch((error) => {
-            if (presenter.isTerminalFenced())
-                return;
-            const message = error instanceof Error ? error.message : String(error);
-            pushLog(`failed run=${payload.runId} ${message}`);
-            console.error("[alan-agent] Agent run failed", {
-                ...correlation,
-                error: message,
-            });
-            // Mid-run sign-out (or expired CLI session) must drop sticky ready so
-            // the next send re-probes and surfaces provider_auth_required cleanly
-            // instead of accepting again and failing the same way.
-            if (backendKind && runtimeCommand && looksLikeProviderAuthFailure(message)) {
-                invalidateProviderAuthPreflight(backendKind, runtimeCommand);
-            }
-            presenter.failApplicationProblem({
-                code: "app.internal",
-                detail: message,
-                component: "agent-manager-daemon",
-                phase: "delivery",
-            });
-        })
-            .finally(() => {
-            releaseRunStart();
-            try {
-                runJournal.remove(payload.runId);
-            }
-            catch {
-                pushLog(`run-journal-remove-failed run=${payload.runId}`);
-            }
-            finalizeAlanMcpForRun(payload.runId);
-            releaseActiveRun();
-        });
-    });
-    socket.on("agent.abort", (payload) => {
-        if (!payload?.runId)
-            return;
-        const entry = activeAgents.get(payload.runId);
-        if (!entry)
-            return;
-        // Only server-side timeouts are accepted as a non-user reason; everything
-        // else (including legacy payloads without a reason) is a user stop.
-        const reason = payload.reason === "watchdog_timeout" ? "watchdog_timeout" : "user";
-        abortActiveAgent(entry, { userInitiated: true, reason });
-        activeAgents.delete(payload.runId);
-        pushLog(`aborted run=${payload.runId} reason=${reason}`);
-        console.info("[alan-agent] Agent run aborted", {
-            runId: payload.runId,
-            reason,
-            agentVersion: AGENT_VERSION,
-        });
-    });
-    socket.on("agent.tool_response", (payload) => {
-        if (!payload?.toolId || typeof payload.response !== "string")
-            return;
-        // Scope delivery to the run/conversation that owns the answer. Fanning the write
-        // out to every active agent lets a foreign CLI accept it (sendToolResponse returns
-        // true on ANY successful stdin write, without verifying tool ownership) so the
-        // intended run never receives its answer and the foreign run gets a garbage
-        // tool_result. Prefer the explicit runId, then match conversationId, and only fall
-        // back to the full set when neither identifier is present (legacy payloads).
-        const entries = payload.runId
-            ? [[payload.runId, activeAgents.get(payload.runId)]]
-            : payload.conversationId
-                ? [...activeAgents.entries()].filter(([, entry]) => entry.conversationId === payload.conversationId)
-                : [...activeAgents.entries()];
-        const delivered = entries.some(([runId, entry]) => {
-            if (!entry || !verifyActiveWorkspaceLease(runId, entry, Date.now()))
-                return false;
-            return entry.agent.sendToolResponse(payload.toolId, payload.response) === true;
-        });
-        if (!delivered) {
-            pushLog(`tool_response missed tool=${payload.toolId}`);
-            // Surface the lost delivery to the conversation instead of hanging
-            // silently until a timeout: the agent process is gone or its stdin is
-            // closed, so the user's answer can only arrive as a new message.
-            // Resolve the conversation even when the runId is stale (e.g. the run was
-            // retried or already reaped) so the error still lands in the right chat.
-            const fallbackRun = [...activeAgents.entries()][0];
-            const resolvedRunId = payload.runId ?? entries[0]?.[0] ?? fallbackRun?.[0];
-            const conversationId = payload.conversationId ??
-                (payload.runId ? activeAgents.get(payload.runId)?.conversationId : undefined) ??
-                fallbackRun?.[1].conversationId;
-            if (conversationId && resolvedRunId) {
-                eventOutbox.enqueue(conversationId, resolvedRunId, {
-                    type: "error",
-                    message: "Your answer could not be delivered to the running agent — its input channel is closed. Send your answer as a new message to continue.",
-                });
-                eventOutbox.flush(socket);
-            }
-        }
-    });
-    socket.on("runtime.models.scan", (payload) => {
-        if (!payload?.requestId)
-            return;
-        const requestId = payload.requestId;
-        void (async () => {
-            try {
-                await runRuntimeModelScan({
-                    refreshModels: refreshProviderModels,
-                    getCapabilities: () => discoverCapabilities(),
-                    getBaseMetadata: async () => (await currentMetadata()),
-                    publishCredentials: (() => {
-                        const stored = readConfig();
-                        if (!stored.runtimeId || !stored.runtimeToken || !stored.apiUrl)
-                            return undefined;
-                        return {
-                            apiUrl: stored.apiUrl,
-                            runtimeId: stored.runtimeId,
-                            runtimeToken: stored.runtimeToken,
-                        };
-                    })(),
-                }, { force: payload.force === true || payload.refresh === true });
-                const metadata = await currentMetadata();
-                socket.emit("runtime.models.result", {
-                    requestId,
-                    capabilities: discoverCapabilities(),
-                    metadata: {
-                        ...metadata,
-                        ...buildModelsScanMetadata("complete"),
-                    },
-                });
-            }
-            catch (error) {
-                socket.emit("runtime.models.result", {
-                    requestId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        })();
-    });
-    socket.on("runtime.skills.scan", (payload) => {
-        if (!payload?.requestId)
-            return;
-        const requestId = payload.requestId;
-        try {
-            // A Project pinned to the default workspace arrives as the
-            // `alan://workspace` sentinel, not a path. Resolve it the same way
-            // dispatch does so those runtimes scan real skills instead of nothing.
-            const projectPath = isAlanDefaultWorkspace(payload.projectPath)
-                ? resolveAlanDefaultWorkspacePath()
-                : payload.projectPath;
-            const result = scanLocalSkillsCached(homedir(), projectPath, {
-                refresh: payload.refresh === true,
-            });
-            socket.emit("runtime.skills.result", {
-                requestId,
-                skills: result.skills,
-                errors: result.errors,
-            });
-        }
-        catch (error) {
-            socket.emit("runtime.skills.result", {
-                requestId,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    });
-    const adoptionChallenges = new Map();
-    const localServer = http.createServer((req, res) => {
-        if (req.method === "GET" && req.url === "/owner") {
-            const now = Date.now();
-            for (const [challenge, expiresAt] of adoptionChallenges) {
-                if (expiresAt <= now)
-                    adoptionChallenges.delete(challenge);
-            }
-            while (adoptionChallenges.size >= 32) {
-                const oldest = adoptionChallenges.keys().next().value;
-                if (!oldest)
-                    break;
-                adoptionChallenges.delete(oldest);
-            }
-            const challenge = randomBytes(24).toString("base64url");
-            adoptionChallenges.set(challenge, now + LOCAL_SERVICE_CHALLENGE_TTL_MS);
-            const unsignedOwner = {
-                version: LOCAL_SERVICE_OWNER_VERSION,
-                serviceId: localServiceId,
-                installationId,
-                runtimeId,
-                port: localApiPort,
-                pid: process.pid,
-                startedAtMs: localServiceStartedAtMs,
-                challenge,
-            };
-            res.writeHead(200, { "cache-control": "no-store", "content-type": "application/json" }).end(JSON.stringify({
-                ...unsignedOwner,
-                signature: signLocalServiceOwner(localServiceSecret, unsignedOwner),
-            }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/adopt") {
-            const serviceId = req.headers["x-alan-service-id"];
-            const challenge = req.headers["x-alan-adoption-challenge"];
-            const proof = req.headers["x-alan-adoption-proof"];
-            const expiresAt = typeof challenge === "string" ? adoptionChallenges.get(challenge) : undefined;
-            if (typeof challenge === "string")
-                adoptionChallenges.delete(challenge);
-            const expectedProof = typeof challenge === "string"
-                ? signLocalServiceAdoption(localServiceSecret, localServiceId, challenge)
-                : "";
-            if (serviceId !== localServiceId ||
-                typeof challenge !== "string" ||
-                typeof proof !== "string" ||
-                !expiresAt ||
-                expiresAt <= Date.now() ||
-                !equalHexDigest(proof, expectedProof)) {
-                res
-                    .writeHead(403, { "cache-control": "no-store", "content-type": "application/json" })
-                    .end(JSON.stringify({ error: "Owner proof rejected" }));
-                return;
-            }
-            res
-                .writeHead(200, { "cache-control": "no-store", "content-type": "application/json" })
-                .end(JSON.stringify({ localApiToken }));
-            return;
-        }
-        const auth = req.headers.authorization;
-        if (auth !== `Bearer ${localApiToken}`) {
-            res
-                .writeHead(401, { "content-type": "application/json" })
-                .end(JSON.stringify({ error: "Unauthorized" }));
-            return;
-        }
-        if (req.method === "GET" && req.url === "/status") {
-            reconcileActiveRuns({ activeAgents, pushLog });
-            const runnerSummary = summarizeRunnerStatus({
-                connected: socket.connected,
-                activeAgents,
-                disconnectedSinceMs,
-                daemonSessionId,
-                daemonEpoch,
-                heartbeatSeq,
-                interruptedRunIds: runJournal.recoveredRunIds(),
-                endpointProfile,
-                configPath,
-                runtimeId,
-                runtimeAuthValid: Boolean(runtimeToken),
-                endpointMismatchDetail: endpointMismatch?.detail ?? null,
-                workspacePath: recheckWorkspaceIssue(),
-                maintenanceReason: maintenanceReason(),
-            });
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
-                configured: true,
-                runtimeId,
-                wsUrl,
-                connected: socket.connected,
-                activeRunIds: runnerSummary.activeRunIds,
-                activeRunCount: runnerSummary.activeRunCount,
-                acceptingRuns: runnerSummary.acceptingRuns,
-                recovering: runnerSummary.recovering,
-                restartRecommended: runnerSummary.restartRecommended,
-                staleRunCount: runnerSummary.staleRunCount,
-                lastRunActivityAtMs: runnerSummary.lastRunActivityAtMs,
-                disconnectedSinceMs: runnerSummary.disconnectedSinceMs,
-                lastConnectError,
-                lastConnectErrorCode,
-                daemonSessionId,
-                heartbeatSeq,
-                endpointProfile,
-                configPath,
-                runnerStatus: runnerSummary.runnerStatus,
-                computerReadiness: runnerSummary.runnerStatus.computerReadiness,
-                workspaceRecoveryPath: workspaceAccessTracker.recoveryPath(),
-                localApiPort,
-                localServiceId,
-                version: AGENT_VERSION,
-            }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/prepare_logout") {
-            const acquired = acquireLocalDaemonMaintenanceLease(configPath, "credential_cleanup", 60_000);
-            if (!acquired.acquired && acquired.lease.reason !== "credential_cleanup") {
-                res
-                    .writeHead(423, { "content-type": "application/json" })
-                    .end(JSON.stringify({ error: "maintenance_in_progress" }));
-                return;
-            }
-            reconcileActiveRuns({ activeAgents, pushLog });
-            const activeRunCount = activeAgents.size + pendingRunStarts.size;
-            emitRunnerPresence();
-            if (activeRunCount > 0) {
-                res
-                    .writeHead(409, { "content-type": "application/json" })
-                    .end(JSON.stringify({ error: "active_runs", activeRunCount }));
-                return;
-            }
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/workspace/recheck") {
-            const previousPath = workspaceAccessTracker.recoveryPath();
-            recheckWorkspaceIssue();
-            emitRunnerPresence();
-            const readiness = workspaceAccessTracker.currentReadiness() ?? {
-                ready: true,
-                message: "Workspace path is accessible.",
-                action: null,
-            };
-            res
-                .writeHead(200, { "content-type": "application/json" })
-                .end(JSON.stringify({ ok: readiness.ready, path: previousPath, readiness }));
-            return;
-        }
-        if (req.method === "GET" && req.url === "/capabilities") {
-            res
-                .writeHead(200, { "content-type": "application/json" })
-                .end(JSON.stringify(discoverCapabilities()));
-            return;
-        }
-        if (req.method === "GET" && req.url === "/logs") {
-            res
-                .writeHead(200, { "content-type": "application/json" })
-                .end(JSON.stringify({ lines: recentLogs }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/stop") {
-            for (const entry of activeAgents.values()) {
-                abortActiveAgent(entry, { userInitiated: true });
-            }
-            activeAgents.clear();
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/reconnect") {
-            // Non-killing socket recovery: tear down and re-dial the WS without
-            // stopping the daemon process or aborting active runs. Heals endpoint
-            // drift and stuck sockets that a mere reconnection backoff won't clear,
-            // while a long-running CLI run keeps executing untouched.
-            pushLog("reconnect requested via local API");
-            // Clear the poisoned-connect signal so a caller polling /status right
-            // after a successful re-dial doesn't still see the pre-reconnect error.
-            lastConnectError = null;
-            lastConnectErrorCode = null;
-            socket.disconnect();
-            socket.connect();
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            return;
-        }
-        if (req.method === "POST" && req.url?.startsWith("/stop_run")) {
-            const runId = new URL(req.url, "http://127.0.0.1").searchParams.get("runId");
-            if (!runId) {
-                res
-                    .writeHead(400, { "content-type": "application/json" })
-                    .end(JSON.stringify({ error: "runId is required" }));
-                return;
-            }
-            const entry = activeAgents.get(runId);
-            if (!entry) {
-                res
-                    .writeHead(404, { "content-type": "application/json" })
-                    .end(JSON.stringify({ error: "Run not active" }));
-                return;
-            }
-            abortActiveAgent(entry, { userInitiated: true });
-            activeAgents.delete(runId);
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            return;
-        }
-        if (req.method === "GET" && req.url?.startsWith("/inspect_run")) {
-            const runId = new URL(req.url, "http://127.0.0.1").searchParams.get("runId");
-            const entry = runId ? activeAgents.get(runId) : undefined;
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(entry
-                ? {
-                    runId,
-                    conversationId: entry.conversationId,
-                    stage: entry.stage,
-                    providerPid: entry.providerPid,
-                    lastActivityAtMs: entry.lastActivityAtMs,
-                    acceptedAtMs: entry.acceptedAtMs,
-                }
-                : { runId, active: false }));
-            return;
-        }
-        if (req.method === "POST" && req.url === "/shutdown") {
-            res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
-            setImmediate(queueFullShutdown);
-            return;
-        }
-        res
-            .writeHead(404, { "content-type": "application/json" })
-            .end(JSON.stringify({ error: "Not found" }));
-    });
-    const occupiedProbe = await probeLocalDaemonEndpoint(localApiPort, localApiToken);
-    if (occupiedProbe.state === "running") {
-        clearInterval(heartbeat);
-        clearInterval(versionRefresh);
-        clearInterval(workspaceLeaseMonitor);
-        suspensionDetector.stop();
-        socket.disconnect();
-        releaseOwnerLease();
-        releaseStartupLease();
-        throw new Error(`${describeOccupiedLocalDaemon(localApiPort)} (runtime ${occupiedProbe.status.runtimeId})`);
-    }
-    if (occupiedProbe.state === "listening_unauthorized") {
-        clearInterval(heartbeat);
-        clearInterval(versionRefresh);
-        clearInterval(workspaceLeaseMonitor);
-        suspensionDetector.stop();
-        socket.disconnect();
-        releaseOwnerLease();
-        releaseStartupLease();
-        throw new Error(`${describeOccupiedLocalDaemon(localApiPort)} The token in ${getConfigPath()} no longer matches the running daemon; quit Alan desktop or run setup again.`);
-    }
-    const localApiListening = new Promise((resolve, reject) => {
-        const onError = (error) => {
-            clearInterval(heartbeat);
-            clearInterval(versionRefresh);
-            clearInterval(workspaceLeaseMonitor);
-            suspensionDetector.stop();
-            socket.disconnect();
-            if (error.code === "EADDRINUSE") {
-                void probeLocalDaemonEndpoint(localApiPort).then((probe) => {
-                    if (probe.state !== "absent") {
-                        reject(new Error(describeOccupiedLocalDaemon(localApiPort)));
-                        return;
-                    }
-                    reject(new Error(`local daemon API port ${localApiPort} is already in use by another process. ` +
-                        "Otherwise free the port or pass `--local-api-port` with a different value."));
-                });
-                return;
-            }
-            reject(error);
-        };
-        localServer.once("error", onError);
-        localServer.listen(localApiPort, "127.0.0.1", () => {
-            localServer.off("error", onError);
-            const address = localServer.address();
-            if (address && typeof address === "object")
-                localApiPort = address.port;
-            pushLog(`local_api listening port=${localApiPort}`);
-            console.info("[alan-agent] Local daemon API listening", { port: localApiPort });
-            resolve();
-        });
-    });
-    try {
-        await localApiListening;
-    }
-    catch (error) {
-        releaseOwnerLease();
-        releaseStartupLease();
-        throw error;
-    }
-    try {
-        ownerLease = updateLocalDaemonOwnerEndpoint(configPath, ownerLease, localApiPort);
-        // The config-scoped owner is held and its authenticated endpoint is now
-        // bound. Only now may prior journal entries be persisted as interrupted.
-        runJournal.confirmRecoveryOwnership();
-        pendingRunStarts.discardRecovered();
-    }
-    catch (error) {
-        clearInterval(heartbeat);
-        clearInterval(versionRefresh);
-        clearInterval(workspaceLeaseMonitor);
-        suspensionDetector.stop();
-        socket.disconnect();
-        await new Promise((resolve) => localServer.close(() => resolve()));
-        releaseOwnerLease();
-        releaseStartupLease();
-        throw error;
-    }
-    releaseStartupLease();
-    let stopped = false;
-    const stop = async () => {
-        if (stopped)
-            return;
-        stopped = true;
-        try {
-            clearInterval(heartbeat);
-            clearInterval(versionRefresh);
-            clearInterval(workspaceLeaseMonitor);
-            suspensionDetector.stop();
-            for (const entry of activeAgents.values()) {
-                abortActiveAgent(entry, { userInitiated: true });
-            }
-            activeAgents.clear();
-            socket.disconnect();
-            await new Promise((resolve) => {
-                localServer.close(() => resolve());
-            });
-        }
-        finally {
-            // Release the sleep assertion even if teardown above threw; a leaked
-            // helper would keep the machine awake indefinitely.
-            sleepInhibitor.dispose();
-            releaseOwnerLease();
-        }
-    };
-    const controller = {
-        runtimeId,
-        wsUrl,
-        localApiPort,
-        localApiToken,
-        stop,
-    };
-    const queueFullShutdown = () => {
-        void stop().then(() => controller.whenExternallyStopped?.());
-    };
-    return controller;
-}
-export async function stopDaemon(args) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    const localApiPort = getLocalApiPort(args, stored);
-    let localApiToken = stored.localApiToken;
-    let probe = localApiToken
-        ? await probeLocalDaemonEndpoint(localApiPort, localApiToken)
-        : { state: "listening_unauthorized" };
-    if (!localApiToken || probe.state === "listening_unauthorized") {
-        const adopted = await adoptConfiguredLocalDaemon(args);
-        if (adopted) {
-            localApiToken = readConfig().localApiToken;
-            probe = { state: "running", status: adopted };
-        }
-    }
-    if (!localApiToken)
-        throw new Error("No local API token in config. Run setup or login first.");
-    if (probe.state === "listening_unauthorized") {
-        throw new Error(`Daemon is listening on port ${localApiPort} but rejected this config token. ` +
-            "Quit Alan desktop or rerun setup/login to refresh config.");
-    }
-    if (probe.state === "absent") {
-        console.info("[alan-agent] No daemon listening", { port: localApiPort });
-        return;
-    }
-    const response = await fetch(`http://127.0.0.1:${localApiPort}/shutdown`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${localApiToken}` },
-        signal: AbortSignal.timeout(5000),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to stop daemon: HTTP ${response.status}`);
-    }
-    console.info("[alan-agent] Daemon stopped", {
-        port: localApiPort,
-        runtimeId: probe.status.runtimeId,
-    });
-}
-export async function runDaemon(args) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    const localApiPort = getLocalApiPort(args, stored);
-    const localApiToken = stored.localApiToken;
-    const existingProbe = await probeLocalDaemonEndpoint(localApiPort, localApiToken);
-    if (existingProbe.state === "running") {
-        console.info("[alan-agent] Daemon already running", {
-            port: localApiPort,
-            runtimeId: existingProbe.status.runtimeId,
-            connected: existingProbe.status.connected,
-            hint: "If Alan desktop is open, it manages the daemon automatically.",
-        });
-        return;
-    }
-    if (existingProbe.state === "listening_unauthorized") {
-        const adopted = await adoptConfiguredLocalDaemon(args);
-        if (adopted) {
-            console.info("[alan-agent] Daemon already running", {
-                port: localApiPort,
-                runtimeId: adopted.runtimeId,
-                connected: adopted.connected,
-                adopted: true,
-            });
-            return;
-        }
-        console.info("[alan-agent] Daemon already running", {
-            port: localApiPort,
-            hint: `Alan desktop is using a different local API token than ${getConfigPath()}. Quit the desktop app or rerun setup if you need a fresh daemon.`,
-        });
-        return;
-    }
-    const controller = await startDaemon(args);
-    const shutdown = () => {
-        void controller.stop().finally(() => process.exit(0));
-    };
-    controller.whenExternallyStopped = shutdown;
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-    await new Promise(() => { });
-}
-export async function recoverDaemonConnection(args = [], options) {
-    bindConfigPath(args);
-    const getStatus = async () => {
-        const config = readConfig();
-        const localApiPort = getLocalApiPort(args, config);
-        let live = config.localApiToken
-            ? await probeLocalDaemon(localApiPort, config.localApiToken)
-            : null;
-        if (!live && config.localServiceId && config.localServiceSecret) {
-            live = await adoptConfiguredLocalDaemon(args);
-        }
-        if (live)
-            return { ...live, running: true };
-        return {
-            configured: Boolean(config.runtimeId && config.runtimeToken && config.wsUrl),
-            running: false,
-            connected: false,
-            activeRunCount: 0,
-            activeRunIds: [],
-            staleRunCount: 0,
-        };
-    };
-    const initialStatus = await getStatus();
-    const recovered = await runLocalDaemonRecoveryLadder({
-        initialStatus,
-        getStatus,
-        redial: async () => {
-            const config = readConfig();
-            if (!config.localApiToken)
-                return false;
-            const localApiPort = getLocalApiPort(args, config);
-            const response = await fetch(`http://127.0.0.1:${localApiPort}/reconnect`, {
-                method: "POST",
-                headers: { authorization: `Bearer ${config.localApiToken}` },
-                signal: AbortSignal.timeout(5000),
-            });
-            return response.ok;
-        },
-        restart: async () => {
-            const beforeRestart = await getStatus();
-            const blockingRunCount = beforeRestart.activeRunCount ??
-                Math.max(0, (beforeRestart.activeRunIds?.length ?? 0) - (beforeRestart.staleRunCount ?? 0));
-            if (blockingRunCount > 0)
-                return beforeRestart;
-            if (beforeRestart.running) {
-                await stopDaemon(args);
-                for (let attempt = 0; attempt < 50; attempt += 1) {
-                    await sleep(50);
-                    if (!(await getStatus()).running)
-                        break;
-                }
-                if ((await getStatus()).running) {
-                    throw new Error("The existing local daemon did not stop within the recovery budget.");
-                }
-            }
-            await startDaemon(args);
-            return getStatus();
-        },
-        blockingRunCount: (status) => status.activeRunCount ??
-            Math.max(0, (status.activeRunIds?.length ?? 0) - (status.staleRunCount ?? 0)),
-        options,
-    });
-    console.info(JSON.stringify({ recovery: recovered }, null, 2));
-    return recovered;
-}
-async function drainAndStopLocalDaemonBeforeCredentialCleanup(args, stored) {
-    const localApiPort = getLocalApiPort(args, stored);
-    let localApiToken = stored.localApiToken;
-    let probe = await probeLocalDaemonEndpoint(localApiPort, localApiToken);
-    if (probe.state === "listening_unauthorized") {
-        const adopted = await adoptConfiguredLocalDaemon(args);
-        if (adopted) {
-            localApiToken = readConfig().localApiToken;
-            probe = { state: "running", status: adopted };
-        }
-    }
-    if (probe.state === "absent")
-        return;
-    if (probe.state === "listening_unauthorized" || !localApiToken) {
-        throw new Error(`Logout cannot verify the local daemon on port ${localApiPort}. Stop the local service before removing credentials.`);
-    }
-    const prepare = await fetch(`http://127.0.0.1:${localApiPort}/prepare_logout`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${localApiToken}` },
-        signal: AbortSignal.timeout(5000),
-    });
-    if (prepare.status === 409) {
-        const body = (await prepare.json().catch(() => ({})));
-        const activeRunCount = typeof body.activeRunCount === "number" && Number.isSafeInteger(body.activeRunCount)
-            ? Math.max(1, body.activeRunCount)
-            : 1;
-        throw new Error(`Logout is deferred while ${activeRunCount} active run${activeRunCount === 1 ? "" : "s"} finish. New runs are paused; retry logout afterward.`);
-    }
-    if (!prepare.ok) {
-        throw new Error(`Logout could not safely drain the local daemon (HTTP ${prepare.status}). Stop or update the local service before removing credentials.`);
-    }
-    const shutdown = await fetch(`http://127.0.0.1:${localApiPort}/shutdown`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${localApiToken}` },
-        signal: AbortSignal.timeout(5000),
-    });
-    if (!shutdown.ok) {
-        throw new Error(`Logout could not stop the local daemon (HTTP ${shutdown.status}).`);
-    }
-    for (let attempt = 0; attempt < 50; attempt += 1) {
-        await sleep(50);
-        if ((await probeLocalDaemonEndpoint(localApiPort, localApiToken, 250)).state === "absent") {
-            return;
-        }
-    }
-    throw new Error("Logout could not confirm that the local daemon stopped; credentials were kept.");
-}
-export async function rotateRuntimeToken(args) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    const apiUrl = argValue(args, "--api-url") ?? process.env.ALAN_API_URL ?? stored.apiUrl;
-    const runtimeId = argValue(args, "--runtime-id") ?? process.env.ALAN_RUNTIME_ID ?? stored.runtimeId;
-    const token = argValue(args, "--token") ?? process.env.ALAN_SETUP_TOKEN;
-    if (!apiUrl || !runtimeId || !token) {
-        throw new Error("token rotate requires configured api/runtime plus --token <alan PAT>");
-    }
-    const response = await fetch(`${apiUrl}/public/runtimes/${runtimeId}/tokens/rotate`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${token}` },
-    });
-    if (!response.ok) {
-        throw new Error(`runtime token rotation failed: HTTP ${response.status}`);
-    }
-    const body = (await response.json());
-    writeConfig({
-        ...stored,
-        apiUrl,
-        runtimeId,
-        runtimeToken: body.runtimeToken,
-        runtimeRenewalToken: body.runtimeRenewalToken,
-    });
-    console.info("[alan-agent] Runtime token rotated", { runtimeId });
-}
-export async function revokeRuntimeToken(args) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    const apiUrl = argValue(args, "--api-url") ?? process.env.ALAN_API_URL ?? stored.apiUrl;
-    const runtimeId = argValue(args, "--runtime-id") ?? process.env.ALAN_RUNTIME_ID ?? stored.runtimeId;
-    const token = argValue(args, "--token") ?? process.env.ALAN_SETUP_TOKEN;
-    if (!apiUrl || !runtimeId || !token) {
-        throw new Error("token revoke requires configured api/runtime plus --token <alan PAT>");
-    }
-    await drainAndStopLocalDaemonBeforeCredentialCleanup(args, stored);
-    const response = await fetch(`${apiUrl}/public/runtimes/${runtimeId}/tokens/revoke`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${token}` },
-    });
-    if (!response.ok) {
-        throw new Error(`runtime token revoke failed: HTTP ${response.status}`);
-    }
-    removeAlanOwnedLocalArtifacts();
-    console.info("[alan-agent] Runtime token revoked", { runtimeId });
-}
-export async function logoutDaemon(args = []) {
-    bindConfigPath(args);
-    const stored = readConfig();
-    await drainAndStopLocalDaemonBeforeCredentialCleanup(args, stored);
-    removeAlanOwnedLocalArtifacts();
-    console.info("[alan-agent] Runtime config removed", { configPath: getConfigPath() });
-}
-export async function printStatus(args = []) {
-    bindConfigPath(args);
-    const config = readConfig();
-    const configured = Boolean(config.runtimeId && config.runtimeToken && config.wsUrl);
-    const warnings = [];
-    if ((isLocalEndpoint(config.apiUrl) || isLocalEndpoint(config.wsUrl)) &&
-        config.endpointProfile !== "local") {
-        warnings.push("Configured endpoint points at localhost. Use --profile local only for local development.");
-    }
-    const localApiPort = config.localApiPort && config.localApiPort > 0
-        ? config.localApiPort
-        : getLocalApiPort([], config);
-    let localDaemonProbe = config.localApiToken
-        ? await probeLocalDaemonEndpoint(localApiPort, config.localApiToken)
-        : { state: "absent" };
-    if (localDaemonProbe.state !== "running" && config.localServiceId && config.localServiceSecret) {
-        const adopted = await adoptConfiguredLocalDaemon(args);
-        if (adopted)
-            localDaemonProbe = { state: "running", status: adopted };
-    }
-    const localDaemonRunning = localDaemonProbe.state === "running";
-    console.info(JSON.stringify({
-        mode: "runtime",
-        configured,
-        runtimeId: config.runtimeId ?? null,
-        apiUrl: config.apiUrl ?? null,
-        wsUrl: config.wsUrl ?? null,
-        endpointProfile: config.endpointProfile ?? null,
-        localApiPort: config.localApiPort ?? null,
-        localDaemonRunning,
-        hasLocalApiToken: Boolean(config.localApiToken),
-        configPath: getConfigPath(),
-        note: configured
-            ? localDaemonRunning
-                ? "Local daemon is running. Stop it with: alan-agent stop"
-                : "Durable runtime config is present. Start it with: alan-agent daemon"
-            : "No durable runtime configured. Cloud sandbox sessions are launched by Alan with session env vars and do not appear in this local config.",
-        warnings,
-    }, null, 2));
-}
-export async function printDoctor(args = []) {
-    bindConfigPath(args);
-    const config = readConfig();
-    const capabilities = discoverCapabilities();
-    let synced = false;
-    let syncError = null;
-    if (args.includes("--sync")) {
-        if (!config.apiUrl || !config.runtimeId || !config.runtimeToken) {
-            throw new Error("doctor --sync requires configured apiUrl, runtimeId, and runtimeToken. Run setup first.");
-        }
-        const response = await fetch(`${config.apiUrl}/public/runtimes/${config.runtimeId}/capabilities/self`, {
-            method: "PATCH",
-            headers: {
-                authorization: `Bearer ${config.runtimeToken}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({
-                capabilities,
-                metadata: {
-                    ...(await collectRuntimeMetadataWithProviderLimits()),
-                    ...(config.installationId ? { installationId: config.installationId } : {}),
-                },
-            }),
-        });
-        if (!response.ok) {
-            syncError = `${response.status} ${await response.text()}`;
-            throw new Error(`doctor sync failed: ${syncError}`);
-        }
-        synced = true;
-    }
-    console.info(JSON.stringify({
-        version: AGENT_VERSION,
-        configPath: getConfigPath(),
-        configured: Boolean(config.runtimeId && config.runtimeToken && config.wsUrl),
-        runtimeId: config.runtimeId ?? null,
-        apiUrl: config.apiUrl ?? null,
-        wsUrl: config.wsUrl ?? null,
-        endpointProfile: config.endpointProfile ?? null,
-        warnings: (isLocalEndpoint(config.apiUrl) || isLocalEndpoint(config.wsUrl)) &&
-            config.endpointProfile !== "local"
-            ? [
-                "Configured endpoint points at localhost. Use --profile local only for local development.",
-            ]
-            : [],
-        synced,
-        syncError,
-        capabilities,
-    }, null, 2));
-}
-//# sourceMappingURL=daemon.js.map