@ouro.bot/cli 0.1.0-alpha.657 → 0.1.0-alpha.659

package/dist/heart/mcp/mcp-server.js

@@ -123,7 +123,7 @@ const TOOL_TO_COMMAND = {
     status: "agent.status",
     catchup: "agent.catchup",
     get_context: "agent.getContext",
-    search_notes: "agent.searchNotes",
+    search_facts: "agent.searchFacts",
     get_task: "agent.getTask",
 };
 const UUID_PREFIX_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-/i;
@@ -326,7 +326,7 @@ function createMcpServer(options) {
         status: "handleAgentStatus",
         catchup: "handleAgentCatchup",
         get_context: "handleAgentGetContext",
-        search_notes: "handleAgentSearchNotes",
+        search_facts: "handleAgentSearchFacts",
         get_task: "handleAgentGetTask",
     };
     function stringArg(args, key) {
@@ -537,7 +537,7 @@ function getToolSchemas() {
     return [
         {
             name: "ask",
-            description: "Ask the agent a question through a full conversation turn. This has the same identity, tools, and session continuity as send_message; use search_notes for read-only note lookup.",
+            description: "Ask the agent a question through a full conversation turn. This has the same identity, tools, and session continuity as send_message; use search_facts or consult_notes for read-only record lookup.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -548,7 +548,7 @@ function getToolSchemas() {
         },
         {
             name: "status",
-            description: "Get the agent's current status including active sessions, diary and journal state, and activity level.",
+            description: "Get the agent's current status including active sessions, Desk record state, and activity level.",
             inputSchema: {
                 type: "object",
                 properties: {},
@@ -576,19 +576,19 @@ function getToolSchemas() {
         },
         {
             name: "get_context",
-            description: "Get the agent's current working context including note summary, active tasks, and relevant state.",
+            description: "Get the agent's current working context including Desk record summary, active tasks, and relevant state.",
             inputSchema: {
                 type: "object",
                 properties: {},
             },
         },
         {
-            name: "search_notes",
-            description: "Read-only note search. Returns matching diary lines without running an agent turn or treating missing matches as absence of agent belief.",
+            name: "search_facts",
+            description: "Read-only fact search. Returns matching Desk record diary lines without running an agent turn or treating missing matches as absence of agent belief.",
             inputSchema: {
                 type: "object",
                 properties: {
-                    query: { type: "string", description: "Search term to look for in agent notes" },
+                    query: { type: "string", description: "Search term to look for in agent facts" },
                 },
                 required: ["query"],
             },

package/dist/heart/session-events.js

@@ -57,12 +57,10 @@ exports.migrateLegacySessionEnvelope = migrateLegacySessionEnvelope;
 exports.parseSessionEnvelope = parseSessionEnvelope;
 exports.loadSessionEnvelopeFile = loadSessionEnvelopeFile;
 exports.buildCanonicalSessionEnvelope = buildCanonicalSessionEnvelope;
-exports.appendEvictedToArchive = appendEvictedToArchive;
 exports.appendSyntheticAssistantEvent = appendSyntheticAssistantEvent;
 const fs = __importStar(require("fs"));
 const runtime_1 = require("../nerves/runtime");
 const structured_output_1 = require("./structured-output");
-let archiveDisabledEmitted = false;
 exports.EVENT_CONTENT_MAX_CHARS = 256 * 1024;
 function truncateLargeEventContent(content, maxChars) {
     if (typeof content !== "string") {
@@ -120,7 +118,7 @@ const TOOL_NAME_MIGRATIONS = {
     go_inward: "ponder",
     descend: "ponder",
     [`${LEGACY_WRITTEN_NOTE_PREFIX}_save`]: "diary_write",
-    [`${LEGACY_WRITTEN_NOTE_PREFIX}_search`]: "search_notes",
+    [`${LEGACY_WRITTEN_NOTE_PREFIX}_search`]: "search_facts",
 };
 function normalizeUsage(usage) {
     if (!usage || typeof usage !== "object")
@@ -1115,34 +1113,6 @@ function buildCanonicalSessionEnvelope(options) {
         evictedEvents,
     };
 }
-function agentFromSessionPath(sessPath) {
-    const match = sessPath.match(/(?:^|[/\\])AgentBundles[/\\]([^/\\]+)\.ouro(?:[/\\]|$)/);
-    return match?.[1] ?? "unknown";
-}
-/**
- * Archive writes are intentionally disabled. The session envelope remains the
- * bounded working-memory record; evicted events are no longer persisted to an
- * unbounded sidecar.
- */
-function appendEvictedToArchive(sessPath, evictedEvents) {
-    if (evictedEvents.length === 0)
-        return;
-    if (!archiveDisabledEmitted) {
-        archiveDisabledEmitted = true;
-        (0, runtime_1.emitNervesEvent)({
-            component: "heart",
-            event: "heart.session_archive_disabled",
-            message: "session archive append disabled",
-            meta: {
-                type: "session_archive_disabled",
-                agent: agentFromSessionPath(sessPath),
-                sessionPath: sessPath,
-                evictedCount: evictedEvents.length,
-                ts: new Date().toISOString(),
-            },
-        });
-    }
-}
 function appendSyntheticAssistantEvent(envelope, content, recordedAt) {
     // Use nextEventSequence(events) instead of `events.length + 1` so any gap
     // (from pruning, archive replay, or self-heal dedup) cannot collide with

package/dist/heart/start-of-turn-packet.js

@@ -42,6 +42,7 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 const bundle_state_1 = require("./bundle-state");
 const tempo_1 = require("./tempo");
+const flight_recorder_1 = require("../arc/flight-recorder");
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
 }
@@ -191,6 +192,7 @@ function buildStartOfTurnPacket(view, opts) {
         obligations: buildObligationsSection(effectiveObligations),
         cares: buildCaresSection(view.activeCares),
         presence: buildPresenceSection(view.peerPresence),
+        arcResume: opts?.flightRecorderResume ? (0, flight_recorder_1.formatFlightRecorderResume)(opts.flightRecorderResume) : undefined,
         resumeHint: buildResumeHint(view, opts?.canonicalObligations ? effectiveObligations : undefined),
         currentSessionTiming: opts?.currentSessionTiming,
         tempo,
@@ -231,6 +233,7 @@ function renderStartOfTurnPacket(packet) {
         { label: "provider", content: packet.providerSelection ?? "", priority: 8 },
         { label: "bundleState", content: (0, bundle_state_1.renderBundleStateHint)(packet.bundleState ?? []), priority: 7 },
         { label: "syncFailure", content: packet.syncFailure ?? "", priority: 7 },
+        { label: "arc", content: packet.arcResume ?? "", priority: 7 },
         { label: "resume", content: packet.resumeHint, priority: 6 },
         { label: "sessionTiming", content: packet.currentSessionTiming ?? "", priority: 5 },
         { label: "obligations", content: packet.obligations, priority: 5 },
@@ -256,8 +259,8 @@ function renderStartOfTurnPacket(packet) {
     for (const section of sortedByPriority) {
         if (tokens <= budget.max)
             break;
-        // Skip resumeHint — it's PROTECTED
-        if (section.label === "resume")
+        // Skip continuity sections — they are protected.
+        if (section.label === "resume" || section.label === "arc")
             continue;
         // Remove this section entirely
         const idx = sections.findIndex((s) => s.label === section.label);
@@ -285,6 +288,9 @@ function formatSections(sections) {
             case "resume":
                 parts.push(`**Next:** ${section.content}`);
                 break;
+            case "arc":
+                parts.push(`**Arc:**\n${section.content}`);
+                break;
             case "obligations":
                 parts.push(`**Owed:**\n${section.content}`);
                 break;

package/dist/heart/tool-description.js

@@ -56,11 +56,23 @@ const TOOL_DESCRIPTIONS = {
         return `searching code for '${truncate(p, 40)}'...`;
     },
     // Notes and knowledge
-    search_notes: (args) => {
+    search_facts: (args) => {
         const q = args.query;
         if (!q)
-            return "searching notes...";
-        return `searching notes for '${truncate(q, 40)}'...`;
+            return "searching facts...";
+        return `searching facts for '${truncate(q, 40)}'...`;
+    },
+    consult_diary: (args) => {
+        const q = args.query;
+        if (!q)
+            return "checking recent diary facts...";
+        return `consulting diary facts for '${truncate(q, 40)}'...`;
+    },
+    consult_notes: (args) => {
+        const q = args.query;
+        if (!q)
+            return "checking Desk record notes...";
+        return `consulting Desk record notes for '${truncate(q, 40)}'...`;
     },
     diary_write: (args) => {
         const about = args.about;

package/dist/heart/turn-context.js

@@ -58,9 +58,9 @@ const cares_1 = require("../arc/cares");
 const config_1 = require("./config");
 const runtime_credentials_1 = require("./runtime-credentials");
 const daemon_health_1 = require("./daemon/daemon-health");
-const prompt_1 = require("../mind/prompt");
 const provider_visibility_1 = require("./provider-visibility");
 const mail_import_discovery_1 = require("./mail-import-discovery");
+const flight_recorder_1 = require("../arc/flight-recorder");
 // ── Helpers ─────────────────────────────────────────────────────────
 const DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
 function isLiveCodingSessionStatus(status) {
@@ -229,6 +229,26 @@ function readBundleMetaFile() {
         /* v8 ignore stop */
     }
 }
+function degradedFlightRecorderResume(issue) {
+    return {
+        schemaVersion: 1,
+        hasCompleteState: false,
+        canContinue: false,
+        missing: ["currentAsk", "nextSafeAction"],
+        gaps: [],
+        currentAsk: { value: null, confidence: "unknown", sourceEventIds: [] },
+        nextSafeAction: { value: null, stopBefore: [], sourceEventIds: [] },
+        blockedBecause: [],
+        activeObligationIds: [],
+        activeReturnObligationIds: [],
+        activePacketIds: [],
+        openEvolutionCaseIds: [],
+        recentClaimIds: [],
+        unverifiedClaimIds: [],
+        lastSafeCheckpoint: { turnId: null, sessionRef: null, recordedAt: null, sourceEventIds: [] },
+        recorderHealth: { status: "degraded", issues: [issue] },
+    };
+}
 // ── Builder ─────────────────────────────────────────────────────────
 async function buildTurnContext(input) {
     const agentRoot = (0, identity_1.getAgentRoot)();
@@ -355,13 +375,13 @@ async function buildTurnContext(input) {
         daemonHealth = null;
         /* v8 ignore stop */
     }
-    let journalFiles = [];
+    let flightRecorderResume;
     try {
-        const journalDir = path.join(agentRoot, "journal");
-        journalFiles = (0, prompt_1.readJournalFiles)(journalDir);
+        flightRecorderResume = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
     }
-    catch { /* v8 ignore start -- defensive: fallback on read failure @preserve */
-        journalFiles = [];
+    catch (error) { /* v8 ignore start -- defensive: fallback on read failure @preserve */
+        const reason = error instanceof Error ? error.message : String(error);
+        flightRecorderResume = degradedFlightRecorderResume(`flight recorder read failed: ${reason}`);
         /* v8 ignore stop */
     }
     (0, runtime_1.emitNervesEvent)({
@@ -397,6 +417,6 @@ async function buildTurnContext(input) {
         senseStatusLines,
         bundleMeta,
         daemonHealth,
-        journalFiles,
+        flightRecorderResume,
     };
 }

package/dist/heart/work-card.js

@@ -0,0 +1,386 @@
+"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.validateWorkCardAgentName = validateWorkCardAgentName;
+exports.buildWorkCard = buildWorkCard;
+exports.formatWorkCardText = formatWorkCardText;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const provider_visibility_1 = require("./provider-visibility");
+const evolution_1 = require("../arc/evolution");
+const obligations_1 = require("../arc/obligations");
+const packets_1 = require("../arc/packets");
+const flight_recorder_1 = require("../arc/flight-recorder");
+const ACTIVE_PACKET_STATUSES = new Set([
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+]);
+function isoFromMs(ms) {
+    return new Date(ms).toISOString();
+}
+function obligationLocator(id) {
+    return `arc/obligations/${id}.json`;
+}
+function returnObligationLocator(id) {
+    return `arc/obligations/inner/${id}.json`;
+}
+function packetLocator(id) {
+    return `arc/packets/${id}.json`;
+}
+function evolutionLocator(id) {
+    return `arc/evolution/cases/${id}.json`;
+}
+function flightRecorderLocator() {
+    return "arc/flight-recorder/latest.json";
+}
+function validateWorkCardAgentName(agentName) {
+    const trimmed = agentName.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed)) {
+        throw new Error("work card requires a safe agent name (letters, numbers, dot, underscore, hyphen; no path separators)");
+    }
+    return trimmed;
+}
+function source(kind, locator, freshness = "current", redaction = "summary") {
+    return { kind, locator, freshness, redaction };
+}
+function issue(code, sourceRef, detail, severity = "degraded") {
+    return { code, severity, source: sourceRef, detail };
+}
+function readJsonDiagnostic(filePath) {
+    try {
+        return { ok: true, parsed: JSON.parse(fs.readFileSync(filePath, "utf-8")) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            detail: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error),
+        };
+    }
+}
+function scanJsonDir(dir, sourceKind, locatorForFile, isValid) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.endsWith(".json"))
+        .flatMap((entry) => {
+        const filePath = path.join(dir, entry);
+        const sourceRef = source(sourceKind, locatorForFile(path.basename(entry, ".json")), "unknown");
+        const read = readJsonDiagnostic(filePath);
+        if (!read.ok) {
+            return [issue("arc_json_unreadable", sourceRef, `${sourceRef.locator} could not be parsed: ${read.detail}`)];
+        }
+        if (!isValid(read.parsed)) {
+            return [issue("arc_json_invalid_shape", sourceRef, `${sourceRef.locator} does not match the expected Work Card source shape`)];
+        }
+        return [];
+    });
+}
+function hasStringRecordFields(value, fields) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return fields.every((field) => typeof record[field] === "string");
+}
+function scanArcSourceIssues(agentRoot) {
+    return [
+        ...scanJsonDir(path.join(agentRoot, "arc", "obligations"), "obligation", obligationLocator, (value) => hasStringRecordFields(value, ["id", "content", "status"])),
+        ...scanJsonDir(path.join(agentRoot, "arc", "obligations", "inner"), "return_obligation", returnObligationLocator, (value) => hasStringRecordFields(value, ["id", "status", "delegatedContent"])
+            && typeof value.createdAt === "number"),
+        ...scanJsonDir(path.join(agentRoot, "arc", "packets"), "ponder_packet", packetLocator, (value) => hasStringRecordFields(value, ["id", "kind", "status", "objective"])),
+        ...scanJsonDir(path.join(agentRoot, "arc", "evolution", "cases"), "evolution_case", evolutionLocator, (value) => hasStringRecordFields(value, ["id", "title", "status"])),
+    ];
+}
+function obligationItem(obligation) {
+    const freshness = obligation.meaning?.stalenessClass === "at-risk" ? "stale_risky" : "current";
+    return {
+        id: obligation.id,
+        title: obligation.content,
+        status: obligation.status,
+        source: source("obligation", obligationLocator(obligation.id), freshness),
+        ...(obligation.latestNote ? { summary: obligation.latestNote } : {}),
+        ...(obligation.nextAction ? { nextAction: obligation.nextAction } : {}),
+        updatedAt: obligation.updatedAt ?? obligation.createdAt,
+    };
+}
+function returnObligationItem(obligation) {
+    return {
+        id: obligation.id,
+        title: obligation.delegatedContent,
+        status: obligation.status,
+        source: source("return_obligation", returnObligationLocator(obligation.id)),
+        ...(obligation.packetId ? { summary: `packet: ${obligation.packetId}` } : {}),
+        nextAction: obligation.status === "queued" ? "start private work and preserve the return route" : "finish and surface the delegated result",
+        updatedAt: isoFromMs(obligation.startedAt ?? obligation.createdAt),
+    };
+}
+function packetItem(packet) {
+    return {
+        id: packet.id,
+        title: packet.objective,
+        status: packet.status,
+        source: source("ponder_packet", packetLocator(packet.id)),
+        summary: packet.summary,
+        nextAction: packet.status === "blocked" ? "resolve blocker or mark waiting" : "advance packet toward validation and return",
+        updatedAt: isoFromMs(packet.updatedAt),
+    };
+}
+function evolutionItem(item) {
+    return {
+        id: item.id,
+        title: item.title,
+        status: item.status,
+        source: source("evolution_case", evolutionLocator(item.id)),
+        summary: item.problemStatement,
+        nextAction: (0, evolution_1.nextEvolutionActionForStatus)(item.status),
+        updatedAt: item.updatedAt,
+    };
+}
+function waitingOnHuman(items) {
+    return items.filter((item) => {
+        const lowerStatus = item.status.toLowerCase();
+        return lowerStatus.includes("waiting")
+            || lowerStatus.includes("blocked");
+    });
+}
+function chooseNextAction(input) {
+    if (input.waiting.length > 0) {
+        return {
+            actor: "human",
+            summary: input.waiting[0].nextAction ?? input.waiting[0].title,
+            source: input.waiting[0].source,
+        };
+    }
+    if (input.flightRecorderResume.blockedBecause.length > 0) {
+        return {
+            actor: "unknown",
+            summary: `flight recorder blocked: ${input.flightRecorderResume.blockedBecause.join("; ")}`,
+            source: source("flight_recorder", flightRecorderLocator(), input.flightRecorderResume.recorderHealth.status === "ok" ? "current" : "unknown"),
+        };
+    }
+    if (input.flightRecorderResume.recorderHealth.status === "ok"
+        && input.flightRecorderResume.canContinue
+        && input.flightRecorderResume.nextSafeAction.value) {
+        return {
+            actor: "agent",
+            summary: input.flightRecorderResume.nextSafeAction.value,
+            source: source("flight_recorder", flightRecorderLocator()),
+        };
+    }
+    if (input.returnObligations[0]) {
+        return {
+            actor: "agent",
+            summary: input.returnObligations[0].nextAction,
+            source: input.returnObligations[0].source,
+        };
+    }
+    if (input.owed[0]) {
+        return {
+            actor: "agent",
+            summary: input.owed[0].nextAction ?? input.owed[0].title,
+            source: input.owed[0].source,
+        };
+    }
+    if (input.activeWork[0]) {
+        return {
+            actor: "agent",
+            summary: input.activeWork[0].nextAction,
+            source: input.activeWork[0].source,
+        };
+    }
+    return {
+        actor: "unknown",
+        summary: "no open work found in arc; verify against current session context before claiming clear state",
+    };
+}
+function buildWorkCard(agentName, agentRoot, options = {}) {
+    const safeAgentName = validateWorkCardAgentName(agentName);
+    const generatedAt = (options.now ?? (() => new Date()))().toISOString();
+    const sourceIssues = scanArcSourceIssues(agentRoot);
+    const owed = (0, obligations_1.readPendingObligations)(agentRoot).map(obligationItem);
+    const returnObligations = (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot, { now: options.nowMs }).map(returnObligationItem);
+    const activePackets = (0, packets_1.listPonderPackets)(agentRoot)
+        .filter((packet) => ACTIVE_PACKET_STATUSES.has(packet.status))
+        .map(packetItem);
+    const evolutionCases = (0, evolution_1.listOpenEvolutionCases)(agentRoot).map(evolutionItem);
+    const activeWork = [...activePackets, ...evolutionCases];
+    const waiting = waitingOnHuman([...owed, ...returnObligations, ...activeWork]);
+    const flightRecorderResume = options.flightRecorderResume ?? (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    const claims = {
+        available: false,
+        unavailableReason: "WorkClaim store is not implemented yet; unverified claim counts are unknown, not zero.",
+        counts: {
+            unverified: null,
+            partial: null,
+            failed: null,
+            unverifiable: null,
+            staleRisky: null,
+            verified: null,
+        },
+        items: [],
+    };
+    const recorderIssues = flightRecorderResume.recorderHealth.status === "ok"
+        ? []
+        : flightRecorderResume.recorderHealth.issues.map((recorderIssue) => issue("flight_recorder_degraded", source("flight_recorder", flightRecorderLocator(), "unknown"), recorderIssue, flightRecorderResume.recorderHealth.status === "unavailable" ? "unavailable" : "degraded"));
+    const providers = (0, provider_visibility_1.buildAgentProviderVisibility)({ agentName: safeAgentName, agentRoot, homeDir: options.homeDir });
+    const nextAction = chooseNextAction({
+        owed,
+        returnObligations,
+        activeWork,
+        waiting,
+        claims,
+        flightRecorderResume,
+    });
+    const sources = [...owed, ...returnObligations, ...activeWork, ...claims.items].map((item) => item.source);
+    sources.push(source("claim_store", "arc/claims", "unknown"));
+    sources.push(source("flight_recorder", flightRecorderLocator(), flightRecorderResume.recorderHealth.status === "ok" ? "current" : "unknown"));
+    const issues = [...sourceIssues, ...recorderIssues];
+    const card = {
+        schemaVersion: 1,
+        projection: {
+            owner: "arc/work-card",
+            scope: "durable-arc-work",
+            relationToActiveWorkFrame: "complements-live-turn-frame",
+        },
+        agent: safeAgentName,
+        generatedAt,
+        degraded: {
+            status: issues.length > 0 ? "degraded" : "ok",
+            issues,
+        },
+        currentAsk: {
+            available: Boolean(flightRecorderResume.currentAsk.value),
+            ...(flightRecorderResume.currentAsk.value ? { value: flightRecorderResume.currentAsk.value } : {}),
+            source: flightRecorderResume.currentAsk.value ? "flight_recorder" : "not_tracked_yet",
+            confidence: flightRecorderResume.currentAsk.confidence,
+        },
+        counts: {
+            owed: owed.length,
+            returnObligations: returnObligations.length,
+            activePackets: activePackets.length,
+            evolutionCases: evolutionCases.length,
+            waitingOnHuman: waiting.length,
+            unverifiedClaims: null,
+            staleRiskyClaims: null,
+        },
+        owed,
+        returnObligations,
+        activeWork,
+        waitingOnOthers: waiting,
+        claims,
+        capabilityHealth: {
+            available: true,
+            providers,
+        },
+        nextAction,
+        sources,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.work_card_compiled",
+        message: "work card compiled from arc records",
+        meta: {
+            agent: agentName,
+            owedCount: card.counts.owed,
+            returnObligationCount: card.counts.returnObligations,
+            activeWorkCount: card.counts.activePackets + card.counts.evolutionCases,
+            waitingOnHumanCount: card.counts.waitingOnHuman,
+            claimsAvailable: card.claims.available,
+            sourceIssueCount: sourceIssues.length,
+        },
+    });
+    return card;
+}
+function formatItems(items, empty) {
+    if (items.length === 0)
+        return [`  ${empty}`];
+    return items.map((item) => {
+        const suffixes = [
+            item.nextAction ? `next: ${item.nextAction}` : null,
+            `source: ${item.source.locator}`,
+        ].filter(Boolean);
+        return `  - [${item.status}] ${item.title} (${suffixes.join("; ")})`;
+    });
+}
+function formatWorkCardText(card) {
+    return [
+        `Work Card — ${card.agent}`,
+        `generated: ${card.generatedAt}`,
+        `health: ${card.degraded.status} (${card.degraded.issues.length} issue${card.degraded.issues.length === 1 ? "" : "s"})`,
+        "",
+        `counts: owed=${card.counts.owed} return_obligations=${card.counts.returnObligations} active_packets=${card.counts.activePackets} evolution_cases=${card.counts.evolutionCases} waiting_on_human=${card.counts.waitingOnHuman} unverified_claims=${card.counts.unverifiedClaims ?? "unknown"} stale_risky_claims=${card.counts.staleRiskyClaims ?? "unknown"}`,
+        "",
+        "Current Ask",
+        card.currentAsk.available
+            ? `  ${card.currentAsk.value} (source: ${card.currentAsk.source}, confidence: ${card.currentAsk.confidence})`
+            : `  unavailable (${card.currentAsk.source})`,
+        "",
+        "Owed",
+        ...formatItems(card.owed, "none found in arc/obligations"),
+        "",
+        "Return Obligations",
+        ...formatItems(card.returnObligations, "none active"),
+        "",
+        "Active Work",
+        ...formatItems(card.activeWork, "none found in packets or evolution cases"),
+        "",
+        "Waiting On Others",
+        ...formatItems(card.waitingOnOthers, "none detected from durable records"),
+        "",
+        "Claims",
+        `  unavailable: ${card.claims.unavailableReason}`,
+        "",
+        "Source Issues",
+        ...card.degraded.issues.map((item) => `  - [${item.severity}] ${item.code}: ${item.detail} (source: ${item.source.locator})`),
+        "",
+        "Capability Health",
+        card.capabilityHealth.available
+            ? `  provider lanes: ${card.capabilityHealth.providers.lanes.map((lane) => `${lane.lane}:${lane.status}/${lane.readiness.status}`).join(", ")}`
+            : `  unavailable: ${card.capabilityHealth.unavailableReason}`,
+        "",
+        "Next Action",
+        `  ${card.nextAction.actor}: ${card.nextAction.summary}`,
+        card.nextAction.source ? `  source: ${card.nextAction.source.locator}` : "",
+    ].filter((line, index, lines) => line !== "" || lines[index - 1] !== "").join("\n").trim();
+}