@ouro.bot/cli 0.1.0-alpha.184 → 0.1.0-alpha.186

package/dist/repertoire/tools-base.js

@@ -62,6 +62,11 @@ const obligations_1 = require("../mind/obligations");
 const progress_story_1 = require("../heart/progress-story");
 const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
 const obligations_2 = require("../heart/obligations");
+const episodes_1 = require("../mind/episodes");
+const cares_1 = require("../heart/cares");
+const agent_relationships_1 = require("../heart/agent-relationships");
+const presence_1 = require("../heart/presence");
+const intentions_1 = require("../heart/intentions");
 // Tracks which file paths have been read via read_file in this session.
 // edit_file requires a file to be read first (must-read-first guard).
 exports.editFileReadTracker = new Set();
@@ -1498,6 +1503,241 @@ exports.baseToolDefinitions = [
         requiredCapability: "reasoning-effort",
         summaryKeys: ["level"],
     },
+    // ── Continuity tools ──────────────────────────────────────────────
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_episodes",
+                description: "Query recent episodes from my continuity memory. Returns timestamped records of significant events (obligation shifts, coding milestones, bridge events, care events, turning points).",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        limit: { type: "number", description: "Maximum episodes to return (default 20)" },
+                        kind: { type: "string", description: "Filter by episode kind: obligation_shift, coding_milestone, bridge_event, care_event, tempo_shift, turning_point" },
+                        since: { type: "string", description: "ISO timestamp — only return episodes after this time" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const options = {};
+            if (a.limit)
+                options.limit = parseInt(a.limit, 10);
+            if (a.kind)
+                options.kinds = [a.kind];
+            if (a.since)
+                options.since = a.since;
+            const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, options);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_episodes", message: `queried ${episodes.length} episodes`, meta: { count: episodes.length } });
+            return JSON.stringify(episodes, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "capture_episode",
+                description: "Record a turning point or significant moment. This is my tool for saying 'that was important — keep it.' Nearly frictionless: only summary and whyItMattered required.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        summary: { type: "string", description: "What happened" },
+                        whyItMattered: { type: "string", description: "Why this was significant" },
+                        kind: { type: "string", description: "Episode kind (default: turning_point)" },
+                        salience: { type: "string", description: "low, medium, high, or critical (default: medium)" },
+                    },
+                    required: ["summary", "whyItMattered"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const episode = (0, episodes_1.emitEpisode)(agentRoot, {
+                kind: a.kind ?? "turning_point",
+                summary: a.summary,
+                whyItMattered: a.whyItMattered,
+                relatedEntities: [],
+                salience: a.salience ?? "medium",
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.capture_episode", message: `captured episode ${episode.id}`, meta: { id: episode.id } });
+            return JSON.stringify(episode, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_presence",
+                description: "Check who's around — my own availability/lane and known peer agents.",
+                parameters: { type: "object", properties: {} },
+            },
+        },
+        handler: () => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const agentName = (0, identity_1.getAgentName)();
+            const self = (0, presence_1.readPresence)(agentRoot, agentName);
+            const peers = (0, presence_1.readPeerPresence)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_presence", message: `presence: self + ${peers.length} peers`, meta: { peerCount: peers.length } });
+            return JSON.stringify({ self, peers }, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_cares",
+                description: "Query things I care about — ongoing concerns, watched situations, projects, people.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        status: { type: "string", description: "Filter by status: 'active', 'watching', 'resolved', 'dormant', or 'all' (default: active cares only)" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const cares = a.status === "all" ? (0, cares_1.readCares)(agentRoot) : (0, cares_1.readActiveCares)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_cares", message: `queried ${cares.length} cares`, meta: { count: cares.length } });
+            return JSON.stringify(cares, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "care_manage",
+                description: "Create, update, or resolve a care. Cares are things I watch over — people, projects, missions, system health.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["create", "update", "resolve"], description: "What to do" },
+                        id: { type: "string", description: "Care ID (required for update/resolve)" },
+                        label: { type: "string", description: "Short label for the care" },
+                        why: { type: "string", description: "Why this matters" },
+                        salience: { type: "string", description: "low, medium, high, or critical" },
+                        kind: { type: "string", description: "person, agent, project, mission, or system" },
+                        stewardship: { type: "string", description: "mine, shared, or delegated" },
+                    },
+                    required: ["action"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            let result;
+            if (a.action === "create") {
+                result = (0, cares_1.createCare)(agentRoot, {
+                    label: a.label ?? "untitled",
+                    why: a.why ?? "",
+                    kind: a.kind ?? "project",
+                    status: "active",
+                    salience: a.salience ?? "medium",
+                    steward: a.stewardship ?? "mine",
+                    relatedFriendIds: [],
+                    relatedAgentIds: [],
+                    relatedObligationIds: [],
+                    relatedEpisodeIds: [],
+                    currentRisk: null,
+                    nextCheckAt: null,
+                });
+            }
+            else if (a.action === "update") {
+                const updates = {};
+                if (a.label)
+                    updates.label = a.label;
+                if (a.why)
+                    updates.why = a.why;
+                if (a.salience)
+                    updates.salience = a.salience;
+                result = (0, cares_1.updateCare)(agentRoot, a.id, updates);
+            }
+            else if (a.action === "resolve") {
+                result = (0, cares_1.resolveCare)(agentRoot, a.id);
+            }
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.care_manage", message: `care ${a.action}`, meta: { action: a.action, id: a.id } });
+            return JSON.stringify(result, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_relationships",
+                description: "Query known agent relationships — familiarity, trust, shared missions, interaction history.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        agentName: { type: "string", description: "Specific agent name to query (omit for all)" },
+                    },
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const result = a.agentName
+                ? (0, agent_relationships_1.readRelationship)(agentRoot, a.agentName)
+                : (0, agent_relationships_1.readRelationships)(agentRoot);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.query_relationships", message: `queried relationships`, meta: { agentName: a.agentName ?? "all" } });
+            return JSON.stringify(result, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "intention_capture",
+                description: "File a lightweight mental note — something I want to do or check later, below the ceremony threshold of tasks or cares. Cheap to create, easy to close.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string", description: "What I want to remember to do" },
+                        salience: { type: "string", description: "low, medium, or high (default: low)" },
+                        nudgeAfter: { type: "string", description: "ISO timestamp — nudge me after this time" },
+                    },
+                    required: ["content"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const intention = (0, intentions_1.captureIntention)(agentRoot, {
+                content: a.content,
+                salience: a.salience ?? "low",
+                source: "tool",
+                ...(a.nudgeAfter ? { nudgeAfter: a.nudgeAfter } : {}),
+            });
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.intention_capture", message: `captured intention ${intention.id}`, meta: { id: intention.id } });
+            return JSON.stringify(intention, null, 2);
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "intention_manage",
+                description: "Resolve or dismiss an intention. Resolve = done. Dismiss = no longer relevant. Both remove it from active list.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        action: { type: "string", enum: ["resolve", "dismiss"], description: "What to do" },
+                        id: { type: "string", description: "Intention ID" },
+                    },
+                    required: ["action", "id"],
+                },
+            },
+        },
+        handler: (a) => {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const result = a.action === "resolve"
+                ? (0, intentions_1.resolveIntention)(agentRoot, a.id)
+                : (0, intentions_1.dismissIntention)(agentRoot, a.id);
+            (0, runtime_1.emitNervesEvent)({ component: "repertoire", event: "repertoire.intention_manage", message: `intention ${a.action}: ${a.id}`, meta: { action: a.action, id: a.id } });
+            return JSON.stringify(result, null, 2);
+        },
+    },
     ...tools_1.codingToolDefinitions,
 ];
 exports.tools = exports.baseToolDefinitions.map((d) => d.tool);

