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

package/dist/arc/packets.js

@@ -0,0 +1,336 @@
+"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.ACTIVE_PONDER_PACKET_STATUSES = void 0;
+exports.getPonderPacketArtifactsDir = getPonderPacketArtifactsDir;
+exports.isActivePonderPacketStatus = isActivePonderPacketStatus;
+exports.isActivePonderPacket = isActivePonderPacket;
+exports.listPonderPackets = listPonderPackets;
+exports.listActivePonderPackets = listActivePonderPackets;
+exports.readPonderPacket = readPonderPacket;
+exports.findPonderPacketByRelatedReturnObligationId = findPonderPacketByRelatedReturnObligationId;
+exports.listPonderPacketsByRelatedReturnObligationId = listPonderPacketsByRelatedReturnObligationId;
+exports.listPonderPacketsByRelatedObligationId = listPonderPacketsByRelatedObligationId;
+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 obligations_1 = require("./obligations");
+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";
+}
+exports.ACTIVE_PONDER_PACKET_STATUSES = new Set([
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+]);
+function isActivePonderPacketStatus(status) {
+    return exports.ACTIVE_PONDER_PACKET_STATUSES.has(status);
+}
+function hasInactiveLinkedReturnObligation(agentRoot, packet, options = {}) {
+    if (!packet.relatedReturnObligationId)
+        return false;
+    const obligation = (0, obligations_1.readReturnObligationForRoot)(agentRoot, packet.relatedReturnObligationId);
+    return !(0, obligations_1.isActiveReturnObligationRecord)(obligation, options);
+}
+function hasFulfilledLinkedObligation(agentRoot, packet) {
+    if (!packet.relatedObligationId)
+        return false;
+    const obligation = (0, obligations_1.readObligation)(agentRoot, packet.relatedObligationId);
+    return obligation?.status === "fulfilled";
+}
+function isActivePonderPacket(agentRoot, packet, options = {}) {
+    return isActivePonderPacketStatus(packet.status)
+        && !hasInactiveLinkedReturnObligation(agentRoot, packet, options)
+        && !hasFulfilledLinkedObligation(agentRoot, packet);
+}
+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 listActivePonderPackets(agentRoot, options = {}) {
+    return listPonderPackets(agentRoot).filter((packet) => isActivePonderPacket(agentRoot, packet, options));
+}
+function readPonderPacket(agentRoot, packetId) {
+    const packet = (0, json_store_1.readJsonFile)(packetsDir(agentRoot), packetId);
+    return isPonderPacket(packet) ? packet : null;
+}
+function findPonderPacketByRelatedReturnObligationId(agentRoot, relatedReturnObligationId) {
+    return listPonderPacketsByRelatedReturnObligationId(agentRoot, relatedReturnObligationId)[0] ?? null;
+}
+function listPonderPacketsByRelatedReturnObligationId(agentRoot, relatedReturnObligationId) {
+    return listPonderPackets(agentRoot).filter((packet) => packet.relatedReturnObligationId === relatedReturnObligationId);
+}
+function listPonderPacketsByRelatedObligationId(agentRoot, relatedObligationId) {
+    return listPonderPackets(agentRoot).filter((packet) => packet.relatedObligationId === relatedObligationId);
+}
+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;
+}

package/dist/arc/presence.js

