@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.660

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();
+}