package/dist/senses/cli.js

@@ -797,7 +797,7 @@ async function runCliSession(options) {
                     }
                 }
                 else {
-                    // Legacy path: inline runAgent (used by adoption specialist and tests)
+                    // Legacy path: inline runAgent (used by serpent guide and tests)
                     const prefix = options.getContentPrefix?.();
                     messages.push({ role: "user", content: prefix ? `${prefix}\n\n${input}` : input });
                     const traceId = (0, nerves_1.createTraceId)();
@@ -845,6 +845,8 @@ async function runCliSession(options) {
         if (inkRef) {
             // Suppress React "state update on unmounted component" warnings during cleanup.
             // Ink's useInput hook fires after unmount — this is harmless but noisy.
+            // This also covers the SerpentGuide exitOnToolCall path, which aborts the
+            // current request and breaks out of the loop into this finally block.
             // eslint-disable-next-line no-console -- intentional console.warn/error override for cleanup
             const origWarn = console.warn;
             const origError = console.error; // eslint-disable-line no-console

package/dist/senses/pipeline.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitObligationTransitionEpisodes = emitObligationTransitionEpisodes;
 exports.handleInboundTurn = handleInboundTurn;
 const runtime_1 = require("../nerves/runtime");
 const commands_1 = require("./commands");
@@ -58,6 +59,32 @@ const obligations_2 = require("../mind/obligations");
 const provider_failover_1 = require("../heart/provider-failover");
 const provider_ping_1 = require("../heart/provider-ping");
 const auth_flow_1 = require("../heart/daemon/auth-flow");
+const tempo_1 = require("../heart/tempo");
+const temporal_view_1 = require("../heart/temporal-view");
+const wake_packet_1 = require("../heart/wake-packet");
+const presence_1 = require("../heart/presence");
+const episodes_1 = require("../mind/episodes");
+const cares_1 = require("../heart/cares");
+/**
+ * Emit episodes for obligation state transitions detected during a turn.
+ * Exported for direct testability (avoids v8 coverage merge issues in multi-file test suites).
+ */
+function emitObligationTransitionEpisodes(agentRoot, preTurnObligationIds, postTurnObligations, preTurnObligations) {
+    const postTurnObligationIds = new Set(postTurnObligations.map((ob) => `${ob.id}:${ob.status}`));
+    for (const key of preTurnObligationIds) {
+        if (!postTurnObligationIds.has(key)) {
+            const [obId] = key.split(":");
+            const matchedOb = postTurnObligations.find((ob) => ob.id === obId) ?? preTurnObligations.find((ob) => ob.id === obId);
+            (0, episodes_1.emitEpisode)(agentRoot, {
+                kind: "obligation_shift",
+                summary: `obligation "${matchedOb?.content ?? obId}" status changed`,
+                whyItMattered: "obligation state transition detected during turn",
+                relatedEntities: [`obligation:${obId}`],
+                salience: "medium",
+            });
+        }
+    }
+}
 function emptyTaskBoard() {
     return {
         compact: "",
@@ -430,6 +457,57 @@ async function handleInboundTurn(input) {
     for (const msg of input.messages) {
         sessionMessages.push(msg);
     }
+    // Step 4b: Continuity pipeline — derive tempo, build wake packet, snapshot obligations
+    let renderedWakePacket;
+    const preTurnObligationIds = new Set(pendingObligations.map((ob) => `${ob.id}:${ob.status}`));
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const agentName = (0, identity_1.getAgentName)();
+        const recentEpisodes = (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: 20 });
+        const activeCares = (0, cares_1.readActiveCares)(agentRoot);
+        const tempoState = (0, tempo_1.deriveTempo)({
+            activeSessions: sessionActivity.length + 1,
+            openObligations: pendingObligations.length,
+            recentEpisodeCount: recentEpisodes.length,
+            lastActivityAgeMs: sessionActivity.length > 0
+                ? Date.now() - new Date(sessionActivity[0].lastActivityAt).getTime()
+                : 0,
+            hasBlockers: false, // obligations use specific statuses, not "blocked"
+            highSalienceEpisodes: recentEpisodes.filter((ep) => ep.salience === "high" || ep.salience === "critical").length,
+            activeCareCount: activeCares.length,
+            atRiskCareCount: activeCares.filter((c) => c.currentRisk != null).length,
+        });
+        const temporalView = (0, temporal_view_1.buildTemporalView)(agentRoot, {
+            tempo: tempoState.mode,
+            preloaded: {
+                recentEpisodes,
+                activeObligations: pendingObligations,
+                activeCares,
+            },
+        });
+        const wakePacket = (0, wake_packet_1.buildWakePacket)(temporalView);
+        renderedWakePacket = (0, wake_packet_1.renderWakePacket)(wakePacket);
+        if (!renderedWakePacket)
+            renderedWakePacket = undefined;
+        // Update self-presence
+        const presence = (0, presence_1.derivePresence)(agentRoot, agentName, {
+            activeSessions: sessionActivity.length + 1,
+            openObligations: pendingObligations.length,
+            activeBridges: activeBridges.length,
+            codingLanes: codingSessions.length,
+            currentTempo: tempoState.mode,
+        });
+        (0, presence_1.writePresence)(agentRoot, agentName, presence);
+    }
+    catch (continuityError) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.continuity_error",
+            message: "continuity pipeline failed, continuing without wake packet",
+            meta: { error: continuityError instanceof Error ? continuityError.message : String(continuityError) },
+        });
+    }
     // Step 5: runAgent
     const existingToolContext = input.runAgentOptions?.toolContext;
     const runAgentOptions = {
@@ -437,6 +515,7 @@ async function handleInboundTurn(input) {
         bridgeContext,
         activeWorkFrame,
         delegationDecision,
+        wakePacket: renderedWakePacket,
         pendingMessages: pending.length > 0 ? pending.map((msg) => ({ from: msg.from, content: msg.content })) : undefined,
         currentSessionKey: currentSession.key,
         currentObligation,
@@ -501,6 +580,15 @@ async function handleInboundTurn(input) {
         }
         /* v8 ignore stop */
     }
+    // Step 5c: Emit episodes for obligation state transitions
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const postTurnObligations = (0, obligations_1.readPendingObligations)(agentRoot);
+        emitObligationTransitionEpisodes(agentRoot, preTurnObligationIds, postTurnObligations, pendingObligations);
+    }
+    catch {
+        // Episode emission is non-fatal
+    }
     // Step 6: postTurn
     const continuingState = {
         ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.184",
+  "version": "0.1.0-alpha.186",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -9,7 +9,7 @@
   },
   "files": [
     "dist/",
-    "AdoptionSpecialist.ouro/",
+    "SerpentGuide.ouro/",
     "subagents/",
     "skills/",
     "assets/",