@claudexor/cli 1.0.1 → 2.1.3

package/dist/setup-jobs.js

@@ -1,477 +1,867 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { harnessRuntimeEnv } from "@claudexor/core";
+import { chmodSync, writeFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { AuthCapabilityVerifier, ProcessGroupService, parseProcessGroupHandle, } from "@claudexor/core";
 import { daemonDir } from "@claudexor/daemon";
-import { appendLine, noProjectRepoRoot, readJsonSafe, redactSecrets } from "@claudexor/util";
-import { ControlSetupJob as ControlSetupJobSchema } from "@claudexor/schema";
+import { ControlSetupJobCreateRequest, SetupNativeCommandReceipt, } from "@claudexor/schema";
+import { noProjectRepoRoot } from "@claudexor/util";
+import * as NativeLogin from "./native-login.js";
+import { SETUP_PROFILES, processGroupFromJob, profileDoctorProbe, resolveProfileBinding, resolveSetupLoginRunnerPath, shellQuote, stateMatchesDurableExecution, waitWithAbort, withAbortAndTimeout, } from "./setup-job-support.js";
 import { buildGateway } from "./registry.js";
+import { ACTIVE_SETUP_STATES, SetupJobStore, TERMINAL_SETUP_STATES } from "./setup-job-store.js";
+import { SETUP_LOGIN_PROTOCOL_VERSION, atomicPrivateJson, captureExecutableEvidence, commandDigest, readLoginManifest, readRunnerResult, readRunnerState, sealLoginManifest, verifyExecutableEvidence, } from "./setup-login-protocol.js";
+import { SetupSupervisor } from "./setup-supervisor.js";
 const NO_PROJECT_ROOT = noProjectRepoRoot();
-/**
- * Doctor verification runs IN-PROCESS (buildGateway().statusAll) — never as a
- * `claudexor ...` shell command. The bundled .app daemon has no global
- * `claudexor` binary on PATH, so the previous shell form always exited 127.
- */
-const SETUP_PROFILES = {
-    codex: {
-        guideUrl: "https://developers.openai.com/codex",
-        installCommand: "npm install -g @openai/codex",
-        loginCommand: "codex login",
-        note: "Codex native login seeds the local CLI session; API-key fallback can be stored as the openai secret ref.",
-        installRiskFlags: ["network_download", "global_npm_install"],
-    },
-    claude: {
-        guideUrl: "https://docs.anthropic.com/en/docs/claude-code",
-        installCommand: "npm install -g @anthropic-ai/claude-code",
-        loginCommand: "claude /login",
-        note: "Claude Code native login is preferred; Anthropic API-key fallback can be stored as the anthropic secret ref.",
-        installRiskFlags: ["network_download", "global_npm_install"],
-    },
-    cursor: {
-        guideUrl: "https://docs.cursor.com/cli",
-        installCommand: "curl https://cursor.com/install -fsS | bash",
-        loginCommand: "cursor-agent login",
-        note: "Cursor native CLI login is reused when available.",
-        installRiskFlags: ["network_download", "shell_pipe", "no_static_sha256", "may_prompt_for_privilege"],
-    },
-    opencode: {
-        guideUrl: "https://opencode.ai/docs",
-        installCommand: "curl -fsSL https://opencode.ai/install | bash",
-        loginCommand: "opencode auth login",
-        note: "OpenCode native auth is reused when available.",
-        installRiskFlags: ["network_download", "shell_pipe", "no_static_sha256", "may_prompt_for_privilege"],
-    },
-    raw: {
-        guideUrl: "https://platform.openai.com/docs",
-        installCommand: null,
-        loginCommand: null,
-        note: "Raw API routes use stored secret refs instead of a native CLI login.",
-        installRiskFlags: [],
-    },
-};
-/** Native login command for a harness (null = API-key refs only). Single
- * source for both the setup-job Terminal handoff and `claudexor auth login`. */
-export function nativeLoginCommand(harness) {
-    return SETUP_PROFILES[harness]?.loginCommand ?? null;
-}
-/** Honest display label for the in-process doctor phase of a setup job. */
-function inProcessDoctorLabel(harness) {
-    return harness === "raw" ? "(in-process doctor: all harnesses)" : `(in-process doctor: ${harness})`;
-}
-const SETUP_JOBS_DIR = join(daemonDir(), "setup-jobs");
-const SETUP_JOBS_REGISTRY = join(SETUP_JOBS_DIR, "jobs.json");
-/** A hung installer must reach a visible terminal state, not run forever. */
-const SETUP_JOB_TIMEOUT_MS = 15 * 60_000;
+const LOGIN_EXTENSION_MS = 15 * 60_000;
 export function createSetupJobManager(opts = {}) {
-    const jobs = new Map();
-    const children = new Map();
-    const timeouts = new Map();
-    const statusAll = opts.statusAll ?? (() => buildGateway({ includeFakes: false }).statusAll({ cwd: NO_PROJECT_ROOT }));
-    // Durable registry: a daemon restart must not erase job history. Jobs that
-    // were mid-flight when the daemon died are marked failed (honest terminal),
-    // except Terminal logins, which legitimately outlive the daemon process.
-    mkdirSync(SETUP_JOBS_DIR, { recursive: true, mode: 0o700 });
-    const persisted = readJsonSafe(SETUP_JOBS_REGISTRY);
-    if (Array.isArray(persisted)) {
-        for (const raw of persisted) {
-            const parsed = ControlSetupJobSchema.safeParse(raw);
-            if (!parsed.success)
-                continue;
-            const job = parsed.data;
-            if (job.state === "running" || job.state === "queued") {
-                jobs.set(job.jobId, {
-                    ...job,
-                    state: "failed",
-                    finishedAt: new Date().toISOString(),
-                    message: `${job.harness} ${job.action} job was interrupted by a daemon restart.`,
-                });
-            }
-            else {
-                jobs.set(job.jobId, job);
+    const now = opts.now ?? (() => new Date());
+    const sleep = opts.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+    const spawnProcess = opts.spawn ?? spawn;
+    const rootDir = opts.rootDir ?? daemonDir();
+    const store = opts.store ?? new SetupJobStore(rootDir, { now });
+    const processGroups = opts.processGroups ?? new ProcessGroupService({ platform: opts.platform ?? process.platform });
+    const processing = new Map();
+    const terminations = new Map();
+    const verificationControllers = new Map();
+    const gateway = opts.probeAuthSource && opts.authCapabilityVerifier
+        ? null
+        : buildGateway({ includeFakes: false });
+    const probeAuthSource = opts.probeAuthSource ??
+        ((harness, source, probe) => gateway.probeAuthSource(harness, source, { cwd: NO_PROJECT_ROOT, ...probe }));
+    const probeCredentialProfile = opts.probeCredentialProfile ??
+        (gateway
+            ? profileDoctorProbe((harness) => gateway.get(harness))
+            : () => {
+                // Injected auth probes without an injected profile probe would
+                // silently verify the WRONG store — refuse loudly instead.
+                throw new Error("probeCredentialProfile hook is required when probeAuthSource is injected");
+            });
+    const authCapabilityVerifier = opts.authCapabilityVerifier ??
+        new AuthCapabilityVerifier((harness) => gateway.get(harness), {
+            now,
+            scratchRoot: join(rootDir, "auth-smokes"),
+        });
+    const runnerPath = opts.runnerPath ?? resolveSetupLoginRunnerPath();
+    const nodePath = opts.nodePath ?? process.execPath;
+    if (!isAbsolute(runnerPath) || !isAbsolute(nodePath))
+        throw new Error("setup login runnerPath and nodePath must be absolute");
+    const platform = opts.platform ?? process.platform;
+    const launcherTimeoutMs = opts.launcherTimeoutMs ?? 10_000;
+    const loginTimeoutMs = opts.loginTimeoutMs ?? 15 * 60_000;
+    const verifyTimeoutMs = opts.verifyTimeoutMs ?? 30_000;
+    const capabilityTimeoutMs = opts.capabilityTimeoutMs ?? 60_000;
+    const verifyPollMs = opts.verifyPollMs ?? 2_000;
+    const terminationGraceMs = opts.terminationGraceMs ?? 5_000;
+    let supervisor;
+    const openTerminal = opts.openTerminal ??
+        ((scriptPath) => spawnProcess("/usr/bin/open", ["-a", "Terminal", scriptPath], {
+            detached: true,
+            stdio: "ignore",
+        }));
+    function iso() {
+        return now().toISOString();
+    }
+    function update(jobId, patch) {
+        return store.update(jobId, patch);
+    }
+    function log(jobId, line) {
+        store.appendLog(jobId, line);
+    }
+    function logAfterMutation(jobId, line) {
+        try {
+            log(jobId, line);
+        }
+        catch (error) {
+            supervisor.reportFailure(error, "setup-log");
+        }
+    }
+    function finish(jobId, state, reason, message, evidence = {}, 
+    // A pre-launch failure still keeps the operator's manual command selectable
+    // (DESIGN_SYSTEM setup contract, INV-093) — never a null command with the
+    // reason buried in one HTTP response.
+    command) {
+        const done = update(jobId, {
+            state,
+            phase: "completed",
+            outcome: { reason, ...evidence },
+            finishedAt: iso(),
+            message,
+            ...(command ? { command } : {}),
+        });
+        logAfterMutation(jobId, message);
+        return done;
+    }
+    function persistNativeCommandOutcome(jobId, result) {
+        let job = store.status(jobId);
+        const receipt = SetupNativeCommandReceipt.parse({
+            executionId: result.executionId,
+            commandDigest: result.commandDigest,
+            manifestDigest: result.manifestDigest,
+            permitIssuedAt: result.permitIssuedAt,
+            commandStarted: result.commandStarted,
+            exitCode: result.exitCode,
+            signal: result.signal,
+            ...(result.errorCode ? { errorCode: result.errorCode } : {}),
+            finishedAt: result.finishedAt,
+        });
+        if (job.nativeCommand) {
+            if (JSON.stringify(job.nativeCommand) !== JSON.stringify(receipt)) {
+                throw new Error(`native command outcome changed for setup job '${jobId}'`);
             }
+            return job;
+        }
+        job = update(jobId, {
+            nativeCommand: receipt,
+            message: `Persisted hash-bound ${job.harness} native command evidence before verification.`,
+        });
+        if (receipt.commandStarted)
+            opts.onCredentialStateMayHaveChanged?.(job.harness);
+        return job;
+    }
+    function probeNativeSession(harness, controller, timeoutMs) {
+        return withAbortAndTimeout(() => probeAuthSource(harness, "native_session", {
+            fresh: true,
+            authPreference: "subscription",
+            abortSignal: controller.signal,
+        }), controller, timeoutMs, "native auth verification");
+    }
+    function probeProfileStatus(harness, profileId, controller, timeoutMs) {
+        return withAbortAndTimeout(() => probeCredentialProfile(harness, profileId, controller.signal), controller, timeoutMs, "profile auth verification");
+    }
+    function finishCapabilityReceipt(jobId, receipt, loginEvidence = {}) {
+        if (receipt.verification === "passed" &&
+            receipt.effective === "vendor_native" &&
+            receipt.effectiveSource === "native_session") {
+            return finish(jobId, "succeeded", "completed", `${receipt.harness} native subscription completed a real same-harness capability smoke. Billing remains unknown.`, loginEvidence);
         }
+        const routeMismatch = receipt.selectionReason === "route_mismatch" ||
+            receipt.selectionReason === "source_mismatch" ||
+            receipt.selectionReason === "route_missing" ||
+            receipt.selectionReason === "source_missing";
+        return finish(jobId, "failed", routeMismatch ? "credential_route_mismatch" : "capability_verification_failed", routeMismatch
+            ? `${receipt.harness} capability smoke did not use the exact vendor-native session route.`
+            : `${receipt.harness} capability smoke failed (${receipt.selectionReason}).`, loginEvidence);
     }
-    const persist = () => {
+    async function runCapabilitySmoke(jobId, controller, loginEvidence) {
+        let job = store.status(jobId);
+        if (!ACTIVE_SETUP_STATES.has(job.state) || job.phase === "cancelling")
+            return;
+        const lifecycle = job.authCapability;
+        if (!lifecycle) {
+            finish(jobId, "failed", "capability_verification_failed", `${job.harness} login is missing its durable capability disclosure.`, loginEvidence);
+            return;
+        }
+        if (lifecycle.state !== "disclosed") {
+            settleDurableCapability(job, "restart");
+            return;
+        }
+        const startedAt = iso();
+        const running = { ...lifecycle, state: "running", startedAt };
+        update(jobId, {
+            state: "running",
+            phase: "verifying",
+            authCapability: running,
+            message: `Running one ${job.harness} capability smoke on native_session; it may consume quota and billing is unknown.`,
+        });
+        let receipt;
+        try {
+            const { state: _state, ...binding } = lifecycle;
+            receipt = await withAbortAndTimeout(() => authCapabilityVerifier.verify({
+                binding,
+                startedAt,
+                abortSignal: controller.signal,
+            }), controller, capabilityTimeoutMs, "auth capability smoke");
+        }
+        catch (error) {
+            const current = store.status(jobId);
+            if (!ACTIVE_SETUP_STATES.has(current.state) || current.phase === "cancelling")
+                return;
+            const interruptedAt = iso();
+            update(jobId, {
+                authCapability: { ...running, state: "interrupted_unknown", interruptedAt },
+                message: `${job.harness} capability smoke ended without a verifiable receipt.`,
+            });
+            finish(jobId, "interrupted_unknown", "interrupted_unknown", `${job.harness} capability smoke outcome is unknown${error instanceof Error && "code" in error && error.code === "setup_timeout" ? " after timeout" : ""}; it was not replayed.`, loginEvidence);
+            return;
+        }
         try {
-            writeFileSync(SETUP_JOBS_REGISTRY, JSON.stringify([...jobs.values()], null, 2) + "\n", { mode: 0o600 });
+            authCapabilityVerifier.cleanup(lifecycle.attemptId);
         }
         catch {
-            /* registry persistence is best-effort; state stays authoritative in memory */
+            /* receipt remains authoritative */
         }
-    };
-    const save = (job) => {
-        jobs.set(job.jobId, job);
-        persist();
-        return job;
-    };
-    const update = (jobId, patch) => {
-        const prev = jobs.get(jobId);
-        if (!prev)
-            throw Object.assign(new Error("setup job not found"), { status: 404 });
-        return save({ ...prev, ...patch });
-    };
-    const writeJobLog = (job, line) => {
-        if (!job.logPath)
+        const current = store.status(jobId);
+        if (!ACTIVE_SETUP_STATES.has(current.state) || current.phase === "cancelling")
             return;
-        appendLine(job.logPath, `[${new Date().toISOString()}] ${redactSecrets(line)}`);
-    };
-    const noteJobOutput = (jobId) => {
-        const current = jobs.get(jobId);
-        if (!current || current.state !== "running")
+        update(jobId, {
+            authCapability: {
+                ...running,
+                state: "completed",
+                completedAt: receipt.completedAt,
+                receipt,
+            },
+            message: `${job.harness} capability receipt persisted (${receipt.verification}).`,
+        });
+        finishCapabilityReceipt(jobId, receipt, loginEvidence);
+    }
+    function runNativeVerification(jobId, loginEvidence = {}) {
+        const existing = processing.get(jobId);
+        if (existing)
+            return existing;
+        const controller = new AbortController();
+        verificationControllers.set(jobId, controller);
+        const operation = supervisor.track(`native-verification:${jobId}`, () => runNativeVerificationOnce(jobId, loginEvidence, controller));
+        processing.set(jobId, operation);
+        const cleanup = () => {
+            if (processing.get(jobId) === operation)
+                processing.delete(jobId);
+            if (verificationControllers.get(jobId) === controller)
+                verificationControllers.delete(jobId);
+        };
+        void operation.then(cleanup, cleanup);
+        return operation;
+    }
+    async function runNativeVerificationOnce(jobId, loginEvidence, verificationController) {
+        const job = store.status(jobId);
+        if (!ACTIVE_SETUP_STATES.has(job.state))
             return;
-        const now = nowForDto();
         update(jobId, {
-            firstOutputAt: current.firstOutputAt ?? now,
-            lastOutputAt: now,
-            message: current.firstOutputAt
-                ? `Running allowlisted ${current.harness} ${current.action} job. Latest output at ${now}.`
-                : `Running allowlisted ${current.harness} ${current.action} job. First output received.`,
+            state: "running",
+            phase: "verifying",
+            message: job.profileId
+                ? `Verifying the scoped ${job.harness} profile "${job.profileId}" via its doctor probe.`
+                : `Verifying the exact ${job.harness} native subscription source.`,
         });
-    };
-    /**
-     * In-process doctor: probes the harness through the SAME gateway code the
-     * Harness Doctor screen uses. No shell, no PATH dependency — the bundled
-     * .app daemon has no global `claudexor` binary (the old shell form was a
-     * guaranteed exit 127).
-     */
-    const doctorTimeoutMs = opts.doctorTimeoutMs ?? 60_000;
-    const runInProcessDoctor = (jobId) => {
-        void (async () => {
-            const job = jobs.get(jobId);
-            if (!job || job.state !== "running")
+        const deadline = now().getTime() + verifyTimeoutMs;
+        let lastDetail;
+        for (;;) {
+            const current = store.status(jobId);
+            if (!ACTIVE_SETUP_STATES.has(current.state) ||
+                current.phase === "cancelling" ||
+                verificationController.signal.aborted)
                 return;
-            writeJobLog(job, `doctor: probing ${job.harness} in-process (no shell, no PATH dependency)`);
+            const remaining = deadline - now().getTime();
+            if (remaining <= 0)
+                break;
+            // INV-135 profile jobs verify the PROFILE's scoped store via the doctor
+            // probe — the default native_session probe would attest the WRONG store.
+            let readiness = null;
+            let profileStatus = null;
             try {
-                const statuses = await Promise.race([
-                    statusAll(),
-                    new Promise((_, reject) => {
-                        const t = setTimeout(() => reject(new Error(`doctor timed out after ${doctorTimeoutMs / 1000}s`)), doctorTimeoutMs);
-                        t.unref();
-                    }),
-                ]);
-                noteJobOutput(jobId);
-                const targets = job.harness === "raw" ? statuses : statuses.filter((s) => s.id === job.harness);
-                if (targets.length === 0)
-                    throw new Error(`no doctor report for harness '${job.harness}'`);
-                for (const s of targets) {
-                    const checks = s.checks.map((c) => `${c.id}:${c.status}`).join(", ");
-                    writeJobLog(job, `doctor ${s.id}: ${s.status}${checks ? ` — ${checks}` : ""}`);
-                    for (const reason of s.reasons ?? [])
-                        writeJobLog(job, `doctor ${s.id}: ${reason}`);
+                if (job.profileId) {
+                    profileStatus = await probeProfileStatus(job.harness, job.profileId, verificationController, remaining);
+                }
+                else {
+                    readiness = await probeNativeSession(job.harness, verificationController, remaining);
                 }
-                const ok = targets.every((s) => s.status === "ok");
-                const degraded = targets.some((s) => s.status === "degraded");
-                const reasons = targets.flatMap((s) => s.reasons ?? []).slice(0, 2).join("; ");
-                const message = ok
-                    ? `${job.harness} doctor passed (in-process).`
-                    : `${job.harness} doctor reports ${degraded ? "degraded" : "unavailable"}: ${reasons || "see the job log for checks"}`;
-                // A cancel may have landed while statusAll() was in flight; a terminal
-                // cancelled state must never be overwritten by a late doctor verdict.
-                const beforeTerminal = jobs.get(jobId);
-                if (!beforeTerminal || beforeTerminal.state !== "running")
-                    return;
-                const done = update(jobId, { state: ok ? "succeeded" : "failed", finishedAt: nowForDto(), message });
-                writeJobLog(done, message);
             }
             catch (err) {
-                const message = `in-process doctor failed: ${err instanceof Error ? err.message : String(err)}`;
-                const current = jobs.get(jobId);
-                // Same cancel-race guard as the success path: only a still-running
-                // job may take a terminal verdict from this async phase.
-                if (!current || current.state !== "running")
+                const latest = store.status(jobId);
+                if (!ACTIVE_SETUP_STATES.has(latest.state) || latest.phase === "cancelling")
                     return;
-                const failed = update(jobId, { state: "failed", finishedAt: nowForDto(), message });
-                writeJobLog(failed, message);
+                lastDetail = err instanceof Error ? err.message : String(err);
+                if (verificationController.signal.aborted) {
+                    if (["draining", "stopped"].includes(supervisor.health().state))
+                        return;
+                    break;
+                }
+                log(jobId, `fresh native-session probe failed transiently: ${lastDetail}`);
+                await waitWithAbort(Math.min(verifyPollMs, Math.max(0, deadline - now().getTime())), verificationController, sleep);
+                continue;
             }
-        })();
-    };
-    const startInProcessDoctorJob = (job) => {
-        const started = update(job.jobId, {
-            state: "running",
-            startedAt: nowForDto(),
-            message: `Running in-process ${job.harness} doctor.`,
-        });
-        runInProcessDoctor(job.jobId);
-        return started;
-    };
-    const startShellJob = (job, command, onSuccess) => {
-        const started = update(job.jobId, { state: "running", startedAt: nowForDto(), message: `Running allowlisted ${job.harness} ${job.action} job.` });
-        writeJobLog(started, `$ ${command}`);
-        const child = spawn("/bin/bash", ["-lc", command], {
-            cwd: NO_PROJECT_ROOT,
-            env: setupJobEnv(),
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        children.set(job.jobId, child);
-        // Watchdog: a wedged install/doctor must surface as a failed terminal state.
-        const watchdog = setTimeout(() => {
-            const current = jobs.get(job.jobId);
-            if (!current || current.state !== "running")
-                return;
-            writeJobLog(current, `watchdog: job exceeded ${SETUP_JOB_TIMEOUT_MS / 60000} minutes; terminating`);
-            child.kill("SIGTERM");
-            setTimeout(() => child.kill("SIGKILL"), 5_000).unref();
-            const failed = update(job.jobId, {
-                state: "failed",
-                finishedAt: nowForDto(),
-                message: `${job.harness} ${job.action} job timed out after ${SETUP_JOB_TIMEOUT_MS / 60000} minutes and was terminated.`,
-            });
-            writeJobLog(failed, failed.message);
-        }, SETUP_JOB_TIMEOUT_MS);
-        watchdog.unref();
-        timeouts.set(job.jobId, watchdog);
-        child.stdout.on("data", (chunk) => { noteJobOutput(job.jobId); writeJobLog(jobs.get(job.jobId) ?? started, String(chunk)); });
-        child.stderr.on("data", (chunk) => { noteJobOutput(job.jobId); writeJobLog(jobs.get(job.jobId) ?? started, String(chunk)); });
-        child.on("error", (err) => {
-            children.delete(job.jobId);
-            clearTimeout(timeouts.get(job.jobId));
-            timeouts.delete(job.jobId);
-            const failed = update(job.jobId, { state: "failed", finishedAt: nowForDto(), message: `Setup job failed to start: ${err.message}` });
-            writeJobLog(failed, failed.message);
-        });
-        child.on("exit", (code, signal) => {
-            children.delete(job.jobId);
-            clearTimeout(timeouts.get(job.jobId));
-            timeouts.delete(job.jobId);
-            const current = jobs.get(job.jobId);
-            if (!current || current.state === "cancelled" || current.state === "failed")
-                return;
-            const ok = code === 0;
-            if (ok && onSuccess) {
-                // The shell phase finished; the job stays running for the in-process
-                // doctor phase, which owns the terminal state.
-                const phase = update(job.jobId, { message: `${job.harness} ${job.action} shell phase finished; verifying with in-process doctor.` });
-                writeJobLog(phase, phase.message);
-                onSuccess(job.jobId);
+            const latest = store.status(jobId);
+            if (!ACTIVE_SETUP_STATES.has(latest.state) || latest.phase === "cancelling")
                 return;
+            if (job.profileId) {
+                const verified = profileStatus?.availability === "available" && profileStatus.verification === "passed";
+                lastDetail = profileStatus?.detail;
+                log(jobId, `profile ${latest.harness}/${job.profileId}: ${profileStatus?.availability ?? "unknown"}; verification ${profileStatus?.verification ?? "not_run"}`);
+                if (verified && now().getTime() <= deadline) {
+                    // Same contract as `claudexor profiles login`: the doctor probe IS
+                    // the verification truth for a scoped profile. The capability smoke
+                    // attests the DEFAULT route only, so it is honestly skipped here.
+                    finish(jobId, "succeeded", "completed", `${latest.harness} profile "${job.profileId}" login verified by its doctor probe. The default-route capability smoke does not apply to scoped profiles and was skipped.`, loginEvidence);
+                    return;
+                }
+            }
+            else {
+                const verified = readiness?.source === "native_session" &&
+                    readiness.availability === "available" &&
+                    readiness.verification === "passed";
+                lastDetail = readiness?.detail;
+                log(jobId, `native_session ${latest.harness}: ${readiness?.availability ?? "unknown"}; verification ${readiness?.verification ?? "not_run"}`);
+                if (verified && now().getTime() <= deadline) {
+                    await runCapabilitySmoke(jobId, verificationController, loginEvidence);
+                    return;
+                }
             }
-            const message = ok
-                ? `${job.harness} ${job.action} job finished.`
-                : `${job.harness} ${job.action} job failed with ${signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`}.`;
-            const done = update(job.jobId, { state: ok ? "succeeded" : "failed", finishedAt: nowForDto(), message });
-            writeJobLog(done, message);
+            await waitWithAbort(Math.min(verifyPollMs, Math.max(0, deadline - now().getTime())), verificationController, sleep);
+        }
+        const latest = store.status(jobId);
+        if (!ACTIVE_SETUP_STATES.has(latest.state) || latest.phase === "cancelling")
+            return;
+        finish(jobId, "failed", "auth_not_ready", `${latest.harness} ${job.profileId ? `profile "${job.profileId}"` : "native session"} was not ready before the verification deadline${lastDetail ? `: ${lastDetail}` : "."}`, loginEvidence);
+    }
+    function manifestFor(jobId) {
+        try {
+            return readLoginManifest(store.paths(jobId).manifest);
+        }
+        catch {
+            return null;
+        }
+    }
+    function matchingState(jobId) {
+        const manifest = manifestFor(jobId);
+        const state = readRunnerState(store.paths(jobId).runnerState);
+        return manifest && state && state.jobId === jobId && state.executionId === manifest.executionId
+            ? state
+            : null;
+    }
+    function matchingResult(jobId) {
+        const manifest = manifestFor(jobId);
+        const result = readRunnerResult(store.paths(jobId).runnerResult);
+        return manifest &&
+            result &&
+            result.jobId === jobId &&
+            result.executionId === manifest.executionId &&
+            result.commandDigest === manifest.commandDigest &&
+            result.manifestDigest === manifest.manifestDigest
+            ? result
+            : null;
+    }
+    function persistPermit(job, manifest) {
+        const issuedAt = job.execution?.permitIssuedAt;
+        if (!issuedAt)
+            throw new Error("cannot issue a setup-login permit before its durable journal transition");
+        atomicPrivateJson(manifest.permitPath, {
+            version: SETUP_LOGIN_PROTOCOL_VERSION,
+            jobId: job.jobId,
+            executionId: manifest.executionId,
+            issuedAt,
+            commandDigest: manifest.commandDigest,
+            manifestDigest: manifest.manifestDigest,
         });
-        return started;
-    };
-    const startTerminalLoginJob = (job, command) => {
-        // The Terminal-handoff login uses macOS `open -a Terminal`. On non-darwin
-        // there is no such affordance: fail with a typed, actionable state rather
-        // than spawn a missing binary (whose unhandled ENOENT `error` event could
-        // take down the daemon). The manual command is disclosed so the user can
-        // run the native login themselves.
-        if (process.platform !== "darwin") {
-            const failed = update(job.jobId, {
-                state: "failed",
-                startedAt: nowForDto(),
-                finishedAt: nowForDto(),
-                message: `Terminal-handoff login is macOS-only. Run the ${job.harness} native login yourself, then recheck Harness Doctor: ${command}`,
+    }
+    async function observeAndPermit(jobId, state) {
+        let job = store.status(jobId);
+        const manifest = manifestFor(jobId);
+        if (!manifest) {
+            finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login manifest became unavailable after worker observation.`);
+            return;
+        }
+        const handle = parseProcessGroupHandle(state.processGroup);
+        if (!job.authorization ||
+            job.authorization.executionId !== state.executionId ||
+            job.authorization.commandDigest !== state.commandDigest ||
+            job.authorization.manifestDigest !== state.manifestDigest ||
+            manifest.commandDigest !== job.authorization.commandDigest ||
+            manifest.manifestDigest !== job.authorization.manifestDigest ||
+            JSON.stringify(manifest.executable) !== JSON.stringify(job.authorization.executable) ||
+            JSON.stringify(manifest.args) !== JSON.stringify(job.authorization.args) ||
+            !verifyExecutableEvidence(job.authorization.executable)) {
+            finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login command authorization changed before execution permit.`);
+            return;
+        }
+        if (!job.execution?.permitIssuedAt && processGroups.compareLeader(handle) !== "same") {
+            finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login worker identity changed before execution was permitted.`);
+            return;
+        }
+        if (!job.execution) {
+            job = update(jobId, {
+                execution: {
+                    executionId: state.executionId,
+                    commandDigest: state.commandDigest,
+                    manifestDigest: state.manifestDigest,
+                    processGroup: state.processGroup,
+                    observedAt: state.observedAt,
+                },
+                message: `Observed ${job.harness} login worker; recording execution permit.`,
             });
-            writeJobLog(failed, failed.message);
-            return failed;
-        }
-        const scriptPath = join(SETUP_JOBS_DIR, `${job.jobId}.command`);
-        const script = `#!/usr/bin/env bash
-set -euo pipefail
-${command}
-printf '\\nClaudexor setup command finished. Press Return to close this window. '
-IFS= read -r _
-`;
-        writeFileSync(scriptPath, script, { mode: 0o700 });
-        chmodSync(scriptPath, 0o700);
-        writeJobLog(job, `Terminal script: ${scriptPath}`);
-        const child = spawn("/usr/bin/open", ["-a", "Terminal", scriptPath], { detached: true, stdio: "ignore" });
-        // The waiting transition lands FIRST (same synchronous tick as spawn —
-        // child 'error'/'exit' events cannot fire mid-tick), so startedAt is
-        // always stamped before any handler can run.
-        const waiting = update(job.jobId, {
-            state: "waiting_for_input",
-            startedAt: nowForDto(),
-            message: `Opened allowlisted ${job.harness} login in Terminal. Complete native auth there, then recheck Harness Doctor.`,
-        });
-        // A missing/blocked `open` must land as a typed failure, never an
-        // unhandled 'error' event that crashes the daemon. `open` can also fail
-        // AFTER spawning (nonzero exit, or killed by signal) — that path must not
-        // leave the job parked on waiting_for_input either. One transition wins
-        // (settled flag), and a job the user already CANCELLED (or any other
-        // terminal state) is never overwritten by a late child event — the same
-        // cancel-race guard the doctor path uses.
-        let settled = false;
-        const failJob = (detail) => {
-            if (settled)
-                return;
-            settled = true;
-            const current = jobs.get(job.jobId);
-            if (!current || current.state !== "waiting_for_input")
-                return;
-            const failed = update(job.jobId, {
-                state: "failed",
-                finishedAt: nowForDto(),
-                message: `Could not open Terminal for ${job.harness} login: ${detail}. Run it yourself, then recheck Harness Doctor: ${command}`,
+        }
+        else if (!stateMatchesDurableExecution(job, state)) {
+            finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login worker contradicts durable process-group evidence.`);
+            return;
+        }
+        if (!job.execution?.permitIssuedAt) {
+            job = update(jobId, {
+                execution: { ...job.execution, permitIssuedAt: iso() },
+                message: `Durably authorized ${job.harness} native login execution.`,
             });
-            writeJobLog(failed, failed.message);
-        };
-        child.on("error", (err) => failJob(err.message));
-        child.on("exit", (code, signal) => {
-            if (code === 0)
+        }
+        persistPermit(job, manifest);
+        if (job.phase === "launching") {
+            update(jobId, {
+                phase: "awaiting_user",
+                message: `Complete ${job.harness} native login in Terminal.`,
+            });
+        }
+    }
+    async function consumeLoginResult(jobId, result) {
+        let job = store.status(jobId);
+        if (!ACTIVE_SETUP_STATES.has(job.state) || job.phase === "cancelling")
+            return;
+        if (result.permitIssuedAt !== null) {
+            const state = matchingState(jobId);
+            if (!job.execution?.permitIssuedAt ||
+                job.execution.permitIssuedAt !== result.permitIssuedAt ||
+                !state ||
+                state.stage !== "running" ||
+                !stateMatchesDurableExecution(job, state) ||
+                Date.parse(result.finishedAt) < Date.parse(result.permitIssuedAt)) {
+                finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login result is not bound to the durable execution permit.`);
                 return;
-            failJob(code === null ? `\`open -a Terminal\` was terminated by signal ${signal ?? "unknown"}` : `\`open -a Terminal\` exited with code ${code}`);
+            }
+        }
+        else if (job.execution?.permitIssuedAt || result.commandStarted) {
+            finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login result contradicts the durable execution permit.`);
+            return;
+        }
+        job = persistNativeCommandOutcome(jobId, result);
+        if (!result.commandStarted) {
+            finish(jobId, "failed", "launch_failed", result.errorCode === "permit_timeout"
+                ? `${job.harness} login worker timed out before a durable execution permit was issued.`
+                : `${job.harness} login command could not be spawned after authorization.`);
+            return;
+        }
+        if (result.exitCode === 0 && result.signal === null) {
+            await runNativeVerification(jobId, {
+                exitCode: job.nativeCommand.exitCode,
+                signal: job.nativeCommand.signal,
+            });
+            return;
+        }
+        finish(jobId, "failed", "command_failed", `${job.harness} login command failed.`, {
+            exitCode: result.exitCode,
+            signal: result.signal,
         });
-        child.unref();
-        return waiting;
-    };
-    return {
-        create(input) {
-            mkdirSync(SETUP_JOBS_DIR, { recursive: true, mode: 0o700 });
-            const p = (input ?? {});
-            const harness = typeof p["harness"] === "string" ? p["harness"] : "";
-            const action = typeof p["action"] === "string" ? p["action"] : "";
-            const profile = SETUP_PROFILES[harness];
-            if (!profile)
-                throw new Error("unknown harness");
-            if (action !== "install" && action !== "login" && action !== "doctor" && action !== "store_key")
-                throw new Error("unsupported setup job action");
-            const jobId = `setup-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
-            const logPath = join(SETUP_JOBS_DIR, `${jobId}.log`);
-            // Honest retry accounting: a new job for the same harness+action after a
-            // failed one IS the user retrying.
-            const priorFailures = [...jobs.values()].filter((j) => j.harness === harness && j.action === action && (j.state === "failed" || j.state === "cancelled")).length;
-            const base = {
-                jobId,
-                harness: harness,
-                action,
-                state: "queued",
-                command: null,
-                guideUrl: profile.guideUrl,
-                logPath,
-                message: profile.note,
-                riskFlags: action === "install" ? profile.installRiskFlags : [],
-                requiresConfirmation: false,
-                createdAt: nowForDto(),
-                startedAt: null,
-                firstOutputAt: null,
-                lastOutputAt: null,
-                finishedAt: null,
-                retryCount: priorFailures,
-            };
-            writeJobLog(base, `created ${harness} ${action}${priorFailures > 0 ? ` (retry #${priorFailures})` : ""}`);
-            if (action === "login") {
-                if (!profile.loginCommand) {
-                    return save({
-                        ...base,
-                        state: "not_supported",
-                        finishedAt: nowForDto(),
-                        message: `${harness} has no native login command; store API-key fallback refs in Settings.`,
-                    });
+    }
+    function serializeTermination(jobId, task) {
+        const existing = terminations.get(jobId);
+        if (existing)
+            return existing;
+        const operation = supervisor.track(`terminate:${jobId}`, task, { safety: true });
+        terminations.set(jobId, operation);
+        const cleanup = () => {
+            if (terminations.get(jobId) === operation)
+                terminations.delete(jobId);
+        };
+        operation.then(cleanup, cleanup);
+        return operation;
+    }
+    function terminateLogin(jobId, reason) {
+        return serializeTermination(jobId, () => terminateLoginOnce(jobId, reason));
+    }
+    async function terminateLoginOnce(jobId, reason) {
+        const job = store.status(jobId);
+        if (TERMINAL_SETUP_STATES.has(job.state))
+            return job;
+        const result = matchingResult(jobId);
+        if (result)
+            persistNativeCommandOutcome(jobId, result);
+        else
+            update(jobId, { phase: "cancelling", message: `Stopping ${job.harness} login (${reason}).` });
+        verificationControllers.get(jobId)?.abort(new Error(`native login ${reason}`));
+        if (result) {
+            const stateName = reason === "timed_out" ? "timed_out" : "cancelled";
+            return finish(jobId, stateName, reason, `${job.harness} login ${reason}.`, {
+                exitCode: result.exitCode,
+                signal: result.signal,
+            });
+        }
+        const group = processGroupFromJob(job);
+        if (!group) {
+            const stateName = reason === "timed_out" ? "timed_out" : "cancelled";
+            return finish(jobId, stateName, reason, `${job.harness} login ${reason} before execution authorization.`);
+        }
+        const alreadyEmpty = processGroups.probeEmpty(group);
+        if (alreadyEmpty.status !== "empty") {
+            const term = processGroups.signal(group, "SIGTERM");
+            if (term.status === "unknown") {
+                return finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login TERM was refused: ${term.reason}.`);
+            }
+            if (!(await waitForGroupEmpty(group, terminationGraceMs))) {
+                const kill = processGroups.signal(group, "SIGKILL");
+                if (kill.status === "unknown") {
+                    return finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login KILL was refused: ${kill.reason}.`);
                 }
-                const job = save({ ...base, command: profile.loginCommand });
-                return startTerminalLoginJob(job, job.command ?? "");
             }
-            if (action === "doctor") {
-                const job = save({ ...base, command: inProcessDoctorLabel(harness) });
-                return startInProcessDoctorJob(job);
+            if (!(await waitForGroupEmpty(group, terminationGraceMs))) {
+                return finish(jobId, "failed", "termination_unconfirmed", `${job.harness} login process group remained nonempty after SIGKILL.`);
             }
-            if (action === "store_key") {
-                // Honest message: this job only verifies via doctor. The key itself is
-                // stored by the separate Settings store-secret call, never by this job.
-                const job = save({
-                    ...base,
-                    command: inProcessDoctorLabel(harness),
-                    message: `Running post-store doctor for ${harness}. (The key itself is saved via Settings > secrets, not by this job.)`,
-                });
-                return startInProcessDoctorJob(job);
+        }
+        const stateName = reason === "timed_out" ? "timed_out" : "cancelled";
+        return finish(jobId, stateName, reason, `${job.harness} login ${reason}.`);
+    }
+    async function waitForGroupEmpty(handle, maxMs) {
+        let remaining = maxMs;
+        for (;;) {
+            const probe = processGroups.probeEmpty(handle);
+            if (probe.status === "empty")
+                return true;
+            if (probe.status === "unknown")
+                return false;
+            if (remaining <= 0)
+                return false;
+            const step = Math.min(100, remaining);
+            await sleep(step);
+            remaining -= step;
+        }
+    }
+    function markAwaitingUser(jobId) {
+        const current = store.status(jobId);
+        if (current.phase === "launching") {
+            update(jobId, {
+                phase: "awaiting_user",
+                message: `Complete ${current.harness} native login in Terminal.`,
+            });
+        }
+    }
+    async function monitorLogin(jobId) {
+        if (processing.has(jobId))
+            return;
+        const job = store.status(jobId);
+        if (!ACTIVE_SETUP_STATES.has(job.state) || job.phase === "cancelling")
+            return;
+        const result = matchingResult(jobId);
+        if (result) {
+            markAwaitingUser(jobId);
+            await consumeLoginResult(jobId, result);
+            return;
+        }
+        const state = matchingState(jobId);
+        if (state) {
+            await observeAndPermit(jobId, state);
+        }
+        else if (!state &&
+            job.phase === "launching" &&
+            job.startedAt &&
+            now().getTime() - Date.parse(job.startedAt) >= launcherTimeoutMs) {
+            finish(jobId, "failed", "launch_failed", `${job.harness} login worker did not provide an identity handshake within ${launcherTimeoutMs / 1000}s; vendor execution was never permitted.`);
+            return;
+        }
+        const current = store.status(jobId);
+        if (current.deadlineAt && now().getTime() >= Date.parse(current.deadlineAt))
+            await terminateLogin(jobId, "timed_out");
+    }
+    async function tick() {
+        await Promise.all(store.list({ active: true }).map((job) => monitorLogin(job.jobId)));
+    }
+    function settleDurableCapability(job, boundary) {
+        const lifecycle = job.authCapability;
+        const evidence = job.nativeCommand
+            ? { exitCode: job.nativeCommand.exitCode, signal: job.nativeCommand.signal }
+            : {};
+        if (lifecycle?.state === "completed") {
+            finishCapabilityReceipt(job.jobId, lifecycle.receipt, evidence);
+            try {
+                authCapabilityVerifier.cleanup(lifecycle.attemptId);
             }
-            if (!profile.installCommand) {
-                return save({
-                    ...base,
-                    state: "not_supported",
-                    finishedAt: nowForDto(),
-                    message: `${harness} has no native installer; use stored API-key fallback refs instead.`,
-                });
+            catch {
+                /* receipt remains authoritative */
             }
-            return save({
-                ...base,
+            return true;
+        }
+        if (lifecycle?.state !== "running" && lifecycle?.state !== "interrupted_unknown")
+            return false;
+        if (lifecycle.state === "running") {
+            update(job.jobId, {
+                authCapability: { ...lifecycle, state: "interrupted_unknown", interruptedAt: iso() },
+                message: `${job.harness} capability smoke ended during daemon ${boundary} without a verifiable receipt.`,
+            });
+        }
+        finish(job.jobId, "interrupted_unknown", "interrupted_unknown", `${job.harness} capability smoke outcome is unknown after daemon ${boundary}; explicit retry is required.`, evidence);
+        logAfterMutation(job.jobId, `retained auth smoke scratch for ${lifecycle.attemptId} because execution termination is unproven`);
+        return true;
+    }
+    async function reconcileRestart() {
+        for (const job of store.list({ active: true })) {
+            if (settleDurableCapability(job, "restart"))
+                continue;
+            const result = matchingResult(job.jobId);
+            if (result) {
+                markAwaitingUser(job.jobId);
+                await consumeLoginResult(job.jobId, result);
+                continue;
+            }
+            const state = matchingState(job.jobId);
+            if (state) {
+                await observeAndPermit(job.jobId, state);
+                continue;
+            }
+            const group = processGroupFromJob(job);
+            if (!group) {
+                finish(job.jobId, "failed", "interrupted", `${job.harness} login stopped before execution authorization during daemon restart.`);
+                continue;
+            }
+            const empty = processGroups.probeEmpty(group);
+            if (empty.status === "empty") {
+                finish(job.jobId, "failed", "interrupted", `${job.harness} login process ended without a terminal receipt during daemon restart.`);
+            }
+            else {
+                finish(job.jobId, "failed", "termination_unconfirmed", `${job.harness} login has durable process evidence but its worker sidecar is unavailable after restart.`);
+            }
+        }
+    }
+    function startObservableLogin(job, spec, profileConfigDir) {
+        if (platform !== "darwin") {
+            return finish(job.jobId, "failed", "launch_failed", `Terminal-handoff login is macOS-only. Run it yourself, then recheck Harness Doctor: ${spec.displayCommand}`, {}, spec.displayCommand);
+        }
+        try {
+            const paths = store.paths(job.jobId);
+            const executionId = randomUUID();
+            const executable = captureExecutableEvidence(spec.binary);
+            const authorizedCommandDigest = commandDigest(executable, spec.args);
+            const manifest = sealLoginManifest({
+                version: SETUP_LOGIN_PROTOCOL_VERSION,
+                jobId: job.jobId,
+                executionId,
+                harness: job.harness,
+                jobDir: paths.dir,
+                binary: executable.realpath,
+                args: [...spec.args],
+                cwd: paths.dir,
+                // Present ONLY on profile jobs: absent keeps pre-upgrade manifests'
+                // sealed digests valid (the field is optional, never defaulted).
+                ...(profileConfigDir ? { profileConfigDir } : {}),
+                statePath: paths.runnerState,
+                resultPath: paths.runnerResult,
+                permitPath: paths.runnerPermit,
+                permitDeadlineAt: new Date(now().getTime() + launcherTimeoutMs).toISOString(),
+                executable,
+                commandDigest: authorizedCommandDigest,
+            });
+            atomicPrivateJson(paths.manifest, manifest);
+            const script = `#!/usr/bin/env bash\nset -uo pipefail\n${NativeLogin.nativeLoginTerminalExports(job.harness)}set +e\n${shellQuote(nodePath)} ${shellQuote(runnerPath)} ${shellQuote(paths.manifest)}\nstatus=$?\nset -e\nprintf '\\nClaudexor setup command finished (exit %s). Press Return to close this window. ' "$status"\nIFS= read -r _\nexit "$status"\n`;
+            writeFileSync(paths.command, script, { mode: 0o700, flag: "wx" });
+            chmodSync(paths.command, 0o700);
+            const waiting = update(job.jobId, {
                 state: "waiting_for_input",
-                command: profile.installCommand,
-                requiresConfirmation: true,
-                message: `Confirm to run allowlisted ${harness} installer. Risks: ${profile.installRiskFlags.join(", ") || "standard process execution"}.`,
+                phase: "launching",
+                deadlineAt: new Date(now().getTime() + loginTimeoutMs).toISOString(),
+                startedAt: iso(),
+                command: spec.displayCommand,
+                authorization: {
+                    executionId,
+                    executable,
+                    args: [...spec.args],
+                    commandDigest: authorizedCommandDigest,
+                    manifestDigest: manifest.manifestDigest,
+                },
+                message: `Opening allowlisted ${job.harness} native login in Terminal.`,
+            });
+            log(job.jobId, `Terminal script: ${paths.command}`);
+            const opener = openTerminal(paths.command);
+            const failLaunch = (detail) => {
+                if (!["idle", "healthy"].includes(supervisor.health().state))
+                    return;
+                const current = store.status(job.jobId);
+                if (current.phase !== "launching")
+                    return;
+                finish(job.jobId, "failed", "launch_failed", `Could not open Terminal for ${job.harness} login: ${detail}.`, {}, spec.displayCommand);
+            };
+            opener.once("error", (err) => failLaunch(err.message));
+            opener.once("exit", (code, signal) => {
+                if (code !== 0)
+                    failLaunch(signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`);
             });
+            opener.unref();
+            return waiting;
+        }
+        catch (err) {
+            return finish(job.jobId, "failed", "launch_failed", `Could not prepare or open Terminal for ${job.harness} login: ${err instanceof Error ? err.message : String(err)}.`, {}, spec.displayCommand);
+        }
+    }
+    supervisor = new SetupSupervisor({
+        pollMs: opts.monitorPollMs ?? 250,
+        recoveryRequired: () => store.recoveryState().status === "recovery_required",
+        reconcile: reconcileRestart,
+        tick,
+        abortInFlight: (reason) => {
+            for (const controller of verificationControllers.values())
+                controller.abort(reason);
         },
-        confirm(input) {
-            const p = (input ?? {});
-            const jobId = typeof p["jobId"] === "string" ? p["jobId"] : "";
-            const confirmed = p["confirmed"] !== false;
-            const job = jobs.get(jobId);
-            if (!job)
-                throw Object.assign(new Error("setup job not found"), { status: 404 });
-            if (!confirmed)
-                return job;
-            if (!job.requiresConfirmation || job.action !== "install" || !job.command) {
-                throw new Error("setup job does not require confirmation");
+    });
+    let shutdownPromise = null;
+    function beginDrain() {
+        supervisor.beginDrain();
+    }
+    function shutdown() {
+        shutdownPromise ??= (async () => {
+            beginDrain();
+            let firstError;
+            let unconfirmed;
+            const rememberError = (error) => {
+                firstError ??= error;
+                supervisor.reportFailure(error, "setup-shutdown");
+            };
+            try {
+                const active = store.recoveryState().status === "ready" ? store.list({ active: true }) : [];
+                const waitingLogins = active.filter((job) => job.authCapability?.state !== "running" &&
+                    job.authCapability?.state !== "completed" &&
+                    job.authCapability?.state !== "interrupted_unknown");
+                const stopped = await Promise.allSettled(waitingLogins.map((job) => terminateLogin(job.jobId, "cancelled_on_restart")));
+                for (const result of stopped) {
+                    if (result.status === "rejected")
+                        rememberError(result.reason);
+                    else if (result.value.outcome?.reason === "termination_unconfirmed") {
+                        unconfirmed ??= result.value;
+                    }
+                }
+            }
+            catch (error) {
+                rememberError(error);
+            }
+            await supervisor.shutdown();
+            try {
+                if (store.recoveryState().status === "ready") {
+                    for (const job of store.list({ active: true })) {
+                        settleDurableCapability(job, "shutdown");
+                    }
+                }
+            }
+            catch (error) {
+                rememberError(error);
             }
-            if (job.state !== "waiting_for_input") {
-                throw new Error(`setup job cannot be confirmed while ${job.state}`);
+            if (unconfirmed) {
+                throw Object.assign(new Error(`setup shutdown could not prove termination for ${unconfirmed.jobId}`), { code: "setup_shutdown_unconfirmed", status: 503 });
             }
-            const ready = save({ ...job, requiresConfirmation: false });
-            // Shell phase = the native installer only; verification runs in-process.
-            return startShellJob(ready, ready.command ?? "", runInProcessDoctor);
+            if (firstError !== undefined)
+                throw firstError;
+        })();
+        return shutdownPromise;
+    }
+    return {
+        start: () => supervisor.start(),
+        beginDrain,
+        shutdown,
+        create(input, idempotency) {
+            const request = ControlSetupJobCreateRequest.parse(input);
+            const { harness, action } = request;
+            const profileBinding = resolveProfileBinding(harness, request.profileId);
+            const binding = idempotency ? { ...idempotency, request } : undefined;
+            const prior = binding ? store.resolveCreate(binding) : null;
+            if (prior)
+                return prior;
+            supervisor.assertCreateAllowed();
+            const jobs = store.list({ harness });
+            const active = jobs.findLast((job) => ACTIVE_SETUP_STATES.has(job.state));
+            if (active) {
+                // Same target store → idempotent reuse. A DIFFERENT target (default vs
+                // profile, or two profiles) must refuse loudly: returning the other job
+                // would hand the caller a login into the wrong store.
+                if ((active.profileId ?? null) === (profileBinding?.profileId ?? null)) {
+                    return binding ? store.bindCreate(active.jobId, binding) : active;
+                }
+                throw Object.assign(new Error(`another ${harness} login job is active (${active.jobId}, ${active.profileId ? `profile "${active.profileId}"` : "default store"}); finish or cancel it before starting a ${profileBinding ? `profile "${profileBinding.profileId}"` : "default-store"} login`), { status: 409 });
+            }
+            const replacementFence = jobs.findLast((job) => job.outcome?.reason === "termination_unconfirmed" && !job.terminationReconciliation);
+            if (replacementFence) {
+                return binding ? store.bindCreate(replacementFence.jobId, binding) : replacementFence;
+            }
+            const profile = SETUP_PROFILES[harness];
+            const jobId = `setup-${now().getTime().toString(36)}-${randomUUID().slice(0, 8)}`;
+            const authCapability = {
+                ...authCapabilityVerifier.prepare({
+                    attemptId: `auth-${randomUUID()}`,
+                    harness,
+                    requested: "subscription",
+                    requiredRoute: "vendor_native",
+                    requiredSource: "native_session",
+                }).binding,
+                state: "disclosed",
+            };
+            const base = store.create({
+                jobId,
+                harness,
+                action,
+                state: "queued",
+                phase: "preparing",
+                command: null,
+                guideUrl: profile.guideUrl,
+                message: profileBinding
+                    ? `${profile.note} This login targets the scoped Claudexor profile "${profileBinding.profileId}" (INV-135); the default vendor store is never touched.`
+                    : `${profile.note} The required same-harness smoke may consume quota; incremental billing is unknown.`,
+                createdAt: iso(),
+                startedAt: null,
+                finishedAt: null,
+                authCapability,
+                profileId: profileBinding?.profileId ?? null,
+            }, binding);
+            log(jobId, `created ${harness} ${action}${profileBinding ? ` for profile "${profileBinding.profileId}"` : ""}`);
+            const spec = NativeLogin.nativeLoginSpec(harness);
+            if (!spec)
+                return finish(jobId, "not_supported", "not_supported", `${harness} native login is unavailable; install the vendor CLI first.`);
+            return startObservableLogin(base, spec, profileBinding?.configDir);
         },
-        list() {
-            return [...jobs.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        list(filter) {
+            return store.list(filter);
         },
         status(input) {
             const p = (input ?? {});
-            const jobId = typeof p["jobId"] === "string" ? p["jobId"] : "";
-            const job = jobs.get(jobId);
-            if (!job)
-                throw Object.assign(new Error("setup job not found"), { status: 404 });
-            return job;
+            return store.status(typeof p.jobId === "string" ? p.jobId : "");
+        },
+        snapshot(input) {
+            const p = (input ?? {});
+            return store.snapshot(typeof p.jobId === "string" ? p.jobId : "");
         },
-        cancel(input) {
+        events(input) {
             const p = (input ?? {});
-            const jobId = typeof p["jobId"] === "string" ? p["jobId"] : "";
-            const job = jobs.get(jobId);
-            if (!job)
-                throw Object.assign(new Error("setup job not found"), { status: 404 });
-            // A terminal job has nothing to cancel; overwriting `succeeded`/`failed`
-            // with `cancelled` would falsify history (the Terminal-handoff child
-            // handlers already refuse this overwrite — the endpoint must too).
-            // Idempotent: return the terminal record unchanged.
-            if (job.state === "succeeded" || job.state === "failed" || job.state === "cancelled" || job.state === "not_supported") {
+            const jobId = typeof p.jobId === "string" ? p.jobId : "";
+            const afterCursor = typeof p.afterCursor === "string" ? p.afterCursor : null;
+            return store.events(jobId, afterCursor);
+        },
+        async cancel(input) {
+            const p = (input ?? {});
+            const jobId = typeof p.jobId === "string" ? p.jobId : "";
+            const job = store.status(jobId);
+            if (TERMINAL_SETUP_STATES.has(job.state))
                 return job;
+            return terminateLogin(jobId, "cancelled_by_user");
+        },
+        reconcile(input) {
+            supervisor.assertCreateAllowed();
+            const p = (input ?? {});
+            const jobId = typeof p.jobId === "string" ? p.jobId : "";
+            const job = store.status(jobId);
+            if (job.terminationReconciliation)
+                return job;
+            if (job.outcome?.reason !== "termination_unconfirmed") {
+                throw Object.assign(new Error("setup job has no unconfirmed termination to reconcile"), {
+                    code: "setup_reconciliation_not_applicable",
+                    status: 409,
+                });
             }
-            const child = children.get(jobId);
-            if (child) {
-                child.kill("SIGTERM");
-                children.delete(jobId);
+            const group = processGroupFromJob(job);
+            if (!group || processGroups.probeEmpty(group).status !== "empty") {
+                throw Object.assign(new Error("setup process group is not proven empty"), {
+                    code: "setup_termination_unconfirmed",
+                    status: 409,
+                    requiredActions: ["retry_setup_reconciliation"],
+                });
             }
-            clearTimeout(timeouts.get(jobId));
-            timeouts.delete(jobId);
-            const cancelled = update(jobId, { state: "cancelled", finishedAt: nowForDto(), message: `Cancelled ${job.harness} ${job.action} setup job.` });
-            writeJobLog(cancelled, cancelled.message);
-            return cancelled;
+            return update(jobId, {
+                terminationReconciliation: { status: "empty", observedAt: iso() },
+                message: `${job.harness} login process group is confirmed empty; replacement is allowed.`,
+            });
         },
+        extend(input) {
+            supervisor.assertCreateAllowed();
+            const p = (input ?? {});
+            const jobId = typeof p.jobId === "string" ? p.jobId : "";
+            const job = store.status(jobId);
+            if (!ACTIVE_SETUP_STATES.has(job.state) ||
+                !["launching", "awaiting_user"].includes(job.phase ?? "") ||
+                !job.deadlineAt) {
+                throw Object.assign(new Error("setup job cannot be extended"), { status: 409 });
+            }
+            return update(jobId, {
+                deadlineAt: new Date(Date.parse(job.deadlineAt) + LOGIN_EXTENSION_MS).toISOString(),
+                message: `${job.harness} login deadline extended by 15 minutes.`,
+            });
+        },
+        _store: store,
+        _supervisorHealth: () => supervisor.health(),
     };
 }
-function setupJobEnv() {
-    const runtime = harnessRuntimeEnv();
-    const env = {
-        HOME: runtime.HOME,
-        PATH: runtime.PATH,
-        SHELL: process.env.SHELL ?? "/bin/bash",
-        TMPDIR: process.env.TMPDIR,
-        LANG: process.env.LANG,
-        LC_ALL: process.env.LC_ALL,
-        USER: process.env.USER,
-        LOGNAME: process.env.LOGNAME,
-    };
-    for (const key of Object.keys(env)) {
-        if (env[key] === undefined)
-            delete env[key];
-    }
-    return env;
-}
-function nowForDto() {
-    return new Date().toISOString();
-}
 //# sourceMappingURL=setup-jobs.js.map