@ouro.bot/cli 0.1.0-alpha.661 → 0.1.0-alpha.663

package/dist/heart/context-loss-sentinel.js

@@ -0,0 +1,752 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextLossSentinelPaths = contextLossSentinelPaths;
+exports.deriveContextLossSentinelProviderSignals = deriveContextLossSentinelProviderSignals;
+exports.refreshContextLossSentinel = refreshContextLossSentinel;
+exports.readContextLossSentinelView = readContextLossSentinelView;
+exports.formatContextLossSentinelText = formatContextLossSentinelText;
+exports.formatContextLossSentinelJson = formatContextLossSentinelJson;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const flight_recorder_1 = require("../arc/flight-recorder");
+const runtime_1 = require("../nerves/runtime");
+const context_loss_gauntlet_1 = require("./context-loss-gauntlet");
+const provider_visibility_1 = require("./provider-visibility");
+const REQUIRED_LANES = ["outward", "inner"];
+function logicalLocator(...parts) {
+    return path.posix.join(...parts);
+}
+function relativeSentinelRoot() {
+    return logicalLocator("arc", "flight-recorder", "context-loss-sentinel");
+}
+function latestLocator() {
+    return logicalLocator(relativeSentinelRoot(), "latest.json");
+}
+function latestReadyLocator() {
+    return logicalLocator(relativeSentinelRoot(), "latest-ready.json");
+}
+function receiptLocator(receiptId) {
+    return logicalLocator(relativeSentinelRoot(), "receipts", `${receiptId}.json`);
+}
+function historyDay(generatedAt) {
+    return generatedAt.slice(0, 10);
+}
+function historyLocator(generatedAt) {
+    return logicalLocator(relativeSentinelRoot(), "history", `${historyDay(generatedAt)}.jsonl`);
+}
+function contextLossSentinelPaths(agentRoot) {
+    const rootDir = path.join(agentRoot, relativeSentinelRoot());
+    return {
+        rootDir,
+        latest: path.join(rootDir, "latest.json"),
+        latestReady: path.join(rootDir, "latest-ready.json"),
+        historyDir: path.join(rootDir, "history"),
+        receiptsDir: path.join(rootDir, "receipts"),
+        lock: path.join(rootDir, ".write.lock"),
+    };
+}
+function atomicWriteJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${(0, crypto_1.randomUUID)()}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmpPath, filePath);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withFileLock(lockPath, timeoutMs, fn) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            const fd = fs.openSync(lockPath, "wx");
+            try {
+                fs.writeFileSync(fd, `${process.pid}\n`, "utf-8");
+                return await fn();
+            }
+            finally {
+                fs.closeSync(fd);
+                fs.rmSync(lockPath, { force: true });
+            }
+        }
+        catch (error) {
+            const code = String(error.code);
+            if (code !== "EEXIST") {
+                throw error;
+            }
+            if (Date.now() - startedAt > timeoutMs) {
+                throw new Error(`context-loss Sentinel lock timed out: ${lockPath}`);
+            }
+            await sleep(5);
+        }
+    }
+}
+function compareReceiptOrder(left, right) {
+    const leftTime = Date.parse(left.generatedAt);
+    const rightTime = Date.parse(right.generatedAt);
+    if (leftTime !== rightTime)
+        return leftTime - rightTime;
+    return left.id.localeCompare(right.id);
+}
+function shouldReplaceReceipt(existing, candidate) {
+    return existing === null || compareReceiptOrder(candidate, existing) >= 0;
+}
+function readJson(filePath) {
+    try {
+        return { ok: true, value: JSON.parse(fs.readFileSync(filePath, "utf-8")) };
+    }
+    catch (error) {
+        return { ok: false, reason: String(error) };
+    }
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isValidTimestamp(value) {
+    return Number.isFinite(Date.parse(value));
+}
+function isSource(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.kind === "string" && typeof record.locator === "string";
+}
+function isRepair(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return (record.actor === "agent-runnable" || record.actor === "human-required" || record.actor === "human-choice")
+        && typeof record.kind === "string"
+        && (record.command === undefined || typeof record.command === "string")
+        && typeof record.detail === "string";
+}
+function isSignal(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.id === "string"
+        && (record.kind === "gauntlet" || record.kind === "provider_lane" || record.kind === "sense" || record.kind === "daemon" || record.kind === "bundle")
+        && (record.status === "pass" || record.status === "warn" || record.status === "fail")
+        && (record.severity === "info" || record.severity === "warn" || record.severity === "critical")
+        && (record.verdictImpact === "none" || record.verdictImpact === "watch" || record.verdictImpact === "blocked")
+        && typeof record.summary === "string"
+        && isSource(record.source)
+        && (record.repair === undefined || isRepair(record.repair));
+}
+function isRecoveryAnchor(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return (record.kind === "flight-recorder" || record.kind === "latest-ready")
+        && (record.currentAsk === null || typeof record.currentAsk === "string")
+        && (record.nextSafeAction === null || typeof record.nextSafeAction === "string")
+        && typeof record.flightRecorderLatestLocator === "string"
+        && isStringArray(record.sourceEventIds)
+        && (record.recordedAt === null || typeof record.recordedAt === "string");
+}
+function isGauntletSummary(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return (record.verdict === "ready" || record.verdict === "watch" || record.verdict === "blocked")
+        && typeof record.scorePercentage === "number"
+        && isStringArray(record.failedChecks)
+        && isStringArray(record.warnedChecks)
+        && typeof record.sourceLocator === "string";
+}
+function isResumeSnapshot(value) {
+    return (0, flight_recorder_1.isFlightRecorderResume)(value);
+}
+function isReceipt(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return record.schemaVersion === 1
+        && typeof record.id === "string"
+        && typeof record.agent === "string"
+        && (record.trigger === "post_turn" || record.trigger === "provider_failover" || record.trigger === "daemon_startup" || record.trigger === "daemon_health" || record.trigger === "session_start" || record.trigger === "manual_cli")
+        && typeof record.generatedAt === "string"
+        && isValidTimestamp(record.generatedAt)
+        && (record.verdict === "ready" || record.verdict === "watch" || record.verdict === "blocked")
+        && typeof record.summary === "string"
+        && typeof record.receiptLocator === "string"
+        && (record.latestReadyLocator === null || typeof record.latestReadyLocator === "string")
+        && isRecoveryAnchor(record.recoveryAnchor)
+        && isGauntletSummary(record.gauntlet)
+        && Array.isArray(record.signals)
+        && record.signals.every(isSignal)
+        && isStringArray(record.sourceLocators)
+        && isResumeSnapshot(record.resumeSnapshot);
+}
+function readReceiptFile(filePath, label, issues) {
+    if (!fs.existsSync(filePath))
+        return null;
+    const parsed = readJson(filePath);
+    if (!parsed.ok) {
+        issues.push(`${label} unreadable: ${parsed.reason}`);
+        return null;
+    }
+    if (!isReceipt(parsed.value)) {
+        issues.push(`${label} malformed`);
+        return null;
+    }
+    return parsed.value;
+}
+function isNonEmptyText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hasSafeResumeSnapshot(receipt) {
+    const resume = receipt.resumeSnapshot;
+    return resume.canContinue
+        && resume.hasCompleteState
+        && resume.recorderHealth.status === "ok"
+        && resume.blockedBecause.length === 0
+        && isNonEmptyText(resume.currentAsk.value)
+        && isNonEmptyText(resume.nextSafeAction.value);
+}
+function readLatestReadyFile(filePath, label, issues) {
+    const receipt = readReceiptFile(filePath, label, issues);
+    if (receipt && receipt.verdict !== "ready") {
+        issues.push(`${label} is not a ready receipt`);
+        return null;
+    }
+    if (receipt && (receipt.gauntlet.verdict !== "ready"
+        || receipt.signals.some((signal) => signal.verdictImpact !== "none")
+        || !hasSafeResumeSnapshot(receipt))) {
+        issues.push(`${label} is not a semantically ready receipt`);
+        return null;
+    }
+    return receipt;
+}
+function readLatestReady(agentRoot) {
+    const receipt = readLatestReadyFile(contextLossSentinelPaths(agentRoot).latestReady, "latest-ready.json", []);
+    return receipt?.verdict === "ready" ? receipt : null;
+}
+function signalStatusForImpact(impact) {
+    if (impact === "blocked")
+        return { status: "fail", severity: "critical" };
+    if (impact === "watch")
+        return { status: "warn", severity: "warn" };
+    return { status: "pass", severity: "info" };
+}
+function providerCheckCommand(agentName, lane) {
+    return `ouro provider check --agent ${agentName} --lane ${lane}`;
+}
+function sourceForLane(lane) {
+    return {
+        kind: "provider-visibility",
+        locator: `agent.json#providers.${lane}`,
+    };
+}
+function repair(actor, kind, detail, command) {
+    return {
+        actor,
+        kind,
+        detail,
+        command,
+    };
+}
+function providerSignal(visibility, lane, impact, summary, repairValue, meta = {}) {
+    return {
+        id: `provider:${lane}`,
+        kind: "provider_lane",
+        ...signalStatusForImpact(impact),
+        verdictImpact: impact,
+        summary,
+        source: sourceForLane(lane),
+        ...(repairValue ? { repair: repairValue } : {}),
+        meta: {
+            agentName: visibility.agentName,
+            lane,
+            ...meta,
+        },
+    };
+}
+function configuredProviderSignal(visibility, lane) {
+    if (lane.credential.status === "missing") {
+        return providerSignal(visibility, lane.lane, "blocked", `${lane.lane} credentials missing for ${lane.provider}`, repair("human-required", "provider-credential", `${lane.provider} credentials must be added to the agent vault.`, lane.credential.repairCommand), { provider: lane.provider, model: lane.model, credentialStatus: lane.credential.status });
+    }
+    if (lane.credential.status === "invalid-pool") {
+        return providerSignal(visibility, lane.lane, "blocked", `${lane.lane} credential vault unavailable for ${lane.provider}`, repair("human-required", "vault-unavailable", "The agent credential vault must be unlocked or repaired.", lane.credential.repairCommand), { provider: lane.provider, model: lane.model, credentialStatus: lane.credential.status });
+    }
+    if (lane.credential.status === "not-loaded") {
+        return providerSignal(visibility, lane.lane, "watch", `${lane.lane} credentials not loaded for ${lane.provider}`, repair("agent-runnable", "provider-credential-cache", "Refresh the in-process provider credential cache.", lane.credential.repairCommand ?? `ouro provider refresh --agent ${visibility.agentName}`), { provider: lane.provider, model: lane.model, credentialStatus: lane.credential.status });
+    }
+    if (lane.readiness.status === "failed") {
+        return providerSignal(visibility, lane.lane, "blocked", `${lane.lane} live check failed for ${lane.provider}${lane.readiness.error ? `: ${lane.readiness.error}` : ""}`, repair("agent-runnable", "provider-live-check", "Run a fresh provider capability check and inspect the failure.", providerCheckCommand(visibility.agentName, lane.lane)), { provider: lane.provider, model: lane.model, readinessStatus: lane.readiness.status, checkedAt: lane.readiness.checkedAt ?? null, attempts: lane.readiness.attempts ?? null });
+    }
+    if (lane.readiness.status === "stale" && (lane.readiness.checkedAt || lane.readiness.reason || lane.readiness.error)) {
+        return providerSignal(visibility, lane.lane, "watch", `${lane.lane} readiness stale for ${lane.provider}${lane.readiness.reason ? `: ${lane.readiness.reason}` : ""}`, repair("agent-runnable", "provider-live-check", "Run a fresh provider capability check before relying on this lane.", providerCheckCommand(visibility.agentName, lane.lane)), { provider: lane.provider, model: lane.model, readinessStatus: lane.readiness.status, checkedAt: lane.readiness.checkedAt ?? null });
+    }
+    if (lane.readiness.status === "unknown" || lane.readiness.status === "stale") {
+        return providerSignal(visibility, lane.lane, "watch", `${lane.lane} readiness unknown for ${lane.provider}${lane.readiness.reason ? `: ${lane.readiness.reason}` : ""}`, repair("agent-runnable", "provider-live-check", "Run a provider capability check; Sentinel will not invent stale readiness without evidence.", providerCheckCommand(visibility.agentName, lane.lane)), { provider: lane.provider, model: lane.model, readinessStatus: "unknown" });
+    }
+    return providerSignal(visibility, lane.lane, "none", `${lane.lane} provider ready: ${lane.provider} / ${lane.model}`, undefined, { provider: lane.provider, model: lane.model, readinessStatus: lane.readiness.status, checkedAt: lane.readiness.checkedAt ?? null });
+}
+function missingProviderLaneSignal(visibility, lane) {
+    return providerSignal(visibility, lane, "blocked", `${lane} provider visibility missing from deterministic provider report`, repair("agent-runnable", "provider-visibility", "Refresh Sentinel from a complete provider visibility source.", `ouro work sentinel refresh --agent ${visibility.agentName}`), { laneStatus: "missing-from-report" });
+}
+function deriveContextLossSentinelProviderSignals(visibility) {
+    return REQUIRED_LANES.map((laneName) => {
+        const lane = visibility.lanes.find((entry) => entry.lane === laneName);
+        if (!lane) {
+            return missingProviderLaneSignal(visibility, laneName);
+        }
+        if (lane.status === "unconfigured") {
+            return providerSignal(visibility, lane.lane, "blocked", `${lane.lane} provider unconfigured: ${lane.reason}`, repair("human-choice", "provider-selection", "Choose a provider and model for this lane.", lane.repairCommand), { laneStatus: lane.status, reason: lane.reason });
+        }
+        return configuredProviderSignal(visibility, lane);
+    });
+}
+function gauntletSignal(report) {
+    const impact = report.verdict === "blocked"
+        ? "blocked"
+        : report.verdict === "watch"
+            ? "watch"
+            : "none";
+    return {
+        id: "gauntlet:context-loss",
+        kind: "gauntlet",
+        ...signalStatusForImpact(impact),
+        verdictImpact: impact,
+        summary: report.summary,
+        source: {
+            kind: "context-loss-gauntlet",
+            locator: "arc/flight-recorder/latest.json",
+        },
+        meta: {
+            scorePercentage: report.score.percentage,
+            failedChecks: report.checks.filter((check) => check.status === "fail").map((check) => check.id),
+            warnedChecks: report.checks.filter((check) => check.status === "warn").map((check) => check.id),
+        },
+    };
+}
+function healthSignalKind(result) {
+    return result.name.startsWith("sense-probe:") ? "sense" : "daemon";
+}
+function healthSignals(results) {
+    return results
+        .filter((result) => result.name.startsWith("sense-probe:") || result.status !== "ok")
+        .map((result) => {
+        const impact = result.status === "critical"
+            ? "blocked"
+            : result.status === "warn"
+                ? "watch"
+                : "none";
+        const kind = healthSignalKind(result);
+        return {
+            id: `${kind}:${result.name}`,
+            kind,
+            ...signalStatusForImpact(impact),
+            verdictImpact: impact,
+            summary: result.message,
+            source: {
+                kind: "daemon-health",
+                locator: `daemon.health:${result.name}`,
+            },
+            meta: { healthStatus: result.status },
+        };
+    });
+}
+function defaultGitStatus(agentRoot) {
+    try {
+        const porcelain = (0, child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+            cwd: agentRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 1_000,
+        });
+        return { ok: true, porcelain };
+    }
+    catch (error) {
+        return { ok: false, error: String(error) };
+    }
+}
+function bundleSignal(status) {
+    if (!status.ok) {
+        return {
+            id: "bundle:git",
+            kind: "bundle",
+            status: "warn",
+            severity: "warn",
+            verdictImpact: "watch",
+            summary: `bundle git status unavailable: ${status.error}`,
+            source: { kind: "git", locator: "git status --porcelain" },
+            repair: repair("agent-runnable", "bundle-cleanup", "Inspect bundle git state before assuming the local state is clean.", "git status --porcelain"),
+        };
+    }
+    const dirtyEntries = status.porcelain.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (dirtyEntries.length > 0) {
+        return {
+            id: "bundle:git",
+            kind: "bundle",
+            status: "warn",
+            severity: "warn",
+            verdictImpact: "watch",
+            summary: `bundle has ${dirtyEntries.length} uncommitted git status entr${dirtyEntries.length === 1 ? "y" : "ies"}`,
+            source: { kind: "git", locator: "git status --porcelain" },
+            repair: repair("agent-runnable", "bundle-cleanup", "Resolve or intentionally preserve local bundle changes before handoff.", "git status --porcelain"),
+            meta: { dirtyEntries },
+        };
+    }
+    return {
+        id: "bundle:git",
+        kind: "bundle",
+        status: "pass",
+        severity: "info",
+        verdictImpact: "none",
+        summary: "bundle git status clean",
+        source: { kind: "git", locator: "git status --porcelain" },
+    };
+}
+function sentinelVerdict(signals) {
+    if (signals.some((entry) => entry.verdictImpact === "blocked"))
+        return "blocked";
+    if (signals.some((entry) => entry.verdictImpact === "watch"))
+        return "watch";
+    return "ready";
+}
+function summaryForVerdict(verdict) {
+    if (verdict === "ready")
+        return "ready: deterministic recovery state is current and last-known-good is safe";
+    if (verdict === "watch")
+        return "watch: deterministic recovery can continue, but one or more signals need attention";
+    return "blocked: deterministic recovery failed and must use latest-ready or repair before continuing";
+}
+function gauntletSummary(report) {
+    return {
+        verdict: report.verdict,
+        scorePercentage: report.score.percentage,
+        failedChecks: report.checks.filter((check) => check.status === "fail").map((check) => check.id),
+        warnedChecks: report.checks.filter((check) => check.status === "warn").map((check) => check.id),
+        sourceLocator: "arc/flight-recorder/latest.json",
+    };
+}
+function anchorFromResume(kind, resume) {
+    return {
+        kind,
+        currentAsk: resume.currentAsk.value,
+        nextSafeAction: resume.nextSafeAction.value,
+        flightRecorderLatestLocator: "arc/flight-recorder/latest.json",
+        sourceEventIds: [...resume.currentAsk.sourceEventIds, ...resume.nextSafeAction.sourceEventIds],
+        recordedAt: resume.lastSafeCheckpoint.recordedAt,
+    };
+}
+function readFlightRecorderEventsByIds(agentRoot, eventIds) {
+    if (eventIds.length === 0)
+        return [];
+    const wanted = new Set(eventIds);
+    const eventsRoot = path.join(agentRoot, "arc", "flight-recorder", "events");
+    if (!fs.existsSync(eventsRoot))
+        return [];
+    return fs.readdirSync(eventsRoot)
+        .filter((entry) => entry.endsWith(".jsonl"))
+        .flatMap((entry) => fs.readFileSync(path.join(eventsRoot, entry), "utf-8").split(/\r?\n/))
+        .filter((line) => line.trim().length > 0)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return wanted.has(parsed.id) ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function isSentinelAuthoredBlockerEvent(event) {
+    return event.kind === "blocker_detected"
+        && (event.meta?.source === "context-loss-sentinel"
+            || Boolean(event.producedRefs?.some((ref) => ref.kind === "arc" && ref.locator.startsWith(relativeSentinelRoot()))));
+}
+function hasSentinelAuthoredBlocker(agentRoot, resume) {
+    if (resume.blockedBecause.length === 0)
+        return false;
+    return readFlightRecorderEventsByIds(agentRoot, resume.lastSafeCheckpoint.sourceEventIds)
+        .some(isSentinelAuthoredBlockerEvent);
+}
+function selectGauntletResume(agentRoot) {
+    const resume = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    const latestReady = readLatestReady(agentRoot);
+    if (hasSentinelAuthoredBlocker(agentRoot, resume) && latestReady) {
+        return { resume: latestReady.resumeSnapshot, anchorKind: "latest-ready" };
+    }
+    return { resume, anchorKind: "flight-recorder" };
+}
+function resolveProviderVisibility(agentName, agentRoot, options) {
+    return options.providerVisibility ?? (0, provider_visibility_1.buildAgentProviderVisibility)({
+        agentName,
+        agentRoot,
+        homeDir: options.homeDir,
+    });
+}
+function shouldUseLatestReadyRecovery(anchorKind, verdict, signals) {
+    if (anchorKind === "latest-ready")
+        return true;
+    if (verdict === "ready")
+        return false;
+    const hasNonGauntletRisk = signals.some((signal) => signal.kind !== "gauntlet" && signal.verdictImpact !== "none");
+    const hasGauntletBlocker = signals.some((signal) => signal.kind === "gauntlet" && signal.verdictImpact === "blocked");
+    return hasNonGauntletRisk && !hasGauntletBlocker;
+}
+function makeReceipt(agentName, agentRoot, options, generatedAt) {
+    const receiptId = options.createReceiptId?.() ?? `sentinel-${(0, crypto_1.randomUUID)()}`;
+    const selectedResume = selectGauntletResume(agentRoot);
+    const report = (0, context_loss_gauntlet_1.runContextLossGauntlet)(agentName, agentRoot, {
+        now: options.now,
+        homeDir: options.homeDir,
+        flightRecorderResume: selectedResume.resume,
+    });
+    const providerVisibility = resolveProviderVisibility(agentName, agentRoot, options);
+    const signals = [
+        gauntletSignal(report),
+        ...deriveContextLossSentinelProviderSignals(providerVisibility),
+        ...healthSignals(options.daemonHealthResults ?? []),
+        bundleSignal((options.gitStatus ?? (() => defaultGitStatus(agentRoot)))()),
+    ];
+    const verdict = sentinelVerdict(signals);
+    const latestReady = readLatestReady(agentRoot);
+    const recoverySource = latestReady && shouldUseLatestReadyRecovery(selectedResume.anchorKind, verdict, signals)
+        ? { resume: latestReady.resumeSnapshot, anchorKind: "latest-ready" }
+        : selectedResume;
+    const readyLocator = verdict === "ready" || latestReady ? latestReadyLocator() : null;
+    return {
+        schemaVersion: 1,
+        id: receiptId,
+        agent: agentName,
+        trigger: options.trigger,
+        generatedAt,
+        verdict,
+        summary: summaryForVerdict(verdict),
+        receiptLocator: receiptLocator(receiptId),
+        latestReadyLocator: readyLocator,
+        recoveryAnchor: anchorFromResume(recoverySource.anchorKind, recoverySource.resume),
+        gauntlet: gauntletSummary(report),
+        signals,
+        sourceLocators: [
+            "arc/flight-recorder/latest.json",
+            latestLocator(),
+            historyLocator(generatedAt),
+            receiptLocator(receiptId),
+            ...(readyLocator ? [readyLocator] : []),
+        ],
+        resumeSnapshot: recoverySource.resume,
+    };
+}
+function ensureSentinelDirs(paths) {
+    fs.mkdirSync(paths.rootDir, { recursive: true });
+    fs.mkdirSync(paths.historyDir, { recursive: true });
+    fs.mkdirSync(paths.receiptsDir, { recursive: true });
+}
+function appendHistory(paths, receipt) {
+    fs.mkdirSync(paths.historyDir, { recursive: true });
+    fs.appendFileSync(path.join(paths.historyDir, `${historyDay(receipt.generatedAt)}.jsonl`), `${JSON.stringify(receipt)}\n`, "utf-8");
+}
+function syncLatestReadyLocator(receipt, hasLatestReady) {
+    receipt.latestReadyLocator = hasLatestReady ? latestReadyLocator() : null;
+    const locator = latestReadyLocator();
+    receipt.sourceLocators = hasLatestReady
+        ? Array.from(new Set([...receipt.sourceLocators, locator]))
+        : receipt.sourceLocators.filter((entry) => entry !== locator);
+    return receipt;
+}
+function syncLatestReadyState(receipt, latestReady) {
+    syncLatestReadyLocator(receipt, latestReady !== null);
+    if (latestReady && shouldUseLatestReadyRecovery(receipt.recoveryAnchor.kind, receipt.verdict, receipt.signals)) {
+        receipt.recoveryAnchor = anchorFromResume("latest-ready", latestReady.resumeSnapshot);
+        receipt.resumeSnapshot = latestReady.resumeSnapshot;
+    }
+    return receipt;
+}
+function blockedSignalSummaries(receipt) {
+    return receipt.signals
+        .filter((signal) => signal.verdictImpact === "blocked")
+        .map((signal) => `${signal.id}: ${signal.summary}`);
+}
+function recordBlockedReceiptEvent(agentRoot, receipt) {
+    if (receipt.verdict !== "blocked")
+        return;
+    (0, flight_recorder_1.recordFlightRecorderEvent)(agentRoot, {
+        id: `fr-${receipt.id}`,
+        kind: "blocker_detected",
+        recordedAt: receipt.generatedAt,
+        summary: "context-loss Sentinel blocked recovery",
+        blockedBecause: blockedSignalSummaries(receipt).map((summary) => `context-loss Sentinel blocked: ${summary}`),
+        producedRefs: [{
+                kind: "arc",
+                locator: receipt.receiptLocator,
+            }],
+        meta: {
+            source: "context-loss-sentinel",
+            receiptId: receipt.id,
+            trigger: receipt.trigger,
+        },
+    });
+}
+async function persistReceipt(agentRoot, receipt, lockTimeoutMs) {
+    const paths = contextLossSentinelPaths(agentRoot);
+    await withFileLock(paths.lock, lockTimeoutMs, async () => {
+        ensureSentinelDirs(paths);
+        const existingLatest = readReceiptFile(paths.latest, "latest.json", []);
+        const existingReady = readLatestReady(agentRoot);
+        const nextReady = receipt.verdict === "ready" && shouldReplaceReceipt(existingReady, receipt)
+            ? receipt
+            : existingReady;
+        syncLatestReadyState(receipt, nextReady);
+        atomicWriteJson(path.join(paths.receiptsDir, `${receipt.id}.json`), receipt);
+        appendHistory(paths, receipt);
+        if (shouldReplaceReceipt(existingLatest, receipt)) {
+            atomicWriteJson(paths.latest, receipt);
+            recordBlockedReceiptEvent(agentRoot, receipt);
+        }
+        else if (existingLatest && receipt.verdict === "ready") {
+            atomicWriteJson(paths.latest, syncLatestReadyState(existingLatest, nextReady));
+        }
+        if (receipt.verdict === "ready" && nextReady === receipt) {
+            atomicWriteJson(paths.latestReady, receipt);
+        }
+    });
+}
+async function refreshContextLossSentinel(agentName, agentRoot, options) {
+    const generatedAt = (options.now ?? (() => new Date()))().toISOString();
+    const receipt = makeReceipt(agentName, agentRoot, options, generatedAt);
+    if (options.delayBeforeWriteMs && options.delayBeforeWriteMs > 0) {
+        await sleep(options.delayBeforeWriteMs);
+    }
+    await persistReceipt(agentRoot, receipt, options.lockTimeoutMs ?? 5_000);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.context_loss_sentinel_refreshed",
+        message: "context-loss Sentinel refreshed deterministic recovery state",
+        meta: {
+            agentName,
+            trigger: options.trigger,
+            verdict: receipt.verdict,
+            receiptId: receipt.id,
+            blockedSignals: receipt.signals.filter((entry) => entry.verdictImpact === "blocked").map((entry) => entry.id),
+            watchSignals: receipt.signals.filter((entry) => entry.verdictImpact === "watch").map((entry) => entry.id),
+        },
+    });
+    return receipt;
+}
+function readHistory(paths, limit, issues) {
+    if (!fs.existsSync(paths.historyDir))
+        return [];
+    const files = fs.readdirSync(paths.historyDir)
+        .filter((entry) => entry.endsWith(".jsonl"))
+        .sort();
+    const receipts = [];
+    for (const fileName of files) {
+        const filePath = path.join(paths.historyDir, fileName);
+        const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/);
+        lines.forEach((line, index) => {
+            if (line.trim().length === 0)
+                return;
+            try {
+                const parsed = JSON.parse(line);
+                if (isReceipt(parsed)) {
+                    receipts.push(parsed);
+                }
+                else {
+                    issues.push(`history/${fileName} line ${index + 1} malformed`);
+                }
+            }
+            catch (error) {
+                issues.push(`history/${fileName} line ${index + 1} unreadable: ${String(error)}`);
+            }
+        });
+    }
+    return receipts.slice(Math.max(0, receipts.length - limit));
+}
+function readContextLossSentinelView(agentRoot, options = {}) {
+    const paths = contextLossSentinelPaths(agentRoot);
+    const issues = [];
+    const limit = Math.max(0, options.limit ?? 20);
+    return {
+        schemaVersion: 1,
+        latest: readReceiptFile(paths.latest, "latest.json", issues),
+        latestReady: readLatestReadyFile(paths.latestReady, "latest-ready.json", issues),
+        history: readHistory(paths, limit, issues),
+        degraded: { issues },
+    };
+}
+function renderSignal(signalEntry) {
+    const repairText = signalEntry.repair?.command ? ` repair: ${signalEntry.repair.command}` : "";
+    return `  - ${signalEntry.status.toUpperCase()} ${signalEntry.id}: ${signalEntry.summary}${repairText}`;
+}
+function formatReceipt(receipt) {
+    return [
+        `Recovery Sentinel - ${receipt.agent}`,
+        `generated: ${receipt.generatedAt}`,
+        `receipt: ${receipt.receiptLocator}`,
+        `trigger: ${receipt.trigger}`,
+        `verdict: ${receipt.verdict}`,
+        `latest-ready: ${receipt.latestReadyLocator ?? "unavailable"}`,
+        `summary: ${receipt.summary}`,
+        "",
+        "Recovery anchor",
+        `  kind: ${receipt.recoveryAnchor.kind}`,
+        `  current ask: ${receipt.recoveryAnchor.currentAsk ?? "unavailable"}`,
+        `  next action: ${receipt.recoveryAnchor.nextSafeAction ?? "unavailable"}`,
+        "",
+        "Signals",
+        ...receipt.signals.map(renderSignal),
+    ];
+}
+function formatContextLossSentinelText(input) {
+    if (input === null)
+        return "Recovery Sentinel - unavailable";
+    if ("latest" in input) {
+        const displayReceipt = input.latest ?? input.latestReady;
+        if (!displayReceipt) {
+            return [
+                "Recovery Sentinel - unavailable",
+                ...input.degraded.issues.map((issue) => `degraded: ${issue}`),
+            ].join("\n").trim();
+        }
+        return [
+            ...formatReceipt(displayReceipt),
+            "",
+            `history: ${input.history.length} receipt${input.history.length === 1 ? "" : "s"}`,
+            ...(input.degraded.issues.length > 0 ? ["", ...input.degraded.issues.map((issue) => `degraded: ${issue}`)] : []),
+        ].join("\n").trim();
+    }
+    return formatReceipt(input).join("\n").trim();
+}
+function formatContextLossSentinelJson(input) {
+    return `${JSON.stringify(input, null, 2)}\n`;
+}