@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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

@@ -0,0 +1,1157 @@
+"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 CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT = 512;
+const CONTEXT_LOSS_SENTINEL_GIT_STATUS_TIMEOUT_MS = 5_000;
+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 orderFromReceipt(receipt) {
+    return { generatedAt: receipt.generatedAt, id: receipt.id };
+}
+function compareOrder(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 maxOrder(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return compareOrder(left, right) >= 0 ? left : right;
+}
+function isOrder(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.generatedAt === "string"
+        && isValidTimestamp(record.generatedAt)
+        && typeof record.id === "string";
+}
+function sentinelWatermarkPath(agentRoot) {
+    return path.join(agentRoot, "state", "arc", "context-loss-sentinel-watermark.json");
+}
+function readWatermark(agentRoot) {
+    const filePath = sentinelWatermarkPath(agentRoot);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return {
+            schemaVersion: 1,
+            latest: isOrder(parsed.latest) ? parsed.latest : null,
+            latestReady: isOrder(parsed.latestReady) ? parsed.latestReady : null,
+        };
+    }
+    catch {
+        return { schemaVersion: 1, latest: null, latestReady: null };
+    }
+}
+function writeWatermark(agentRoot, watermark) {
+    atomicWriteJson(sentinelWatermarkPath(agentRoot), watermark);
+}
+function updateWatermarkOrder(watermark, key, candidate) {
+    watermark[key] = maxOrder(watermark[key], orderFromReceipt(candidate));
+}
+function stableReceiptState(receipt) {
+    return JSON.stringify({
+        verdict: receipt.verdict,
+        summary: receipt.summary,
+        latestReadyLocator: receipt.latestReadyLocator,
+        recoveryAnchor: receipt.recoveryAnchor,
+        gauntlet: receipt.gauntlet,
+        signals: receipt.signals,
+        resumeSnapshot: receipt.resumeSnapshot,
+    });
+}
+function sameRecoveryState(left, right) {
+    return stableReceiptState(left) === stableReceiptState(right);
+}
+function setReceiptFileMtime(filePath, receipt) {
+    const timestamp = new Date(receipt.generatedAt);
+    fs.utimesSync(filePath, timestamp, timestamp);
+}
+function selectLatestReadyReceipt(existingReady, candidate, latestReadyOrder) {
+    if (candidate.verdict !== "ready")
+        return existingReady;
+    if (latestReadyOrder && compareOrder(orderFromReceipt(candidate), latestReadyOrder) < 0)
+        return existingReady;
+    return candidate;
+}
+function shouldReplaceLatestReceipt(existingLatest, candidate, latestOrder) {
+    if (latestOrder && compareOrder(orderFromReceipt(candidate), latestOrder) < 0)
+        return false;
+    if (!existingLatest)
+        return true;
+    return shouldReplaceReceipt(existingLatest, candidate);
+}
+function coalescedDaemonHealthReceipt(agentRoot, existingLatest, existingReady, candidate, watermark) {
+    if (candidate.trigger !== "daemon_health")
+        return null;
+    if (!existingLatest || !sameRecoveryState(existingLatest, candidate))
+        return null;
+    if (candidate.verdict === "ready" && (!existingReady || !sameRecoveryState(existingReady, candidate)))
+        return null;
+    const candidateOrder = orderFromReceipt(candidate);
+    if (watermark.latest && compareOrder(candidateOrder, watermark.latest) <= 0)
+        return existingLatest;
+    updateWatermarkOrder(watermark, "latest", candidate);
+    if (candidate.verdict === "ready" && existingReady) {
+        updateWatermarkOrder(watermark, "latestReady", candidate);
+    }
+    writeWatermark(agentRoot, watermark);
+    return existingLatest;
+}
+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 receiptIdFromFileName(fileName) {
+    return fileName.endsWith(".json") ? fileName.slice(0, -".json".length) : null;
+}
+function receiptOrderFromDetailFile(filePath, fileName) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (isReceipt(parsed))
+            return orderFromReceipt(parsed);
+    }
+    catch {
+        // Malformed legacy detail files should not block retention cleanup.
+    }
+    const stat = fs.statSync(filePath);
+    return {
+        generatedAt: new Date(stat.mtimeMs).toISOString(),
+        id: receiptIdFromFileName(fileName),
+    };
+}
+function pruneReceiptDetailFiles(paths, protectedReceiptIds) {
+    const fileNames = fs.readdirSync(paths.receiptsDir)
+        .filter((entry) => receiptIdFromFileName(entry) !== null);
+    if (fileNames.length <= CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT)
+        return;
+    const candidates = fileNames
+        .map((fileName) => ({
+        fileName,
+        filePath: path.join(paths.receiptsDir, fileName),
+        receiptId: receiptIdFromFileName(fileName),
+        order: receiptOrderFromDetailFile(path.join(paths.receiptsDir, fileName), fileName),
+    }))
+        .filter((entry) => !protectedReceiptIds.has(entry.receiptId))
+        .sort((left, right) => compareOrder(left.order, right.order));
+    const removalCount = fileNames.length - CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT;
+    for (const entry of candidates.slice(0, removalCount)) {
+        fs.rmSync(entry.filePath, { force: true });
+    }
+}
+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 {
+        if (!fs.existsSync(path.join(agentRoot, ".git")))
+            return { ok: true, porcelain: "" };
+        const porcelain = (0, child_process_1.execFileSync)("git", ["status", "--porcelain=v1", "-uall"], {
+            cwd: agentRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: CONTEXT_LOSS_SENTINEL_GIT_STATUS_TIMEOUT_MS,
+        });
+        return { ok: true, porcelain };
+    }
+    catch (error) {
+        return { ok: false, error: String(error) };
+    }
+}
+function gitStatusEntries(porcelain) {
+    return porcelain.split(/\r?\n/).filter((line) => line.trim().length > 0);
+}
+function normalizeGitStatusPath(entryPath) {
+    return entryPath.trim().replace(/^"|"$/g, "");
+}
+function gitStatusPaths(entry) {
+    const rawPath = entry.slice(3).trim();
+    const paths = [];
+    let start = 0;
+    let inQuote = false;
+    let escaped = false;
+    for (let index = 0; index < rawPath.length; index += 1) {
+        const char = rawPath[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inQuote && char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "\"") {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && rawPath.startsWith(" -> ", index)) {
+            paths.push(rawPath.slice(start, index));
+            start = index + 4;
+            index += 3;
+        }
+    }
+    paths.push(rawPath.slice(start));
+    return paths.map(normalizeGitStatusPath);
+}
+function isSentinelGitStatusEntry(entry) {
+    const sentinelRoot = relativeSentinelRoot();
+    return gitStatusPaths(entry).every((entryPath) => {
+        const normalizedPath = entryPath.replace(/\/$/, "");
+        return normalizedPath === sentinelRoot || normalizedPath.startsWith(`${sentinelRoot}/`);
+    });
+}
+function isContextLossSentinelBlockerText(value) {
+    return value.startsWith("context-loss Sentinel blocked:");
+}
+function hasContextLossSentinelCheckpointEvents(agentRoot, resume) {
+    const events = readFlightRecorderEventsByIds(agentRoot, resume.lastSafeCheckpoint.sourceEventIds);
+    const foundEventIds = new Set(events.map((event) => event.id));
+    if (resume.lastSafeCheckpoint.sourceEventIds.some((eventId) => !foundEventIds.has(eventId)))
+        return false;
+    return resume.blockedBecause.length > 0
+        ? events.every(isContextLossSentinelBlockerEvent)
+        : events.every(isContextLossSentinelRecoveryEvent);
+}
+function isContextLossSentinelCheckpoint(agentRoot, resume) {
+    return resume.lastSafeCheckpoint.sourceEventIds.length > 0
+        && resume.lastSafeCheckpoint.sourceEventIds.every((eventId) => eventId.startsWith("fr-sentinel-"))
+        && resume.blockedBecause.every(isContextLossSentinelBlockerText)
+        && hasContextLossSentinelCheckpointEvents(agentRoot, resume);
+}
+function neutralizeSentinelCheckpoint(resume) {
+    return {
+        ...resume,
+        canContinue: true,
+        blockedBecause: [],
+        lastSafeCheckpoint: {
+            turnId: null,
+            sessionRef: null,
+            recordedAt: null,
+            sourceEventIds: [],
+        },
+        recorderHealth: { status: "ok", issues: [] },
+    };
+}
+function isContextLossSentinelProducedRef(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    if (record.kind !== "arc" || typeof record.locator !== "string")
+        return false;
+    const sentinelRoot = relativeSentinelRoot();
+    return record.locator === sentinelRoot || record.locator.startsWith(`${sentinelRoot}/`);
+}
+function isContextLossSentinelFlightRecorderEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    const meta = record.meta;
+    const producedRefs = record.producedRefs;
+    return typeof record.id === "string"
+        && record.id.startsWith("fr-sentinel-")
+        && (record.kind === "blocker_detected" || record.kind === "agent_note")
+        && meta?.source === "context-loss-sentinel"
+        && Array.isArray(producedRefs)
+        && producedRefs.length > 0
+        && producedRefs.every(isContextLossSentinelProducedRef);
+}
+function isContextLossSentinelBlockerEvent(event) {
+    return isContextLossSentinelFlightRecorderEvent(event)
+        && event.kind === "blocker_detected"
+        && Array.isArray(event.blockedBecause)
+        && event.blockedBecause.length > 0
+        && event.blockedBecause.every(isContextLossSentinelBlockerText);
+}
+function isContextLossSentinelRecoveryEvent(event) {
+    return isContextLossSentinelFlightRecorderEvent(event)
+        && event.kind === "agent_note"
+        && Array.isArray(event.blockedBecause)
+        && event.blockedBecause.length === 0
+        && event.meta?.resolution === "blocked-signals-recovered";
+}
+function gitShowHeadFile(agentRoot, entryPath) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["show", `HEAD:${entryPath}`], {
+            cwd: agentRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: CONTEXT_LOSS_SENTINEL_GIT_STATUS_TIMEOUT_MS,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function nonEmptyLines(text) {
+    return text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+}
+function isFlightRecorderEventsPath(entryPath) {
+    return /^arc\/flight-recorder\/events\/[^/]+\.jsonl$/.test(entryPath);
+}
+function isFlightRecorderLatestPath(entryPath) {
+    return entryPath === "arc/flight-recorder/latest.json";
+}
+function isDeletedGitStatusEntry(entry) {
+    return entry.slice(0, 2).includes("D");
+}
+function isUntrackedGitStatusEntry(entry) {
+    return entry.startsWith("??");
+}
+function isWorktreeOnlyModifiedGitStatusEntry(entry) {
+    return entry.slice(0, 2) === " M";
+}
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function isContextLossSentinelEventFileDirty(agentRoot, entry, entryPath) {
+    if (isDeletedGitStatusEntry(entry))
+        return false;
+    const filePath = path.join(agentRoot, entryPath);
+    if (isUntrackedGitStatusEntry(entry)) {
+        const candidateLines = fs.existsSync(filePath) ? nonEmptyLines(fs.readFileSync(filePath, "utf-8")) : [];
+        return candidateLines.length > 0
+            && candidateLines.every((line) => isContextLossSentinelFlightRecorderEvent(parseJsonLine(line)));
+    }
+    if (!isWorktreeOnlyModifiedGitStatusEntry(entry) || !fs.existsSync(filePath))
+        return false;
+    const headText = gitShowHeadFile(agentRoot, entryPath);
+    if (headText === null)
+        return false;
+    const headLines = nonEmptyLines(headText);
+    const currentLines = nonEmptyLines(fs.readFileSync(filePath, "utf-8"));
+    if (currentLines.length <= headLines.length)
+        return false;
+    if (!headLines.every((line, index) => currentLines[index] === line))
+        return false;
+    const appendedLines = currentLines.slice(headLines.length);
+    return appendedLines.every((line) => isContextLossSentinelFlightRecorderEvent(parseJsonLine(line)));
+}
+function isContextLossSentinelLatestDirty(agentRoot, entry, entryPath) {
+    if (isDeletedGitStatusEntry(entry) || isUntrackedGitStatusEntry(entry))
+        return false;
+    if (!isWorktreeOnlyModifiedGitStatusEntry(entry))
+        return false;
+    const current = readJson(path.join(agentRoot, entryPath));
+    if (!current.ok || !(0, flight_recorder_1.isFlightRecorderResume)(current.value) || !isContextLossSentinelCheckpoint(agentRoot, current.value)) {
+        return false;
+    }
+    const headText = gitShowHeadFile(agentRoot, entryPath);
+    if (headText === null)
+        return false;
+    const head = parseJsonLine(headText);
+    if (!(0, flight_recorder_1.isFlightRecorderResume)(head))
+        return false;
+    return JSON.stringify(neutralizeSentinelCheckpoint(current.value))
+        === JSON.stringify(neutralizeSentinelCheckpoint(head));
+}
+function isContextLossSentinelFlightRecorderGitStatusEntry(agentRoot, entry) {
+    return gitStatusPaths(entry).every((entryPath) => (isFlightRecorderEventsPath(entryPath)
+        ? isContextLossSentinelEventFileDirty(agentRoot, entry, entryPath)
+        : isFlightRecorderLatestPath(entryPath)
+            ? isContextLossSentinelLatestDirty(agentRoot, entry, entryPath)
+            : false));
+}
+function isContextLossSentinelOwnedGitStatusEntry(entry, options) {
+    return isSentinelGitStatusEntry(entry)
+        || isContextLossSentinelFlightRecorderGitStatusEntry(options.agentRoot, entry);
+}
+function bundleSignal(status, options) {
+    const gitStatusCommand = "git status --porcelain=v1 -uall";
+    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: gitStatusCommand },
+            repair: repair("agent-runnable", "bundle-cleanup", "Inspect bundle git state before assuming the local state is clean.", gitStatusCommand),
+        };
+    }
+    const dirtyEntries = gitStatusEntries(status.porcelain)
+        .filter((entry) => !(options.ignoreSentinelDirtyEntries && isContextLossSentinelOwnedGitStatusEntry(entry, options)));
+    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: gitStatusCommand },
+            repair: repair("agent-runnable", "bundle-cleanup", "Resolve or intentionally preserve local bundle changes before handoff.", gitStatusCommand),
+            meta: { dirtyEntries },
+        };
+    }
+    return {
+        id: "bundle:git",
+        kind: "bundle",
+        status: "pass",
+        severity: "info",
+        verdictImpact: "none",
+        summary: "bundle git status clean",
+        source: { kind: "git", locator: gitStatusCommand },
+    };
+}
+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) {
+    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 hasOnlySentinelAuthoredBlockers(agentRoot, resume) {
+    if (resume.blockedBecause.length === 0)
+        return false;
+    if (resume.lastSafeCheckpoint.sourceEventIds.length === 0)
+        return false;
+    const events = readFlightRecorderEventsByIds(agentRoot, resume.lastSafeCheckpoint.sourceEventIds);
+    const foundEventIds = new Set(events.map((event) => event.id));
+    if (resume.lastSafeCheckpoint.sourceEventIds.some((eventId) => !foundEventIds.has(eventId)))
+        return false;
+    const blockerEvents = events.filter((event) => (event.blockedBecause?.length ?? 0) > 0);
+    if (blockerEvents.length === 0)
+        return false;
+    return blockerEvents.every(isSentinelAuthoredBlockerEvent);
+}
+function selectGauntletResume(agentRoot) {
+    const resume = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    const latestReady = readLatestReady(agentRoot);
+    if (hasOnlySentinelAuthoredBlockers(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)))(), {
+            ignoreSentinelDirtyEntries: options.trigger === "daemon_health",
+            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;
+    if (receipt.signals.some((signal) => signal.kind === "gauntlet" && signal.verdictImpact === "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,
+        },
+    });
+}
+function recordRecoveredReceiptEvent(agentRoot, receipt) {
+    if (receipt.verdict === "blocked")
+        return;
+    const resume = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    if (!hasOnlySentinelAuthoredBlockers(agentRoot, resume))
+        return;
+    (0, flight_recorder_1.recordFlightRecorderEvent)(agentRoot, {
+        id: `fr-${receipt.id}-recovered`,
+        kind: "agent_note",
+        recordedAt: receipt.generatedAt,
+        summary: "context-loss Sentinel cleared its prior recovery blocker",
+        blockedBecause: [],
+        producedRefs: [{
+                kind: "arc",
+                locator: receipt.receiptLocator,
+            }],
+        meta: {
+            source: "context-loss-sentinel",
+            receiptId: receipt.id,
+            trigger: receipt.trigger,
+            resolution: "blocked-signals-recovered",
+        },
+    });
+}
+async function persistReceipt(agentRoot, receipt, lockTimeoutMs) {
+    const paths = contextLossSentinelPaths(agentRoot);
+    return withFileLock(paths.lock, lockTimeoutMs, async () => {
+        ensureSentinelDirs(paths);
+        const existingLatest = readReceiptFile(paths.latest, "latest.json", []);
+        const existingReady = readLatestReady(agentRoot);
+        const watermark = readWatermark(agentRoot);
+        const latestOrder = maxOrder(maxOrder(maxOrder(existingLatest ? orderFromReceipt(existingLatest) : null, existingReady ? orderFromReceipt(existingReady) : null), watermark.latest), watermark.latestReady);
+        const latestReadyOrder = maxOrder(maxOrder(existingReady ? orderFromReceipt(existingReady) : null, watermark.latestReady), existingLatest?.verdict === "ready" ? orderFromReceipt(existingLatest) : null);
+        const nextReady = selectLatestReadyReceipt(existingReady, receipt, latestReadyOrder);
+        syncLatestReadyState(receipt, nextReady);
+        const coalesced = coalescedDaemonHealthReceipt(agentRoot, existingLatest, existingReady, receipt, watermark);
+        if (coalesced)
+            return coalesced;
+        const receiptPath = path.join(paths.receiptsDir, `${receipt.id}.json`);
+        atomicWriteJson(receiptPath, receipt);
+        setReceiptFileMtime(receiptPath, receipt);
+        appendHistory(paths, receipt);
+        let latestAfterWrite = existingLatest ?? receipt;
+        if (shouldReplaceLatestReceipt(existingLatest, receipt, latestOrder)) {
+            atomicWriteJson(paths.latest, receipt);
+            updateWatermarkOrder(watermark, "latest", receipt);
+            writeWatermark(agentRoot, watermark);
+            setReceiptFileMtime(paths.latest, receipt);
+            latestAfterWrite = receipt;
+            recordBlockedReceiptEvent(agentRoot, receipt);
+            recordRecoveredReceiptEvent(agentRoot, receipt);
+        }
+        else if (existingLatest && nextReady === receipt) {
+            const updatedLatest = syncLatestReadyState(existingLatest, nextReady);
+            atomicWriteJson(paths.latest, updatedLatest);
+            latestAfterWrite = updatedLatest;
+        }
+        if (receipt.verdict === "ready" && nextReady === receipt) {
+            atomicWriteJson(paths.latestReady, receipt);
+            updateWatermarkOrder(watermark, "latestReady", receipt);
+            writeWatermark(agentRoot, watermark);
+            setReceiptFileMtime(paths.latestReady, receipt);
+        }
+        const protectedReceiptIds = new Set([receipt.id, latestAfterWrite.id]);
+        if (nextReady)
+            protectedReceiptIds.add(nextReady.id);
+        pruneReceiptDetailFiles(paths, protectedReceiptIds);
+        return 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);
+    }
+    const persistedReceipt = 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: persistedReceipt.verdict,
+            receiptId: persistedReceipt.id,
+            blockedSignals: persistedReceipt.signals.filter((entry) => entry.verdictImpact === "blocked").map((entry) => entry.id),
+            watchSignals: persistedReceipt.signals.filter((entry) => entry.verdictImpact === "watch").map((entry) => entry.id),
+        },
+    });
+    return persistedReceipt;
+}
+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) {
+    const blockedGuidance = receipt.verdict === "blocked"
+        ? receipt.latestReadyLocator
+            ? "guidance: current latest is blocked; repair blocked signals or use latest-ready before continuing."
+            : "guidance: current latest is blocked; repair blocked signals before continuing."
+        : null;
+    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}`,
+        ...(blockedGuidance ? [blockedGuidance] : []),
+        "",
+        "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`;
+}