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

package/dist/arc/obligations.js

@@ -0,0 +1,292 @@
+"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.isOpenObligationStatus = isOpenObligationStatus;
+exports.isOpenObligation = isOpenObligation;
+exports.createObligation = createObligation;
+exports.readObligations = readObligations;
+exports.readPendingObligations = readPendingObligations;
+exports.advanceObligation = advanceObligation;
+exports.fulfillObligation = fulfillObligation;
+exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
+exports.enrichObligation = enrichObligation;
+exports.generateObligationId = generateObligationId;
+exports.getReturnObligationsDir = getReturnObligationsDir;
+exports.getReturnObligationsDirForRoot = getReturnObligationsDirForRoot;
+exports.createReturnObligation = createReturnObligation;
+exports.readReturnObligation = readReturnObligation;
+exports.advanceReturnObligation = advanceReturnObligation;
+exports.listActiveReturnObligations = listActiveReturnObligations;
+exports.listActiveReturnObligationsForRoot = listActiveReturnObligationsForRoot;
+const path = __importStar(require("path"));
+const identity_1 = require("../heart/identity");
+const session_events_1 = require("../heart/session-events");
+const runtime_1 = require("../nerves/runtime");
+const json_store_1 = require("./json-store");
+function obligationsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations");
+}
+function isOpenObligationStatus(status) {
+    return status !== "fulfilled";
+}
+function isOpenObligation(obligation) {
+    return isOpenObligationStatus(obligation.status);
+}
+function createObligation(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = (0, json_store_1.generateTimestampId)();
+    const obligation = {
+        id,
+        origin: input.origin,
+        ...(input.bridgeId ? { bridgeId: input.bridgeId } : {}),
+        content: (0, session_events_1.capStructuredRecordString)(input.content),
+        status: "pending",
+        createdAt: now,
+        updatedAt: now,
+    };
+    (0, json_store_1.writeJsonFile)(obligationsDir(agentRoot), id, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_created",
+        message: "obligation created",
+        meta: {
+            obligationId: id,
+            friendId: input.origin.friendId,
+            channel: input.origin.channel,
+            key: input.origin.key,
+        },
+    });
+    return obligation;
+}
+function readObligations(agentRoot) {
+    const all = (0, json_store_1.readJsonDir)(obligationsDir(agentRoot));
+    return all.filter((parsed) => typeof parsed.id === "string" && typeof parsed.content === "string");
+}
+function readPendingObligations(agentRoot) {
+    return readObligations(agentRoot).filter(isOpenObligation);
+}
+function advanceObligation(agentRoot, obligationId, update) {
+    const dir = obligationsDir(agentRoot);
+    const obligation = (0, json_store_1.readJsonFile)(dir, obligationId);
+    if (!obligation)
+        return;
+    const previousStatus = obligation.status;
+    if (update.status) {
+        obligation.status = update.status;
+        if (update.status === "fulfilled") {
+            obligation.fulfilledAt = new Date().toISOString();
+        }
+    }
+    if (update.currentSurface) {
+        obligation.currentSurface = update.currentSurface;
+    }
+    if (typeof update.currentArtifact === "string") {
+        obligation.currentArtifact = (0, session_events_1.capStructuredRecordString)(update.currentArtifact);
+    }
+    if (typeof update.nextAction === "string") {
+        obligation.nextAction = (0, session_events_1.capStructuredRecordString)(update.nextAction);
+    }
+    if (typeof update.latestNote === "string") {
+        obligation.latestNote = (0, session_events_1.capStructuredRecordString)(update.latestNote);
+    }
+    obligation.updatedAt = new Date().toISOString();
+    (0, json_store_1.writeJsonFile)(dir, obligationId, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_advanced",
+        message: "obligation advanced",
+        meta: {
+            obligationId,
+            previousStatus,
+            status: obligation.status,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+            surfaceKind: obligation.currentSurface?.kind ?? null,
+            surfaceLabel: obligation.currentSurface?.label ?? null,
+        },
+    });
+}
+function fulfillObligation(agentRoot, obligationId) {
+    advanceObligation(agentRoot, obligationId, { status: "fulfilled" });
+    const obligation = (0, json_store_1.readJsonFile)(obligationsDir(agentRoot), obligationId);
+    if (!obligation)
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_fulfilled",
+        message: "obligation fulfilled",
+        meta: {
+            obligationId,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+        },
+    });
+}
+function findPendingObligationForOrigin(agentRoot, origin) {
+    return readPendingObligations(agentRoot).find((ob) => ob.origin.friendId === origin.friendId
+        && ob.origin.channel === origin.channel
+        && ob.origin.key === origin.key);
+}
+function enrichObligation(agentRoot, id, meaning) {
+    const dir = obligationsDir(agentRoot);
+    const existing = (0, json_store_1.readJsonFile)(dir, id);
+    if (!existing) {
+        throw new Error(`Obligation not found: ${id}`);
+    }
+    const obligation = existing;
+    obligation.meaning = {
+        ...meaning,
+        ...(typeof meaning.careReason === "string" ? { careReason: (0, session_events_1.capStructuredRecordString)(meaning.careReason) } : {}),
+        ...(typeof meaning.resumeHint === "string" ? { resumeHint: (0, session_events_1.capStructuredRecordString)(meaning.resumeHint) } : {}),
+        ...(meaning.waitingOn
+            ? { waitingOn: { ...meaning.waitingOn, detail: (0, session_events_1.capStructuredRecordString)(meaning.waitingOn.detail) } }
+            : {}),
+    };
+    obligation.updatedAt = new Date().toISOString();
+    (0, json_store_1.writeJsonFile)(dir, id, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_enriched",
+        message: "obligation enriched with meaning",
+        meta: {
+            obligationId: id,
+            salience: meaning.salience,
+            stalenessClass: meaning.stalenessClass,
+        },
+    });
+    return obligation;
+}
+function generateObligationId(timestamp) {
+    return `${timestamp}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function getReturnObligationsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "arc", "obligations", "inner");
+}
+function getReturnObligationsDirForRoot(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations", "inner");
+}
+function createReturnObligation(agentName, obligation) {
+    const dir = getReturnObligationsDir(agentName);
+    const cappedObligation = {
+        ...obligation,
+        delegatedContent: (0, session_events_1.capStructuredRecordString)(obligation.delegatedContent),
+    };
+    (0, json_store_1.writeJsonFile)(dir, obligation.id, cappedObligation);
+    const filePath = path.join(dir, `${obligation.id}.json`);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_created",
+        component: "mind",
+        message: "return obligation created",
+        meta: {
+            obligationId: obligation.id,
+            origin: `${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}`,
+            status: obligation.status,
+        },
+    });
+    return filePath;
+}
+function readReturnObligation(agentName, obligationId) {
+    return (0, json_store_1.readJsonFile)(getReturnObligationsDir(agentName), obligationId);
+}
+function advanceReturnObligation(agentName, obligationId, update) {
+    const existing = readReturnObligation(agentName, obligationId);
+    if (!existing)
+        return null;
+    const updated = {
+        ...existing,
+        status: update.status,
+        ...(update.startedAt !== undefined ? { startedAt: update.startedAt } : {}),
+        ...(update.returnedAt !== undefined ? { returnedAt: update.returnedAt } : {}),
+        ...(update.returnTarget !== undefined ? { returnTarget: update.returnTarget } : {}),
+    };
+    (0, json_store_1.writeJsonFile)(getReturnObligationsDir(agentName), obligationId, updated);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_advanced",
+        component: "mind",
+        message: `obligation advanced to ${update.status}`,
+        meta: {
+            obligationId,
+            status: update.status,
+            ...(update.returnTarget ? { returnTarget: update.returnTarget } : {}),
+        },
+    });
+    return updated;
+}
+// Inner return obligations that have been sitting in queued/running state
+// longer than this are auto-pruned from the "held work items" injection.
+// Anything older is overwhelmingly noise: the agent has had many turns to
+// resolve them and has not, and reinjecting them every turn just burns
+// attention without producing progress. The file stays on disk and can
+// still be inspected or surfaced explicitly; it just no longer gets
+// re-piped into the active prompt.
+const RETURN_OBLIGATION_INJECTION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+// Strict allow-list of statuses that should appear in the "held work items"
+// section. Anything else (including legacy/migrated `"fulfilled"` values left
+// over from before the ObligationStatus → ReturnObligationStatus split, plus
+// any future invalid value that slips past the `as any` casts at the
+// surface-tool boundary) is treated as terminal — i.e., we do not re-inject
+// it. This is a read-time defense; the underlying file is left as-is.
+const ACTIVE_RETURN_OBLIGATION_STATUSES = new Set(["queued", "running"]);
+function isSelfInnerReturnObligation(obligation) {
+    return obligation.origin?.friendId === "self" && obligation.origin.channel === "inner";
+}
+function isReturnObligationRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.id === "string"
+        && typeof candidate.status === "string"
+        && typeof candidate.delegatedContent === "string"
+        && typeof candidate.createdAt === "number"
+        && !!candidate.origin
+        && typeof candidate.origin.friendId === "string"
+        && typeof candidate.origin.channel === "string"
+        && typeof candidate.origin.key === "string";
+}
+function listActiveReturnObligations(agentName, options = {}) {
+    return listActiveReturnObligationsForRoot((0, identity_1.getAgentRoot)(agentName), options);
+}
+function listActiveReturnObligationsForRoot(agentRoot, options = {}) {
+    const all = (0, json_store_1.readJsonDir)(getReturnObligationsDirForRoot(agentRoot));
+    const nowMs = (options.now ?? Date.now)();
+    return all
+        .filter(isReturnObligationRecord)
+        .filter((parsed) => ACTIVE_RETURN_OBLIGATION_STATUSES.has(parsed.status))
+        .filter((parsed) => !isSelfInnerReturnObligation(parsed))
+        .filter((parsed) => nowMs - parsed.createdAt <= RETURN_OBLIGATION_INJECTION_MAX_AGE_MS)
+        .sort((a, b) => a.createdAt - b.createdAt);
+}

package/dist/arc/packets.js

@@ -0,0 +1,288 @@
+"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.getPonderPacketArtifactsDir = getPonderPacketArtifactsDir;
+exports.listPonderPackets = listPonderPackets;
+exports.readPonderPacket = readPonderPacket;
+exports.createPonderPacket = createPonderPacket;
+exports.revisePonderPacket = revisePonderPacket;
+exports.advancePonderPacket = advancePonderPacket;
+exports.completePonderPacket = completePonderPacket;
+exports.findHarnessFrictionPacket = findHarnessFrictionPacket;
+const path = __importStar(require("path"));
+const session_events_1 = require("../heart/session-events");
+const runtime_1 = require("../nerves/runtime");
+const task_lifecycle_1 = require("./task-lifecycle");
+const json_store_1 = require("./json-store");
+const evolution_1 = require("./evolution");
+function packetsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "packets");
+}
+function getPonderPacketArtifactsDir(agentRoot, packetId) {
+    return path.join(agentRoot, "state", "packets", packetId);
+}
+function packetLocator(packetId) {
+    return `arc/packets/${packetId}.json`;
+}
+function packetSop(kind) {
+    switch (kind) {
+        case "harness_friction":
+            return "harness_friction_v1";
+        case "research":
+            return "research_v1";
+        case "reflection":
+            return "reflection_v1";
+    }
+}
+function isPacketKind(value) {
+    return value === "harness_friction" || value === "research" || value === "reflection";
+}
+function isPonderPacket(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const packet = value;
+    return typeof packet.id === "string"
+        && isPacketKind(packet.kind)
+        && typeof packet.objective === "string"
+        && typeof packet.summary === "string"
+        && Array.isArray(packet.successCriteria)
+        && (0, task_lifecycle_1.isTaskStatus)(packet.status)
+        && typeof packet.createdAt === "number"
+        && typeof packet.updatedAt === "number";
+}
+function payloadString(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function evolutionOriginForPacket(packet) {
+    if (packet.origin) {
+        return {
+            kind: "session",
+            label: `${packet.origin.friendId}/${packet.origin.channel}/${packet.origin.key}`,
+            locator: packetLocator(packet.id),
+        };
+    }
+    return {
+        kind: "runtime",
+        label: "ponder packet",
+        locator: packetLocator(packet.id),
+    };
+}
+function desiredBehaviorForPacket(packet) {
+    return packet.successCriteria.length > 0
+        ? packet.successCriteria.join("; ")
+        : "Resolve the captured harness friction.";
+}
+function evidenceForPacket(packet, reason) {
+    return {
+        kind: "ponder_packet",
+        locator: packetLocator(packet.id),
+        capturedAt: new Date(packet.createdAt).toISOString(),
+        redaction: "summary",
+        reason,
+    };
+}
+function bindHarnessFrictionEvolutionCase(agentRoot, packet) {
+    if (packet.kind !== "harness_friction")
+        return packet;
+    const frictionSignature = payloadString(packet.payload, "frictionSignature");
+    if (!frictionSignature)
+        return packet;
+    const existing = (0, evolution_1.findOpenEvolutionCaseByFrictionSignature)(agentRoot, frictionSignature);
+    const evidenceReason = existing
+        ? "Harness-friction ponder packet added evidence to this evolution case"
+        : "Harness-friction ponder packet created this evolution case";
+    const evidence = evidenceForPacket(packet, evidenceReason);
+    const evolutionCase = existing
+        ? (0, evolution_1.addEvolutionEvidence)(agentRoot, existing.id, evidence)
+        : (0, evolution_1.createEvolutionCase)(agentRoot, {
+            title: packet.objective,
+            problemStatement: packet.summary,
+            desiredBehavior: desiredBehaviorForPacket(packet),
+            origin: evolutionOriginForPacket(packet),
+            evidenceRefs: [evidence],
+            frictionSignature,
+            packetId: packet.id,
+        });
+    if (!existing) {
+        (0, evolution_1.appendEvolutionTraceEvent)(agentRoot, evolutionCase.id, {
+            type: "evidence_added",
+            reason: evidence.reason,
+            evidenceRefs: [evidence.locator],
+        });
+    }
+    return {
+        ...packet,
+        payload: {
+            ...packet.payload,
+            evolutionCaseId: evolutionCase.id,
+        },
+    };
+}
+function listPonderPackets(agentRoot) {
+    return (0, json_store_1.readJsonDir)(packetsDir(agentRoot))
+        .filter(isPonderPacket)
+        .sort((left, right) => left.createdAt - right.createdAt);
+}
+function readPonderPacket(agentRoot, packetId) {
+    const packet = (0, json_store_1.readJsonFile)(packetsDir(agentRoot), packetId);
+    return isPonderPacket(packet) ? packet : null;
+}
+function createPonderPacket(agentRoot, input) {
+    const now = Date.now();
+    const packet = bindHarnessFrictionEvolutionCase(agentRoot, {
+        id: (0, json_store_1.generateTimestampId)("pkt"),
+        kind: input.kind,
+        sop: packetSop(input.kind),
+        status: "drafting",
+        objective: (0, session_events_1.capStructuredRecordString)(input.objective),
+        summary: (0, session_events_1.capStructuredRecordString)(input.summary),
+        successCriteria: (0, session_events_1.capStructuredRecordStringArray)(input.successCriteria),
+        ...(input.origin ? { origin: input.origin } : {}),
+        ...(input.relatedObligationId ? { relatedObligationId: input.relatedObligationId } : {}),
+        ...(input.relatedReturnObligationId ? { relatedReturnObligationId: input.relatedReturnObligationId } : {}),
+        ...(input.followsPacketId ? { followsPacketId: input.followsPacketId } : {}),
+        payload: (0, session_events_1.capStructuredRecordStringLeaves)(input.payload),
+        createdAt: now,
+        updatedAt: now,
+    });
+    (0, json_store_1.writeJsonFile)(packetsDir(agentRoot), packet.id, packet);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_created",
+        message: "ponder packet created",
+        meta: { packetId: packet.id, kind: packet.kind, status: packet.status },
+    });
+    return packet;
+}
+function revisePonderPacket(agentRoot, packetId, input) {
+    const existing = readPonderPacket(agentRoot, packetId);
+    if (!existing) {
+        throw new Error(`packet not found: ${packetId}`);
+    }
+    if (existing.status !== "drafting") {
+        throw new Error("packet is no longer drafting; file a follow-up packet instead");
+    }
+    const revised = {
+        ...existing,
+        kind: input.kind,
+        sop: packetSop(input.kind),
+        objective: (0, session_events_1.capStructuredRecordString)(input.objective),
+        summary: (0, session_events_1.capStructuredRecordString)(input.summary),
+        successCriteria: (0, session_events_1.capStructuredRecordStringArray)(input.successCriteria),
+        payload: (0, session_events_1.capStructuredRecordStringLeaves)(input.payload),
+        updatedAt: Date.now(),
+    };
+    (0, json_store_1.writeJsonFile)(packetsDir(agentRoot), packetId, revised);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_revised",
+        message: "ponder packet revised",
+        meta: { packetId, kind: revised.kind, status: revised.status },
+    });
+    return revised;
+}
+function advancePonderPacket(agentRoot, packetId, update) {
+    const existing = readPonderPacket(agentRoot, packetId);
+    if (!existing) {
+        throw new Error(`packet not found: ${packetId}`);
+    }
+    const nextStatus = update.status ?? existing.status;
+    if (update.status) {
+        const transition = (0, task_lifecycle_1.validateTransition)(existing.status, update.status);
+        if (!transition.ok) {
+            throw new Error(transition.reason);
+        }
+    }
+    const advanced = {
+        ...existing,
+        status: nextStatus,
+        ...(update.relatedObligationId ? { relatedObligationId: update.relatedObligationId } : {}),
+        ...(update.relatedReturnObligationId ? { relatedReturnObligationId: update.relatedReturnObligationId } : {}),
+        updatedAt: Date.now(),
+    };
+    (0, json_store_1.writeJsonFile)(packetsDir(agentRoot), packetId, advanced);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_advanced",
+        message: "ponder packet advanced",
+        meta: { packetId, status: advanced.status },
+    });
+    return advanced;
+}
+const PONDER_PACKET_COMPLETION_PATH = {
+    drafting: ["processing", "validating", "done"],
+    processing: ["validating", "done"],
+    validating: ["done"],
+    collaborating: ["validating", "done"],
+    paused: ["processing", "validating", "done"],
+    blocked: ["processing", "validating", "done"],
+    done: [],
+    cancelled: [],
+};
+function completePonderPacket(agentRoot, packetId) {
+    let packet = readPonderPacket(agentRoot, packetId);
+    if (!packet) {
+        throw new Error(`packet not found: ${packetId}`);
+    }
+    for (const status of PONDER_PACKET_COMPLETION_PATH[packet.status]) {
+        packet = advancePonderPacket(agentRoot, packet.id, { status });
+    }
+    return packet;
+}
+function findHarnessFrictionPacket(agentRoot, origin, frictionSignature) {
+    const found = listPonderPackets(agentRoot).find((packet) => {
+        if (packet.kind !== "harness_friction")
+            return false;
+        if (!packet.origin)
+            return false;
+        return packet.origin.friendId === origin.friendId
+            && packet.origin.channel === origin.channel
+            && packet.origin.key === origin.key
+            && packet.payload.frictionSignature === frictionSignature;
+    }) ?? null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.packet_lookup",
+        message: "ponder packet lookup completed",
+        meta: {
+            kind: "harness_friction",
+            found: found !== null,
+            origin: `${origin.friendId}/${origin.channel}/${origin.key}`,
+            frictionSignature,
+        },
+    });
+    return found;
+}