@@ -0,0 +1,185 @@
+"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.derivePresence = derivePresence;
+exports.writePresence = writePresence;
+exports.readPresence = readPresence;
+exports.readPeerPresence = readPeerPresence;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function presenceDir(agentRoot) {
+    return path.join(agentRoot, "state", "presence");
+}
+function deriveAvailability(inputs) {
+    if (inputs.currentTempo === "crisis")
+        return "dnd";
+    if (inputs.activeSessions > 0)
+        return "active";
+    if (inputs.openObligations > 0)
+        return "idle";
+    return "away";
+}
+function deriveLane(inputs) {
+    const hasCoding = inputs.codingLanes > 0;
+    const hasBridges = inputs.activeBridges > 0;
+    if (hasCoding && hasBridges)
+        return "mixed";
+    if (hasCoding)
+        return "coding";
+    if (hasBridges)
+        return "conversation";
+    return "idle";
+}
+function deriveMission(inputs) {
+    const parts = [];
+    if (inputs.openObligations > 0) {
+        parts.push(`${inputs.openObligations} open obligation${inputs.openObligations !== 1 ? "s" : ""}`);
+    }
+    if (inputs.activeBridges > 0) {
+        parts.push(`${inputs.activeBridges} active bridge${inputs.activeBridges !== 1 ? "s" : ""}`);
+    }
+    if (inputs.codingLanes > 0) {
+        parts.push(`${inputs.codingLanes} coding lane${inputs.codingLanes !== 1 ? "s" : ""}`);
+    }
+    if (parts.length === 0)
+        return "no active work";
+    return parts.join(", ");
+}
+function derivePresence(_agentRoot, agentName, inputs) {
+    const presence = {
+        agentName,
+        availability: deriveAvailability(inputs),
+        lane: deriveLane(inputs),
+        mission: deriveMission(inputs),
+        tempo: inputs.currentTempo,
+        updatedAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.presence_derived",
+        message: `presence derived: ${presence.availability}/${presence.lane}`,
+        meta: {
+            agentName,
+            availability: presence.availability,
+            lane: presence.lane,
+            tempo: presence.tempo,
+        },
+    });
+    return presence;
+}
+function writePresence(agentRoot, _agentName, presence) {
+    const dir = presenceDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "self.json"), JSON.stringify(presence, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.presence_written",
+        message: `presence written for ${presence.agentName}`,
+        meta: { agentName: presence.agentName },
+    });
+}
+function readPresence(agentRoot, _agentName) {
+    const filePath = path.join(presenceDir(agentRoot), "self.json");
+    if (!fs.existsSync(filePath)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read",
+            message: "presence file not found",
+            meta: { found: false },
+        });
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const presence = JSON.parse(raw);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read",
+            message: `presence read: ${presence.availability}`,
+            meta: { agentName: presence.agentName, found: true },
+        });
+        return presence;
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.presence_read_error",
+            message: "failed to read presence file",
+            meta: { error: "parse error" },
+        });
+        return null;
+    }
+}
+function readPeerPresence(agentRoot) {
+    const friendsDir = path.join(agentRoot, "friends");
+    if (!fs.existsSync(friendsDir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.peer_presence_read",
+            message: "no friends directory, no peers",
+            meta: { peerCount: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+    const peers = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(friendsDir, file), "utf-8");
+            const friend = JSON.parse(raw);
+            if (friend.kind !== "agent")
+                continue;
+            peers.push({
+                agentName: friend.name ?? path.basename(file, ".json"),
+                availability: "idle",
+                lane: "idle",
+                mission: "",
+                tempo: "brief",
+                updatedAt: friend.updatedAt ?? new Date().toISOString(),
+            });
+        }
+        catch {
+            // Skip malformed or unreadable files
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.peer_presence_read",
+        message: `read ${peers.length} agent peer records from friends`,
+        meta: { peerCount: peers.length },
+    });
+    return peers;
+}

package/dist/arc/task-lifecycle.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_STATUS_TRANSITIONS = exports.TASK_VALID_STATUSES = void 0;
+exports.isTaskStatus = isTaskStatus;
+exports.normalizeTaskStatus = normalizeTaskStatus;
+exports.validateTransition = validateTransition;
+const runtime_1 = require("../nerves/runtime");
+exports.TASK_VALID_STATUSES = [
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+    "done",
+    "cancelled",
+];
+exports.TASK_STATUS_TRANSITIONS = {
+    drafting: ["processing", "collaborating", "cancelled"],
+    processing: ["validating", "paused", "blocked", "cancelled"],
+    validating: ["done", "processing", "collaborating", "cancelled"],
+    collaborating: ["processing", "validating", "paused", "cancelled"],
+    paused: ["processing", "blocked", "cancelled"],
+    blocked: ["processing", "paused", "cancelled"],
+    done: [],
+    cancelled: [],
+};
+function isTaskStatus(value) {
+    return exports.TASK_VALID_STATUSES.includes(value);
+}
+function normalizeTaskStatus(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return isTaskStatus(normalized) ? normalized : null;
+}
+function validateTransition(from, to) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.step_start",
+        component: "mind",
+        message: "validating task status transition",
+        meta: { from, to },
+    });
+    if (from === to) {
+        return { ok: true, from, to };
+    }
+    const allowed = exports.TASK_STATUS_TRANSITIONS[from];
+    if (!allowed.includes(to)) {
+        return {
+            ok: false,
+            from,
+            to,
+            reason: `invalid transition: ${from} -> ${to}`,
+        };
+    }
+    return { ok: true, from, to };
+}