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

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

@@ -0,0 +1,387 @@
+"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.runContextLossGauntlet = runContextLossGauntlet;
+exports.formatContextLossGauntletText = formatContextLossGauntletText;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const flight_recorder_1 = require("../arc/flight-recorder");
+const record_paths_1 = require("../mind/record-paths");
+const runtime_1 = require("../nerves/runtime");
+const work_card_1 = require("./work-card");
+function makeCheck(input) {
+    return input;
+}
+function flightRecorderEvidence(card) {
+    return card.sources.filter((source) => source.kind === "flight_recorder").slice(0, 1);
+}
+function currentAskCheck(card) {
+    const evidence = flightRecorderEvidence(card);
+    if (!card.currentAsk.available) {
+        return makeCheck({
+            id: "current_ask",
+            label: "Current ask",
+            status: "fail",
+            score: 0,
+            maxScore: 15,
+            detail: "No durable current ask is available after context loss.",
+            evidence,
+        });
+    }
+    if (card.currentAsk.confidence !== "current") {
+        return makeCheck({
+            id: "current_ask",
+            label: "Current ask",
+            status: "warn",
+            score: 10,
+            maxScore: 15,
+            detail: `Current ask is available but marked ${card.currentAsk.confidence}.`,
+            evidence,
+        });
+    }
+    return makeCheck({
+        id: "current_ask",
+        label: "Current ask",
+        status: "pass",
+        score: 15,
+        maxScore: 15,
+        detail: "Current ask is preserved in the flight recorder.",
+        evidence,
+    });
+}
+const TERMINAL_IDLE_OUTCOMES = new Set(["settled", "observed", "rested", "superseded"]);
+function isTerminalIdleTurnWait(resume) {
+    const blocker = resume.blockedBecause[0] ?? "";
+    const match = /^turn outcome ([a-z_]+); wait for new input before acting$/.exec(blocker);
+    return resume.hasCompleteState
+        && resume.recorderHealth.status === "ok"
+        && resume.blockedBecause.length === 1
+        && match !== null
+        && TERMINAL_IDLE_OUTCOMES.has(match[1])
+        && resume.nextSafeAction.value === "inspect the latest session and wait for new input before acting";
+}
+function nextSafeActionCheck(card, resume) {
+    const evidence = card.nextAction.source ? [card.nextAction.source] : [];
+    if (isTerminalIdleTurnWait(resume)) {
+        return makeCheck({
+            id: "next_safe_action",
+            label: "Next safe action",
+            status: "pass",
+            score: 20,
+            maxScore: 20,
+            detail: "idle: turn is settled and waiting for new input.",
+            evidence: flightRecorderEvidence(card),
+        });
+    }
+    if (card.nextAction.actor === "unknown") {
+        return makeCheck({
+            id: "next_safe_action",
+            label: "Next safe action",
+            status: "fail",
+            score: 0,
+            maxScore: 20,
+            detail: card.nextAction.summary,
+            evidence,
+        });
+    }
+    return makeCheck({
+        id: "next_safe_action",
+        label: "Next safe action",
+        status: "pass",
+        score: 20,
+        maxScore: 20,
+        detail: `${card.nextAction.actor}: ${card.nextAction.summary}`,
+        evidence,
+    });
+}
+function staleGuardCheck(resume, card) {
+    const evidence = flightRecorderEvidence(card);
+    if (resume.canContinue && resume.hasCompleteState && resume.recorderHealth.status === "ok" && resume.blockedBecause.length === 0) {
+        return makeCheck({
+            id: "stale_guard",
+            label: "Stale-state guard",
+            status: "pass",
+            score: 15,
+            maxScore: 15,
+            detail: "Flight recorder permits continuation with complete state.",
+            evidence,
+        });
+    }
+    if (isTerminalIdleTurnWait(resume)) {
+        return makeCheck({
+            id: "stale_guard",
+            label: "Stale-state guard",
+            status: "pass",
+            score: 15,
+            maxScore: 15,
+            detail: "Flight recorder has complete settled-turn state and is safely waiting for new input.",
+            evidence,
+        });
+    }
+    const reasons = [
+        "canContinue is false",
+        ...(!resume.hasCompleteState ? ["incomplete resume state"] : []),
+        ...(resume.recorderHealth.status !== "ok" ? [`recorder health is ${resume.recorderHealth.status}`] : []),
+        ...(resume.blockedBecause.length > 0 ? resume.blockedBecause : []),
+    ];
+    return makeCheck({
+        id: "stale_guard",
+        label: "Stale-state guard",
+        status: "fail",
+        score: 0,
+        maxScore: 15,
+        detail: `Flight recorder says continuation is unsafe: ${reasons.join("; ")}.`,
+        evidence,
+    });
+}
+function obligationsCheck(card) {
+    if (card.counts.owed === 0) {
+        return makeCheck({
+            id: "obligations_visible",
+            label: "Obligations",
+            status: "not_applicable",
+            score: 0,
+            maxScore: 0,
+            detail: "No owed obligations are active.",
+            evidence: [],
+        });
+    }
+    const evidence = card.owed.map((item) => item.source);
+    return makeCheck({
+        id: "obligations_visible",
+        label: "Obligations",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: `${card.counts.owed} owed obligation(s) have source locators.`,
+        evidence,
+    });
+}
+function returnRoutesCheck(card) {
+    if (card.counts.returnObligations === 0) {
+        return makeCheck({
+            id: "return_routes_visible",
+            label: "Return routes",
+            status: "not_applicable",
+            score: 0,
+            maxScore: 0,
+            detail: "No active return obligations are queued.",
+            evidence: [],
+        });
+    }
+    const evidence = card.returnObligations.map((item) => item.source);
+    return makeCheck({
+        id: "return_routes_visible",
+        label: "Return routes",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: `${card.counts.returnObligations} return route(s) are visible.`,
+        evidence,
+    });
+}
+function blockersCheck(card) {
+    if (card.counts.waitingOnHuman === 0) {
+        return makeCheck({
+            id: "blockers_surface",
+            label: "Blockers",
+            status: "not_applicable",
+            score: 0,
+            maxScore: 0,
+            detail: "No waiting or blocked work is active.",
+            evidence: [],
+        });
+    }
+    const evidence = card.waitingOnOthers.map((item) => item.source);
+    return makeCheck({
+        id: "blockers_surface",
+        label: "Blockers",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: "Waiting work controls the next action.",
+        evidence,
+    });
+}
+function deskRecordCheck(agentRoot) {
+    const recordPaths = (0, record_paths_1.resolveDeskRecordPaths)(agentRoot);
+    const requiredPaths = [
+        recordPaths.recordRoot,
+        recordPaths.diaryRoot,
+        recordPaths.diaryDailyDir,
+        recordPaths.notesRoot,
+        recordPaths.factsPath,
+        recordPaths.entitiesPath,
+    ];
+    const missing = requiredPaths
+        .filter((entry) => !fs.existsSync(entry))
+        .map((entry) => path.relative(agentRoot, entry));
+    const legacyRoots = ["journal", "diary"]
+        .map((entry) => path.join(agentRoot, entry))
+        .filter((entry) => fs.existsSync(entry))
+        .map((entry) => path.relative(agentRoot, entry));
+    if (legacyRoots.length > 0) {
+        return makeCheck({
+            id: "desk_record_ready",
+            label: "Desk record",
+            status: "fail",
+            score: 0,
+            maxScore: 10,
+            detail: `Legacy active record root(s) still exist: ${legacyRoots.join(", ")}.`,
+            evidence: [],
+        });
+    }
+    if (missing.length > 0) {
+        return makeCheck({
+            id: "desk_record_ready",
+            label: "Desk record",
+            status: "warn",
+            score: 5,
+            maxScore: 10,
+            detail: `Canonical Desk record scaffold is incomplete: ${missing.join(", ")}.`,
+            evidence: [],
+        });
+    }
+    return makeCheck({
+        id: "desk_record_ready",
+        label: "Desk record",
+        status: "pass",
+        score: 10,
+        maxScore: 10,
+        detail: "Canonical Desk record scaffold is present and no legacy record roots are active.",
+        evidence: [],
+    });
+}
+function sourceProvenanceCheck(card) {
+    const evidence = card.sources;
+    if (card.degraded.issues.length > 0) {
+        return makeCheck({
+            id: "source_provenance",
+            label: "Source provenance",
+            status: "fail",
+            score: 0,
+            maxScore: 15,
+            detail: `${card.degraded.issues.length} Work Card source issue(s) are present.`,
+            evidence,
+        });
+    }
+    return makeCheck({
+        id: "source_provenance",
+        label: "Source provenance",
+        status: "pass",
+        score: 15,
+        maxScore: 15,
+        detail: "Work Card source locators are intact.",
+        evidence,
+    });
+}
+function summarize(verdict) {
+    if (verdict === "ready")
+        return "ready: durable Arc, flight recorder, and Desk state can carry context-loss recovery";
+    if (verdict === "watch")
+        return "watch: recovery is possible, but warnings need attention";
+    return "blocked: context-loss recovery would lose or mislead the agent";
+}
+function runContextLossGauntlet(agentName, agentRoot, options = {}) {
+    const flightRecorderResume = options.flightRecorderResume ?? (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    const card = (0, work_card_1.buildWorkCard)(agentName, agentRoot, { ...options, flightRecorderResume });
+    const generatedAt = (options.now ?? (() => new Date()))().toISOString();
+    const checks = [
+        currentAskCheck(card),
+        nextSafeActionCheck(card, flightRecorderResume),
+        staleGuardCheck(flightRecorderResume, card),
+        obligationsCheck(card),
+        returnRoutesCheck(card),
+        blockersCheck(card),
+        deskRecordCheck(agentRoot),
+        sourceProvenanceCheck(card),
+    ];
+    const earned = checks.reduce((sum, check) => sum + check.score, 0);
+    const possible = checks.reduce((sum, check) => sum + check.maxScore, 0);
+    const percentage = Math.round((earned / possible) * 100);
+    const verdict = checks.some((check) => check.status === "fail")
+        ? "blocked"
+        : checks.some((check) => check.status === "warn")
+            ? "watch"
+            : "ready";
+    const report = {
+        schemaVersion: 1,
+        agent: card.agent,
+        generatedAt,
+        verdict,
+        summary: summarize(verdict),
+        score: { earned, possible, percentage },
+        currentAsk: card.currentAsk,
+        nextAction: card.nextAction,
+        counts: card.counts,
+        checks,
+        workCard: card,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.context_loss_gauntlet_ran",
+        message: "context-loss gauntlet scored durable recovery state",
+        meta: {
+            agent: card.agent,
+            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),
+        },
+    });
+    return report;
+}
+function statusToken(status) {
+    if (status === "not_applicable")
+        return "N/A";
+    return status.toUpperCase();
+}
+function formatContextLossGauntletText(report) {
+    return [
+        `Context-loss gauntlet - ${report.agent}`,
+        `generated: ${report.generatedAt}`,
+        `verdict: ${report.verdict} (${report.score.earned}/${report.score.possible}, ${report.score.percentage}%)`,
+        `summary: ${report.summary}`,
+        "",
+        "Recovery",
+        report.currentAsk.available
+            ? `  current ask: ${report.currentAsk.value} (${report.currentAsk.confidence})`
+            : `  current ask: unavailable (${report.currentAsk.source})`,
+        `  next action: ${report.nextAction.actor}: ${report.nextAction.summary}`,
+        "",
+        "Checks",
+        ...report.checks.map((check) => `  - ${statusToken(check.status)} ${check.id}: ${check.detail}`),
+    ].join("\n").trim();
+}