@openrig/cli 0.4.8 → 0.5.1

package/node_modules/@openrig/daemon/dist/domain/restore-check-service.js

@@ -0,0 +1,1139 @@
+import { accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative } from "node:path";
+import { getCompatibleOpenRigPath } from "../openrig-compat.js";
+// --- Service ---
+const DAEMON_HEALTHY_PATTERN = /^Daemon running\b/m;
+// OPR.0.3.2.14 — fallback subpath uses a generic .openrig placeholder
+// rather than an internal-team layout, to close the source-side
+// privacy leak. Fallback preserved per slice README §"Architecture
+// note" (option-A removal cascaded 36 test yellows in 0.3.1 cleanup).
+const SUBSTRATE_SHARED_DOCS_ROOT = process.env["OPENRIG_SUBSTRATE_SHARED_DOCS"]
+    ?? join(homedir(), ".openrig", "shared-docs");
+// OPR.0.3.2.14 — these four constants used to be copy-pasted in 7+
+// test files. Exporting from source + importing in tests eliminates
+// the divergence class that broke 17 tests during 0.3.1 cleanup.
+export const CLAUDE_HOOKS_ROOT = join(SUBSTRATE_SHARED_DOCS_ROOT, "control-plane", "services", "claude-hooks");
+export const CLAUDE_SESSION_START_COMPACT_COMMAND = join(CLAUDE_HOOKS_ROOT, "bin", "session-start-compact-context.sh");
+export const CLAUDE_USER_PROMPT_SUBMIT_COMMAND = join(CLAUDE_HOOKS_ROOT, "bin", "userpromptsubmit-queue-attention.sh");
+export const CLAUDE_HOOK_FRAGMENT_PATH = join(CLAUDE_HOOKS_ROOT, "config", "settings.fragment.json");
+export class RestoreCheckService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    check(opts) {
+        const checks = [];
+        // rev1-r2 no-false-ready: ready-seat caveat signals that default compact
+        // COMPUTES but does NOT emit (AC-4 token-safe) still count toward the
+        // top-level verdict/readiness/counts, so the headline never reports a false
+        // ready while a rig rollup is ready_with_caveats.
+        const deferredAssessmentChecks = [];
+        const rigRollupInputs = [];
+        const recoveryRigInputs = [];
+        // Host-level checks — daemon probe throw produces unknown (not not_restorable).
+        // Daemon definitely-down (healthy=false, negative text) is red/not_restorable.
+        // Daemon probe exception (socket unavailable, etc.) is unknown.
+        const daemonCheck = this.checkDaemonReachable();
+        if (daemonCheck === null) {
+            // Probe threw — state is uninspectable
+            return this.buildUnknown([
+                { check: "daemon.reachable", status: "red", evidence: "Daemon health probe failed (unable to determine state)", remediation: "Start the daemon with: rig daemon start",
+                    remediationSafe: false },
+            ]);
+        }
+        checks.push(daemonCheck);
+        checks.push(this.checkStateDirWritable());
+        const hostInfraCheck = this.checkHostInfraDeclaration();
+        checks.push(hostInfraCheck.check);
+        // Get rigs — probe error produces unknown, not not_restorable
+        let rigs;
+        try {
+            rigs = this.deps.listRigs();
+        }
+        catch (err) {
+            return this.buildUnknown([
+                ...checks,
+                { check: "probe.error", status: "red", evidence: `Failed to list rigs: ${err instanceof Error ? err.message : String(err)}`, remediation: "Check daemon status with: rig daemon status", remediationSafe: true },
+            ]);
+        }
+        if (opts.rig) {
+            rigs = rigs.filter((r) => r.name === opts.rig);
+            if (rigs.length === 0) {
+                return this.buildResult([
+                    ...checks,
+                    { check: `rig.${opts.rig}.exists`, status: "red", evidence: `Rig "${opts.rig}" not found`, remediation: "List rigs with: rig ps", remediationSafe: true },
+                ], [], hostInfraCheck.hostInfra);
+            }
+        }
+        // Per-rig checks
+        for (const rig of rigs) {
+            const rigChecks = [];
+            const snapshotCheck = this.checkSnapshot(rig);
+            checks.push(snapshotCheck);
+            rigChecks.push(snapshotCheck);
+            // Rig spec/root check
+            const specCheck = this.checkSpecPresent(rig);
+            checks.push(specCheck);
+            rigChecks.push(specCheck);
+            // Per-seat checks — probe error produces unknown, not not_restorable
+            let nodes;
+            try {
+                nodes = this.deps.getNodeInventory(rig.rigId);
+            }
+            catch (err) {
+                return this.buildUnknown([
+                    ...checks,
+                    { check: "probe.error", status: "red", evidence: `Failed to get node inventory for ${rig.name}: ${err instanceof Error ? err.message : String(err)}`, remediation: "Check daemon status" },
+                ]);
+            }
+            for (const node of nodes) {
+                const readinessCheck = this.checkSeatReadiness(node);
+                checks.push(readinessCheck);
+                rigChecks.push(readinessCheck);
+                // OPR.0.4.0.29: in default compact, ready (green) seats SKIP full per-seat
+                // detail assembly — the FR-3/AC-4 compute "look-above" win (transcript,
+                // resume, queue, hooks are NOT probed). But the FR-8 summary still needs
+                // the restore-readiness caveat signal: a running/ready seat whose startup
+                // context is missing/unrestorable is ready_with_caveats, not ready. So we
+                // compute ONLY checkStartupContext for every seat and feed it to the rig
+                // rollup (rigChecks); it is emitted to the top-level `checks` only when we
+                // are not skipping (full, --ready/includeReady, or a non-ready seat).
+                const omitReadyDetail = opts.compact && !opts.includeReady && readinessCheck.status === "green";
+                const startupContextCheck = this.checkStartupContext(node);
+                if ("unknownChecks" in startupContextCheck) {
+                    return this.buildUnknown([
+                        ...checks,
+                        ...startupContextCheck.unknownChecks,
+                    ]);
+                }
+                rigChecks.push(startupContextCheck.check);
+                if (omitReadyDetail) {
+                    // Not emitted (AC-4 token-safe), but counts toward the top-level
+                    // verdict/readiness/counts (rev1-r2 no-false-ready).
+                    deferredAssessmentChecks.push(startupContextCheck.check);
+                }
+                else {
+                    checks.push(startupContextCheck.check);
+                }
+                // AC-4 / FR-3: default compact does NOT assemble the rest of the
+                // ready-seat detail (the genuine compute skip, not a post-assembly hide).
+                if (omitReadyDetail) {
+                    continue;
+                }
+                const transcriptCheck = this.checkTranscript(rig.name, node);
+                checks.push(transcriptCheck);
+                rigChecks.push(transcriptCheck);
+                const resumeCheck = this.checkResumePath(node);
+                checks.push(resumeCheck);
+                rigChecks.push(resumeCheck);
+                if (!opts.noQueue) {
+                    const queueCheck = this.checkQueueFile(rig.name, node);
+                    checks.push(queueCheck);
+                    rigChecks.push(queueCheck);
+                }
+                if (!opts.noHooks) {
+                    const hooksCheck = this.checkHooks(node);
+                    checks.push(hooksCheck);
+                    rigChecks.push(hooksCheck);
+                }
+            }
+            rigRollupInputs.push({ rig, nodes, checks: rigChecks });
+        }
+        const rigRollups = rigRollupInputs.map((input) => this.buildRigRollup(input));
+        for (const rollup of rigRollups) {
+            const latestSnapshot = this.inspectLatestSnapshot(rollup.rigId);
+            recoveryRigInputs.push({
+                rigId: rollup.rigId,
+                rigName: rollup.rigName,
+                expectedNodes: rollup.expectedNodes,
+                runningReadyNodes: rollup.runningReadyNodes,
+                blockingChecks: rollup.blockingChecks,
+                latestSnapshot: latestSnapshot.snapshot,
+                snapshotLookupError: latestSnapshot.error,
+            });
+        }
+        return this.buildResult(checks, rigRollups, hostInfraCheck.hostInfra, recoveryRigInputs, deferredAssessmentChecks);
+    }
+    /** Returns CheckEntry on success/definite-down; null on probe exception
+     *  (uninspectable state → caller should produce verdict: unknown). */
+    checkDaemonReachable() {
+        try {
+            const probe = this.deps.probeDaemonHealth();
+            // Anchored positive match: only "Daemon running" at line start is green.
+            // Anything else (including "Daemon not running", empty output, or text
+            // that contains "running" non-anchored) is red. This preserves the
+            // reviewer fix from prototype 0e2af8d.
+            if (probe.healthy && DAEMON_HEALTHY_PATTERN.test(probe.evidence)) {
+                return { check: "daemon.reachable", status: "green", evidence: probe.evidence, remediation: "" };
+            }
+            return {
+                check: "daemon.reachable", status: "red",
+                evidence: probe.evidence || "Daemon health probe returned non-positive result",
+                remediation: "Start the daemon with: rig daemon start",
+                remediationSafe: false,
+            };
+        }
+        catch {
+            // Probe threw — return null to signal uninspectable state
+            return null;
+        }
+    }
+    checkStateDirWritable() {
+        const stateDir = getCompatibleOpenRigPath("");
+        try {
+            // Non-mutating permission probe — no file creation/deletion.
+            // accessSync throws if the directory is not writable.
+            accessSync(stateDir, constants.W_OK);
+            return { check: "host.state-dir-writable", status: "green", evidence: `${stateDir} is writable`, remediation: "" };
+        }
+        catch {
+            return {
+                check: "host.state-dir-writable", status: "red",
+                evidence: `${stateDir} is not writable`,
+                remediation: `Fix permissions: chmod u+w ${stateDir}`,
+                remediationSafe: false,
+            };
+        }
+    }
+    checkHostInfraDeclaration() {
+        const declarationPath = getCompatibleOpenRigPath("host-infra.json");
+        const check = "host.bootstrap-autostart.declaration";
+        try {
+            if (!this.deps.exists(declarationPath)) {
+                const evidence = `Host infra declaration missing at ${declarationPath}`;
+                return {
+                    check: {
+                        check,
+                        status: "yellow",
+                        evidence,
+                        remediation: `Create host infra declaration at ${declarationPath}`,
+                        remediationSafe: false,
+                    },
+                    hostInfra: {
+                        status: "not_declared",
+                        evidence,
+                    },
+                };
+            }
+            let raw;
+            try {
+                raw = this.deps.readFile(declarationPath);
+            }
+            catch (err) {
+                const evidence = `Host infra declaration inspection failed at ${declarationPath}: ${err instanceof Error ? err.message : String(err)}`;
+                return {
+                    check: {
+                        check,
+                        status: "yellow",
+                        evidence,
+                        remediation: `Inspect or fix host infra declaration at ${declarationPath}`,
+                        remediationSafe: false,
+                    },
+                    hostInfra: {
+                        status: "unknown",
+                        evidence,
+                    },
+                };
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (err) {
+                const evidence = `Host infra declaration JSON parse failed at ${declarationPath}: ${err instanceof Error ? err.message : String(err)}`;
+                return {
+                    check: {
+                        check,
+                        status: "yellow",
+                        evidence,
+                        remediation: `Fix host infra declaration JSON at ${declarationPath}`,
+                        remediationSafe: false,
+                    },
+                    hostInfra: {
+                        status: "not_declared",
+                        evidence,
+                    },
+                };
+            }
+            const validation = this.validateHostInfraDeclaration(parsed);
+            if (validation.errors.length > 0) {
+                const evidence = `Invalid host infra declaration at ${declarationPath}: missing/invalid ${validation.errors.join(", ")}`;
+                return {
+                    check: {
+                        check,
+                        status: "yellow",
+                        evidence,
+                        remediation: `Fix host infra declaration shape at ${declarationPath}`,
+                        remediationSafe: false,
+                    },
+                    hostInfra: {
+                        status: "not_declared",
+                        evidence,
+                    },
+                };
+            }
+            if (validation.schemaVersion === 2 && validation.evidenceProblems.length > 0) {
+                const evidence = `Host infra declaration at ${declarationPath} declared with insufficient evidence paths; ${validation.evidenceProblems.join("; ")}`;
+                return {
+                    check: {
+                        check,
+                        status: "yellow",
+                        evidence,
+                        remediation: `Add or repair host infra evidence path(s): ${validation.evidenceProblems.join("; ")}`,
+                        remediationSafe: false,
+                    },
+                    hostInfra: {
+                        status: "declared",
+                        evidence,
+                    },
+                };
+            }
+            const evidence = validation.schemaVersion === 2
+                ? `Host infra declaration at ${declarationPath} declared, evidence paths present, not autostart verified; daemonBootstrap mechanism=${validation.mechanism}; requiredSupportingInfra=${validation.requiredSupportingInfra}; evidencePaths=${validation.evidencePaths.join(", ")}`
+                : `Host infra declaration at ${declarationPath} declared, not verified; daemonBootstrap mechanism=${validation.mechanism}; requiredSupportingInfra=${validation.requiredSupportingInfra}`;
+            return {
+                check: {
+                    check,
+                    status: "green",
+                    evidence,
+                    remediation: "",
+                },
+                hostInfra: {
+                    status: "declared",
+                    evidence,
+                },
+            };
+        }
+        catch (err) {
+            const evidence = `Host infra declaration inspection failed at ${declarationPath}: ${err instanceof Error ? err.message : String(err)}`;
+            return {
+                check: {
+                    check,
+                    status: "yellow",
+                    evidence,
+                    remediation: `Inspect or fix host infra declaration at ${declarationPath}`,
+                    remediationSafe: false,
+                },
+                hostInfra: {
+                    status: "unknown",
+                    evidence,
+                },
+            };
+        }
+    }
+    validateHostInfraDeclaration(value) {
+        const errors = [];
+        const evidencePaths = [];
+        const evidenceProblems = [];
+        const obj = isRecord(value) ? value : null;
+        if (obj === null) {
+            return {
+                errors: ["schemaVersion", "daemonBootstrap.mechanism", "supportingInfra"],
+                schemaVersion: null,
+                mechanism: "unknown",
+                requiredSupportingInfra: 0,
+                evidencePaths,
+                evidenceProblems,
+            };
+        }
+        const schemaVersion = obj["schemaVersion"] === 1 || obj["schemaVersion"] === 2
+            ? obj["schemaVersion"]
+            : null;
+        if (schemaVersion === null) {
+            errors.push("schemaVersion");
+        }
+        const daemonBootstrap = isRecord(obj["daemonBootstrap"]) ? obj["daemonBootstrap"] : null;
+        const mechanism = daemonBootstrap && typeof daemonBootstrap["mechanism"] === "string"
+            ? daemonBootstrap["mechanism"].trim()
+            : "";
+        if (!mechanism) {
+            errors.push("daemonBootstrap.mechanism");
+        }
+        if (daemonBootstrap?.["declared"] !== true) {
+            errors.push("daemonBootstrap.declared");
+        }
+        const supportingInfra = Array.isArray(obj["supportingInfra"]) ? obj["supportingInfra"] : null;
+        if (!supportingInfra) {
+            errors.push("supportingInfra");
+        }
+        const requiredSupportingInfra = supportingInfra
+            ? supportingInfra.filter((entry) => isRecord(entry) && entry["required"] === true).length
+            : 0;
+        if (schemaVersion === 2 && errors.length === 0) {
+            this.collectRequiredEvidencePaths("daemonBootstrap.evidencePaths", daemonBootstrap?.["evidencePaths"], evidencePaths, evidenceProblems);
+            supportingInfra?.forEach((entry, index) => {
+                if (!isRecord(entry) || entry["required"] !== true)
+                    return;
+                const id = typeof entry["id"] === "string" && entry["id"].trim()
+                    ? entry["id"].trim()
+                    : String(index);
+                this.collectRequiredEvidencePaths(`supportingInfra[${id}].evidencePaths`, entry["evidencePaths"], evidencePaths, evidenceProblems);
+            });
+        }
+        return {
+            errors,
+            schemaVersion,
+            mechanism: mechanism || "unknown",
+            requiredSupportingInfra,
+            evidencePaths,
+            evidenceProblems,
+        };
+    }
+    collectRequiredEvidencePaths(label, value, evidencePaths, evidenceProblems) {
+        if (!Array.isArray(value) || value.length === 0) {
+            evidenceProblems.push(`${label} missing or empty`);
+            return;
+        }
+        for (const candidate of value) {
+            if (typeof candidate !== "string" || candidate.trim() === "") {
+                evidenceProblems.push(`${label} contains invalid evidence path ${String(candidate)}`);
+                continue;
+            }
+            const resolved = this.resolveHostInfraEvidencePath(candidate.trim());
+            if ("error" in resolved) {
+                evidenceProblems.push(`${label} invalid evidence path ${candidate}: ${resolved.error}`);
+                continue;
+            }
+            const resolvedPath = resolved.path;
+            evidencePaths.push(resolvedPath);
+            if (!this.deps.exists(resolvedPath)) {
+                evidenceProblems.push(`${label} missing evidence path ${resolvedPath}`);
+            }
+        }
+    }
+    resolveHostInfraEvidencePath(rawPath) {
+        const openRigPrefix = "${OPENRIG_HOME}/";
+        const hasTraversal = rawPath.split(/[\\/]+/).includes("..");
+        if (rawPath.startsWith(openRigPrefix)) {
+            const relativePath = rawPath.slice(openRigPrefix.length);
+            if (!relativePath || isAbsolute(relativePath) || hasTraversal) {
+                return { error: "path traversal or empty OPENRIG_HOME-relative path rejected" };
+            }
+            const openRigHome = getCompatibleOpenRigPath("");
+            const resolved = join(openRigHome, relativePath);
+            const relativeToHome = relative(openRigHome, resolved);
+            if (relativeToHome.startsWith("..") || isAbsolute(relativeToHome)) {
+                return { error: "path traversal outside OPENRIG_HOME rejected" };
+            }
+            return { path: resolved };
+        }
+        if (!isAbsolute(rawPath)) {
+            return { error: "plain relative evidence paths are rejected; use absolute or ${OPENRIG_HOME}/..." };
+        }
+        if (hasTraversal) {
+            return { error: "path traversal evidence paths are rejected" };
+        }
+        return { path: rawPath };
+    }
+    checkSnapshot(rig) {
+        try {
+            const has = this.deps.hasSnapshot(rig.rigId);
+            if (has) {
+                return { check: `rig.${rig.name}.snapshot`, status: "green", evidence: "Snapshot available", remediation: "" };
+            }
+            return {
+                check: `rig.${rig.name}.snapshot`, status: "yellow",
+                evidence: "No snapshot found (first-boot or adopted rig)",
+                remediation: "Create a snapshot with: rig snapshot <rigId>",
+                remediationSafe: false,
+            };
+        }
+        catch {
+            return { check: `rig.${rig.name}.snapshot`, status: "yellow", evidence: "Could not check snapshots", remediation: "" };
+        }
+    }
+    checkTranscript(rigName, node) {
+        const session = node.canonicalSessionName ?? node.logicalId;
+        const check = `seat.${session}.transcript`;
+        // Terminal/infrastructure nodes are exempt from transcript checks
+        if (node.nodeKind === "infrastructure") {
+            return { check, status: "green", evidence: "Terminal/infrastructure node — transcript exempt", remediation: "" };
+        }
+        const transcriptPath = join(getCompatibleOpenRigPath("transcripts"), rigName, `${session}.log`);
+        if (this.deps.exists(transcriptPath)) {
+            return { check, status: "green", evidence: `Transcript exists at ${transcriptPath}`, remediation: "" };
+        }
+        return {
+            check, status: "yellow",
+            evidence: `Transcript missing: ${transcriptPath}`,
+            remediation: "Transcript will be created on next session launch",
+            remediationSafe: true,
+        };
+    }
+    checkSeatReadiness(node) {
+        const session = node.canonicalSessionName ?? node.logicalId;
+        const check = `seat.${session}.readiness`;
+        if (!node.canonicalSessionName) {
+            return {
+                check,
+                status: "red",
+                evidence: "Missing canonical session identity",
+                remediation: "Restore or relaunch the seat so it has a canonical session identity",
+                remediationSafe: false,
+            };
+        }
+        if (node.sessionStatus !== "running" || node.startupStatus !== "ready") {
+            const latestError = node.latestError ? ` latestError=${node.latestError}` : "";
+            return {
+                check,
+                status: "red",
+                evidence: `Seat not running/ready: sessionStatus=${node.sessionStatus ?? "unknown"} startupStatus=${node.startupStatus ?? "unknown"}${latestError}`,
+                remediation: "Restore or relaunch the seat, then rerun rig restore-check",
+                remediationSafe: false,
+            };
+        }
+        return {
+            check,
+            status: "green",
+            evidence: `Seat running and ready: ${node.canonicalSessionName}`,
+            remediation: "",
+        };
+    }
+    checkResumePath(node) {
+        const session = node.canonicalSessionName ?? node.logicalId;
+        if (node.tmuxAttachCommand) {
+            return { check: `seat.${session}.resume-path`, status: "green", evidence: node.tmuxAttachCommand, remediation: "" };
+        }
+        return {
+            check: `seat.${session}.resume-path`, status: "yellow",
+            evidence: "No attach command available",
+            remediation: "Session will be created fresh on restore",
+            remediationSafe: true,
+        };
+    }
+    checkStartupContext(node) {
+        const session = node.canonicalSessionName ?? node.logicalId;
+        const check = `seat.${session}.startup-context`;
+        const runningReady = node.sessionStatus === "running" && node.startupStatus === "ready";
+        if (!node.nodeId) {
+            return {
+                check: this.buildStartupContextAvailabilityCheck(check, runningReady, `Startup context cannot be inspected because node id is missing for ${session}`),
+            };
+        }
+        const probe = this.deps.getStartupContext(node.nodeId);
+        switch (probe.status) {
+            case "probe_error":
+                return {
+                    unknownChecks: [{
+                            check: "probe.error",
+                            status: "red",
+                            evidence: `Failed to inspect startup context for ${session}: ${probe.evidence}`,
+                            remediation: "Check daemon logs with: rig daemon logs",
+                            remediationSafe: true,
+                        }],
+                };
+            case "missing":
+            case "malformed":
+                return {
+                    check: this.buildStartupContextAvailabilityCheck(check, runningReady, probe.evidence),
+                };
+            case "ok":
+                break;
+        }
+        const startupContext = probe;
+        const missingRequired = startupContext.resolvedStartupFiles.filter((file) => file.required && !this.deps.exists(file.absolutePath));
+        const missingOptional = startupContext.resolvedStartupFiles.filter((file) => !file.required && !this.deps.exists(file.absolutePath));
+        const missingProjectionEntries = startupContext.projectionEntries.filter((entry) => !this.deps.exists(entry.absolutePath));
+        if (missingRequired.length === 0 && missingOptional.length === 0 && missingProjectionEntries.length === 0) {
+            const detailParts = [];
+            if (startupContext.resolvedStartupFiles.length > 0) {
+                detailParts.push(`resolved startup files present: ${startupContext.resolvedStartupFiles.map((file) => file.absolutePath).join(", ")}`);
+            }
+            if (startupContext.projectionEntries.length > 0) {
+                detailParts.push(`projection source paths present: ${startupContext.projectionEntries.map((entry) => entry.absolutePath).join(", ")}`);
+            }
+            if (detailParts.length === 0) {
+                detailParts.push("no persisted startup files or projection source paths declared");
+            }
+            return {
+                check: {
+                    check,
+                    status: "green",
+                    evidence: `Startup context present for node ${node.nodeId}; ${detailParts.join("; ")}`,
+                    remediation: "",
+                },
+            };
+        }
+        const evidenceParts = [];
+        if (missingRequired.length > 0) {
+            evidenceParts.push(`missing required startup file(s): ${missingRequired.map((file) => file.absolutePath).join(", ")}`);
+        }
+        if (missingOptional.length > 0) {
+            evidenceParts.push(`missing optional startup file(s): ${missingOptional.map((file) => file.absolutePath).join(", ")}`);
+        }
+        if (missingProjectionEntries.length > 0) {
+            evidenceParts.push(`missing projection source path(s): ${missingProjectionEntries.map((entry) => entry.absolutePath).join(", ")}`);
+        }
+        const status = missingRequired.length > 0 && !runningReady ? "red" : "yellow";
+        return {
+            check: {
+                check,
+                status,
+                evidence: `Startup context present for node ${node.nodeId}, but replay inputs are incomplete: ${evidenceParts.join("; ")}`,
+                remediation: `Restore or recreate the missing startup inputs from the rig or agent spec before trusting replay: ${[
+                    ...missingRequired.map((file) => file.absolutePath),
+                    ...missingOptional.map((file) => file.absolutePath),
+                    ...missingProjectionEntries.map((entry) => entry.absolutePath),
+                ].join(", ")}`,
+                remediationSafe: false,
+            },
+        };
+    }
+    buildStartupContextAvailabilityCheck(check, runningReady, evidence) {
+        return {
+            check,
+            status: runningReady ? "yellow" : "red",
+            evidence,
+            remediation: "Recreate the seat startup context from the rig or agent spec before trusting replay inputs",
+            remediationSafe: false,
+        };
+    }
+    checkQueueFile(rigName, node) {
+        const session = node.canonicalSessionName ?? node.logicalId;
+        const check = `seat.${session}.queue-file`;
+        // Derive queue file path from pod/member
+        const podName = node.podNamespace ?? (node.logicalId.includes(".") ? node.logicalId.split(".")[0] : null);
+        const memberName = node.logicalId.includes(".") ? node.logicalId.split(".").slice(1).join(".") : node.logicalId;
+        if (!podName) {
+            return { check, status: "yellow", evidence: "Cannot derive queue path (no pod namespace)", remediation: "" };
+        }
+        // OPR.0.3.2.14 — subpath scrubbed (internal-team layout → generic placeholder).
+        const substrateRoot = this.deps.substrateRoot ?? join(process.env["HOME"] ?? "~", ".openrig", "shared-docs");
+        const queuePath = join(substrateRoot, "rigs", rigName, "state", podName, `${memberName}.queue.md`);
+        if (this.deps.exists(queuePath)) {
+            return { check, status: "green", evidence: `Queue file exists at ${queuePath}`, remediation: "" };
+        }
+        return {
+            check, status: "yellow",
+            evidence: `Queue file missing: ${queuePath}`,
+            remediation: "Create queue file per attention-queue convention",
+            remediationSafe: false,
+        };
+    }
+    checkHooks(node) {
+        const session = node.canonicalSessionName ?? node.logicalId;
+        if (node.nodeKind !== "agent") {
+            return {
+                check: `seat.${session}.hooks`, status: "green",
+                evidence: "Infrastructure/terminal node; Claude Code hook inspection not applicable",
+                remediation: "",
+            };
+        }
+        if (node.runtime !== "claude-code") {
+            return {
+                check: `seat.${session}.hooks`, status: "green",
+                evidence: `${node.runtime ?? "non-Claude"} seat; Claude Code hook inspection not applicable`,
+                remediation: "",
+            };
+        }
+        const candidates = this.getClaudeSettingsCandidates(node);
+        const searchedPaths = candidates.map((candidate) => candidate.path);
+        const cwdUnavailable = !node.cwd;
+        const inspections = [];
+        const malformed = [];
+        for (const candidate of candidates) {
+            if (!this.deps.exists(candidate.path))
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(this.deps.readFile(candidate.path));
+            }
+            catch (err) {
+                malformed.push(`${candidate.path}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+            inspections.push({
+                path: candidate.path,
+                hasSessionStartCompact: this.hasClaudeCommandHook(parsed, "SessionStart", CLAUDE_SESSION_START_COMPACT_COMMAND, "compact"),
+                hasUserPromptSubmit: this.hasClaudeCommandHook(parsed, "UserPromptSubmit", CLAUDE_USER_PROMPT_SUBMIT_COMMAND),
+            });
+        }
+        if (malformed.length > 0) {
+            return {
+                check: `seat.${session}.hooks`, status: "yellow",
+                evidence: `Malformed applicable Claude settings file(s): ${malformed.join("; ")}. Claude hook configuration could not be trusted until the malformed applicable settings file is fixed. Searched settings paths: ${searchedPaths.join(", ")}`,
+                remediation: `Fix Claude settings JSON before trusting hook readiness: ${malformed.map((entry) => entry.split(":")[0]).join(", ")}`,
+                remediationSafe: false,
+            };
+        }
+        const sessionStartPaths = inspections
+            .filter((inspection) => inspection.hasSessionStartCompact)
+            .map((inspection) => inspection.path);
+        const userPromptSubmitPaths = inspections
+            .filter((inspection) => inspection.hasUserPromptSubmit)
+            .map((inspection) => inspection.path);
+        const hasSessionStart = sessionStartPaths.length > 0;
+        const hasUserPromptSubmit = userPromptSubmitPaths.length > 0;
+        if (hasSessionStart && hasUserPromptSubmit) {
+            return {
+                check: `seat.${session}.hooks`, status: "green",
+                evidence: `Claude Code hook configuration present, not hook-execution verified; SessionStart matcher compact command found in ${sessionStartPaths.join(", ")}; UserPromptSubmit command found in ${userPromptSubmitPaths.join(", ")}. Searched settings paths: ${searchedPaths.join(", ")}`,
+                remediation: "",
+            };
+        }
+        const missing = [];
+        if (!hasSessionStart) {
+            missing.push(`SessionStart matcher compact command ${CLAUDE_SESSION_START_COMPACT_COMMAND}`);
+        }
+        if (!hasUserPromptSubmit) {
+            missing.push(`UserPromptSubmit command ${CLAUDE_USER_PROMPT_SUBMIT_COMMAND}`);
+        }
+        const inspected = inspections.length > 0
+            ? `Existing settings inspected: ${inspections.map((inspection) => inspection.path).join(", ")}.`
+            : "No existing Claude settings files were found.";
+        const cwdEvidence = cwdUnavailable
+            ? " project settings were not inspected because cwd is unavailable."
+            : "";
+        return {
+            check: `seat.${session}.hooks`, status: "yellow",
+            evidence: `Claude Code hook configuration missing required entries: ${missing.join("; ")}. Searched settings paths: ${searchedPaths.join(", ")}. ${inspected}${cwdEvidence}`,
+            remediation: `Merge required Claude hook entries from ${CLAUDE_HOOK_FRAGMENT_PATH} into host-global or project Claude settings`,
+            remediationSafe: false,
+        };
+    }
+    getClaudeSettingsCandidates(node) {
+        const home = process.env["HOME"] ?? "~";
+        const candidates = [{
+                path: join(home, ".claude", "settings.json"),
+                scope: "host-global",
+            }];
+        if (node.cwd) {
+            candidates.push({
+                path: join(node.cwd, ".claude", "settings.json"),
+                scope: "project",
+            });
+            candidates.push({
+                path: join(node.cwd, ".claude", "settings.local.json"),
+                scope: "project-local",
+            });
+        }
+        return candidates;
+    }
+    hasClaudeCommandHook(settings, eventName, requiredCommand, requiredMatcher) {
+        if (!isRecord(settings) || !isRecord(settings["hooks"]))
+            return false;
+        const eventEntries = settings["hooks"][eventName];
+        if (!Array.isArray(eventEntries))
+            return false;
+        return eventEntries.some((entry) => {
+            if (!isRecord(entry))
+                return false;
+            if (requiredMatcher !== undefined && entry["matcher"] !== requiredMatcher)
+                return false;
+            const hooks = entry["hooks"];
+            if (!Array.isArray(hooks))
+                return false;
+            return hooks.some((hook) => isRecord(hook) && hook["command"] === requiredCommand);
+        });
+    }
+    checkSpecPresent(rig) {
+        // OPR.0.3.2.14 — subpath scrubbed (internal-team layout → generic placeholder).
+        const substrateRoot = this.deps.substrateRoot ?? join(process.env["HOME"] ?? "~", ".openrig", "shared-docs");
+        const rigRoot = join(substrateRoot, "rigs", rig.name);
+        const rigYaml = join(rigRoot, "rig.yaml");
+        if (!this.deps.exists(rigRoot)) {
+            return {
+                check: `rig.${rig.name}.spec-present`, status: "red",
+                evidence: `Rig root missing: ${rigRoot}`,
+                remediation: `Create the rig root directory at ${rigRoot} with a rig.yaml spec`,
+                remediationSafe: false,
+            };
+        }
+        if (!this.deps.exists(rigYaml)) {
+            return {
+                check: `rig.${rig.name}.spec-present`, status: "yellow",
+                evidence: `Rig root exists but rig.yaml missing: ${rigYaml}`,
+                remediation: `Add a rig.yaml spec to ${rigRoot}`,
+                remediationSafe: false,
+            };
+        }
+        return { check: `rig.${rig.name}.spec-present`, status: "green", evidence: `Spec present at ${rigYaml}`, remediation: "" };
+    }
+    inspectLatestSnapshot(rigId) {
+        if (!this.deps.getLatestSnapshot) {
+            return { snapshot: null };
+        }
+        try {
+            const snapshot = this.deps.getLatestSnapshot(rigId);
+            if (!snapshot)
+                return { snapshot: null };
+            return { snapshot: { id: snapshot.id, kind: snapshot.kind } };
+        }
+        catch (err) {
+            return {
+                snapshot: null,
+                error: `Latest snapshot lookup failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    buildResult(checks, rigs, hostInfra, recoveryInputs = [], assessmentExtra = []) {
+        // counts + verdict assess the FULL signal (emitted checks + any computed-but-
+        // omitted ready-seat caveats) so default compact never reports a false ready;
+        // repairPacket/recovery still operate on the EMITTED checks (token-safe).
+        const assessed = assessmentExtra.length > 0 ? [...checks, ...assessmentExtra] : checks;
+        const red = assessed.filter((c) => c.status === "red").length;
+        const yellow = assessed.filter((c) => c.status === "yellow").length;
+        const green = assessed.filter((c) => c.status === "green").length;
+        let verdict;
+        if (red > 0) {
+            verdict = "not_restorable";
+        }
+        else if (yellow > 0) {
+            verdict = "restorable_with_caveats";
+        }
+        else {
+            verdict = "restorable";
+        }
+        const repairPacket = this.buildRepairPacket(checks, verdict);
+        const recovery = this.buildRecovery(verdict, checks, recoveryInputs);
+        return this.withAssertion({ verdict, counts: { red, yellow, green }, checks, repairPacket, recovery }, rigs, hostInfra);
+    }
+    /** Probe error produces verdict=unknown (not not_restorable) so operators
+     *  can distinguish "definitely broken" from "checker couldn't inspect." */
+    buildUnknown(checks) {
+        const red = checks.filter((c) => c.status === "red").length;
+        const yellow = checks.filter((c) => c.status === "yellow").length;
+        const green = checks.filter((c) => c.status === "green").length;
+        const repairPacket = this.buildRepairPacket(checks, "unknown");
+        const evidence = checks.find((check) => check.status === "red")?.evidence
+            ?? "Restore-check state could not be inspected";
+        return this.withAssertion({
+            verdict: "unknown",
+            counts: { red, yellow, green },
+            checks,
+            repairPacket,
+            recovery: {
+                status: "unknown",
+                summary: "Recovery status could not be inspected because restore-check state is unknown.",
+                actions: [],
+                blocked: [],
+                unknown: [{ scope: "host", reason: evidence }],
+            },
+        }, []);
+    }
+    withAssertion(result, rigs, hostInfra) {
+        const blockingRigCount = rigs.filter((rig) => rig.blockedNodes > 0 || rig.blockingChecks.length > 0).length;
+        const caveatRigCount = rigs.filter((rig) => rig.blockedNodes === 0 && rig.blockingChecks.length === 0 && (rig.caveatNodes > 0 || rig.caveatChecks.length > 0)).length;
+        const unknownRigCount = rigs.filter((rig) => rig.status === "unknown").length;
+        let readinessStatus;
+        let reason;
+        if (result.verdict === "unknown") {
+            readinessStatus = "unknown";
+            reason = "unknown_probe_state";
+        }
+        else if (result.counts.red > 0) {
+            readinessStatus = "not_ready";
+            reason = "blockers_present";
+        }
+        else if (result.counts.yellow > 0) {
+            readinessStatus = "ready_with_caveats";
+            reason = "caveats_present";
+        }
+        else {
+            readinessStatus = "ready";
+            reason = hostInfra?.status === "declared"
+                ? "all_observable_checks_green_host_infra_declared_not_verified"
+                : "all_observable_checks_green";
+        }
+        // Continuity is always not_proven in v1 — no code path can produce "proven"
+        const continuity = {
+            status: "not_proven",
+            evidence: "Strict same-session/provider-context resume is not verified by restore-check v1. Observable readiness is verified.",
+            provenCapabilities: this.computeProvenCapabilities(result.checks),
+            unprovenCapabilities: [
+                "provider_session_resume",
+                "context_window_preservation",
+                "interrupted_work_functional_resume",
+            ],
+        };
+        return {
+            ...result,
+            readiness: {
+                status: readinessStatus,
+                reason,
+                blockingRigCount,
+                caveatRigCount,
+                unknownRigCount,
+            },
+            continuity,
+            rigs,
+            // FR-8: fleet-wide ready-confidence breakdown = sum of the per-rig class counts.
+            classCounts: rigs.reduce((acc, r) => ({
+                ready: acc.ready + r.classCounts.ready,
+                ready_with_caveats: acc.ready_with_caveats + r.classCounts.ready_with_caveats,
+                not_ready: acc.not_ready + r.classCounts.not_ready,
+                attention_required: acc.attention_required + r.classCounts.attention_required,
+                unknown: acc.unknown + r.classCounts.unknown,
+            }), { ready: 0, ready_with_caveats: 0, not_ready: 0, attention_required: 0, unknown: 0 }),
+            hostInfra: result.verdict === "unknown"
+                ? {
+                    status: "unknown",
+                    evidence: "Host bootstrap/autostart source could not be inspected because restore-check state is unknown",
+                }
+                : (hostInfra ?? {
+                    status: "not_inspected",
+                    evidence: "No host bootstrap/autostart source inspected by v0; readiness only covers observable daemon, rig, and seat checks",
+                }),
+            recovery: result.recovery,
+        };
+    }
+    /** Derive proven capabilities from green checks for the continuity block. */
+    computeProvenCapabilities(checks) {
+        const proven = [];
+        if (checks.some((c) => c.check === "daemon.reachable" && c.status === "green"))
+            proven.push("daemon_reachable");
+        if (checks.some((c) => c.check.endsWith(".transcript") && c.status === "green"))
+            proven.push("transcript_readable");
+        if (checks.some((c) => c.check.endsWith(".spec-present") && c.status === "green"))
+            proven.push("spec_present");
+        if (checks.some((c) => c.check.endsWith(".queue-file") && c.status === "green"))
+            proven.push("queue_file_present");
+        if (checks.some((c) => c.check.endsWith(".resume-path") && c.status === "green"))
+            proven.push("seat_identity_resolvable");
+        return proven;
+    }
+    buildRecovery(verdict, checks, recoveryInputs) {
+        if (verdict === "unknown") {
+            const evidence = checks.find((check) => check.status === "red")?.evidence
+                ?? "Restore-check state could not be inspected";
+            return {
+                status: "unknown",
+                summary: "Recovery status could not be inspected because restore-check state is unknown.",
+                actions: [],
+                blocked: [],
+                unknown: [{ scope: "host", reason: evidence }],
+            };
+        }
+        if (recoveryInputs.length === 0) {
+            const firstRed = checks.find((check) => check.status === "red");
+            if (firstRed) {
+                return {
+                    status: "blocked",
+                    summary: "No exact recovery action is known in v0 because restore-check found blockers outside runnable rig inventory.",
+                    actions: [],
+                    blocked: [{ scope: "host", reason: firstRed.evidence }],
+                    unknown: [],
+                };
+            }
+            return {
+                status: "not_needed",
+                summary: "All observable rigs are already running/ready; no recovery action needed.",
+                actions: [],
+                blocked: [],
+                unknown: [],
+            };
+        }
+        const allReady = recoveryInputs.every((input) => input.runningReadyNodes === input.expectedNodes);
+        if (allReady) {
+            return {
+                status: "not_needed",
+                summary: "All observable rigs are already running/ready; no recovery action needed.",
+                actions: [],
+                blocked: [],
+                unknown: [],
+            };
+        }
+        const actions = [];
+        const blocked = [];
+        const unknown = [];
+        for (const input of recoveryInputs) {
+            if (input.runningReadyNodes === input.expectedNodes)
+                continue;
+            if (input.snapshotLookupError) {
+                unknown.push({
+                    scope: "rig",
+                    rigId: input.rigId,
+                    rigName: input.rigName,
+                    reason: input.snapshotLookupError,
+                });
+                continue;
+            }
+            const restoreInputBlockers = input.blockingChecks.filter((check) => this.classifyRecoveryBlockingCheck(check) === "restore_input");
+            if (restoreInputBlockers.length > 0) {
+                blocked.push({
+                    scope: "rig",
+                    rigId: input.rigId,
+                    rigName: input.rigName,
+                    reason: `No exact recovery action is known in v0 because restore-input blockers remain: ${restoreInputBlockers.map((check) => check.evidence).join("; ")}`,
+                });
+                continue;
+            }
+            if (input.latestSnapshot) {
+                actions.push({
+                    scope: "rig",
+                    rigId: input.rigId,
+                    rigName: input.rigName,
+                    action: "restore_from_latest_snapshot",
+                    command: `rig up --existing ${shellQuote(input.rigName)}`,
+                    reason: "Rig has a latest snapshot and one or more seats are not running/ready.",
+                    safe: false,
+                    blocking: true,
+                });
+                continue;
+            }
+            actions.push({
+                scope: "rig",
+                rigId: input.rigId,
+                rigName: input.rigName,
+                action: "restore_from_latest_snapshot",
+                command: `rig up --existing ${shellQuote(input.rigName)}`,
+                reason: "Rig has persisted current DB state but no latest snapshot; rig up will capture an auto-rehydrate snapshot and restore.",
+                safe: false,
+                blocking: true,
+            });
+        }
+        const status = unknown.length > 0
+            ? "unknown"
+            : actions.length > 0
+                ? "actionable"
+                : blocked.length > 0
+                    ? "blocked"
+                    : "not_needed";
+        return {
+            status,
+            summary: this.buildRecoverySummary(status, actions, blocked, unknown),
+            actions,
+            blocked,
+            unknown,
+        };
+    }
+    classifyRecoveryBlockingCheck(check) {
+        if (check.status !== "red")
+            return "other";
+        if (check.check.startsWith("seat.") && check.check.endsWith(".readiness")) {
+            if (check.evidence.includes("Missing canonical session identity")) {
+                return "restore_input";
+            }
+            return "runtime";
+        }
+        if (check.check.startsWith("seat.") && check.check.endsWith(".startup-context")) {
+            return "restore_input";
+        }
+        return "other";
+    }
+    buildRecoverySummary(status, actions, blocked, unknown) {
+        if (status === "not_needed") {
+            return "All observable rigs are already running/ready; no recovery action needed.";
+        }
+        if (status === "unknown") {
+            return `Recovery status could not be inspected completely; ${actions.length} actionable, ${blocked.length} blocked, ${unknown.length} unknown.`;
+        }
+        if (status === "actionable") {
+            return `${actions.length} ${pluralize(actions.length, "rig")} can be recovered by known OpenRig command; ${blocked.length} ${pluralize(blocked.length, "rig")} blocked; ${unknown.length} unknown.`;
+        }
+        return `${blocked.length} ${pluralize(blocked.length, "rig")} blocked; ${actions.length} actionable; ${unknown.length} unknown.`;
+    }
+    buildRigRollup(input) {
+        const blockingChecks = input.checks.filter((check) => check.status === "red");
+        const caveatChecks = input.checks.filter((check) => check.status === "yellow");
+        const expectedNodes = input.nodes.length;
+        let runningReadyNodes = 0;
+        let blockedNodes = 0;
+        let caveatNodes = 0;
+        // FR-8: per-seat class breakdown (each seat counts toward exactly one class).
+        const classCounts = { ready: 0, ready_with_caveats: 0, not_ready: 0, attention_required: 0, unknown: 0 };
+        // unknown/no-snapshot derives from the REAL snapshot primitive: the
+        // rig-level `rig.<name>.snapshot` yellow check (no snapshot found / could
+        // not check). A rig with no snapshot cannot be restored, so its seats'
+        // restore-readiness is unknown (not "ready"), per FR-8/AC-7.
+        const rigNoSnapshot = input.checks.some((check) => check.check === `rig.${input.rig.name}.snapshot` && check.status === "yellow");
+        for (const node of input.nodes) {
+            const session = node.canonicalSessionName ?? node.logicalId;
+            const nodeChecks = input.checks.filter((check) => check.check.startsWith(`seat.${session}.`));
+            const hasBlocking = nodeChecks.some((check) => check.status === "red");
+            const hasCaveat = nodeChecks.some((check) => check.status === "yellow");
+            const runningReady = Boolean(node.canonicalSessionName) && node.sessionStatus === "running" && node.startupStatus === "ready";
+            if (runningReady)
+                runningReadyNodes += 1;
+            if (hasBlocking)
+                blockedNodes += 1;
+            else if (hasCaveat)
+                caveatNodes += 1;
+            // FR-8 class derivation (precedence; each from a real primitive).
+            // attention/not_ready WIN FIRST (a failed/attention seat is surfaced even
+            // in a no-snapshot rig); no-snapshot then overrides ONLY ready/caveat (a
+            // clean seat in an unrestorable rig is unknown); a real yellow caveat then
+            // wins over plain ready so the class count matches the per-rig status +
+            // caveatNodes (a running/ready seat with a yellow check is NOT plain ready):
+            //   attention_required ← node.startupStatus
+            //   not_ready          ← a red seat check (failed/down)
+            //   unknown            ← no-snapshot (rig can't restore)
+            //   ready_with_caveats ← a yellow seat check
+            //   ready              ← running/ready, no caveat
+            //   unknown            ← indeterminate remainder
+            if (node.startupStatus === "attention_required")
+                classCounts.attention_required += 1;
+            else if (hasBlocking)
+                classCounts.not_ready += 1;
+            else if (rigNoSnapshot)
+                classCounts.unknown += 1;
+            else if (hasCaveat)
+                classCounts.ready_with_caveats += 1;
+            else if (runningReady)
+                classCounts.ready += 1;
+            else
+                classCounts.unknown += 1;
+        }
+        let verdict;
+        let status;
+        if (blockingChecks.length > 0) {
+            verdict = "not_restorable";
+            status = "not_ready";
+        }
+        else if (caveatChecks.length > 0) {
+            verdict = "restorable_with_caveats";
+            status = "ready_with_caveats";
+        }
+        else {
+            verdict = "restorable";
+            status = "ready";
+        }
+        return {
+            rigId: input.rig.rigId,
+            rigName: input.rig.name,
+            status,
+            verdict,
+            expectedNodes,
+            runningReadyNodes,
+            blockedNodes,
+            caveatNodes,
+            classCounts,
+            blockingChecks,
+            caveatChecks,
+        };
+    }
+    /** Generate ordered repair steps from non-green checks with remediation.
+     *  null when all green (restorable — nothing to repair).
+     *  Blockers (red) first in check order, then caveats (yellow). */
+    buildRepairPacket(checks, verdict) {
+        if (verdict === "restorable")
+            return null;
+        // Blockers first, then caveats, preserving original check order within each group
+        const blockers = checks.filter((c) => c.status === "red" && c.remediation);
+        const caveats = checks.filter((c) => c.status === "yellow" && c.remediation);
+        const ordered = [...blockers, ...caveats];
+        if (ordered.length === 0)
+            return null;
+        let step = 0;
+        return ordered.map((c) => ({
+            step: ++step,
+            command: c.remediation,
+            rationale: c.evidence,
+            safe: c.remediationSafe === true, // conservative: default false unless explicitly marked safe
+            blocking: c.status === "red",
+        }));
+    }
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9._@:-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pluralize(count, noun) {
+    return count === 1 ? noun : `${noun}s`;
+}
+//# sourceMappingURL=restore-check-service.js.map