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

package/dist/mind/prompt.js

@@ -39,6 +39,7 @@ exports.bodyMapSection = bodyMapSection;
 exports.mcpToolsSection = mcpToolsSection;
 exports.runtimeInfoSection = runtimeInfoSection;
 exports.toolRestrictionSection = toolRestrictionSection;
+exports.wakePacketSection = wakePacketSection;
 exports.centerOfGravitySteeringSection = centerOfGravitySteeringSection;
 exports.commitmentsSection = commitmentsSection;
 exports.delegationHintSection = delegationHintSection;
@@ -481,10 +482,13 @@ function bridgeContextSection(options) {
         return "";
     return bridgeContext.startsWith("## ") ? bridgeContext : `## active bridge work\n${bridgeContext}`;
 }
+function wakePacketSection(options) {
+    return options?.wakePacket ?? "";
+}
 function activeWorkSection(options) {
     if (!options?.activeWorkFrame)
         return "";
-    return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame);
+    return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame, { hasWakePacket: !!options?.wakePacket });
 }
 function liveWorldStateSection(options) {
     if (!options?.activeWorkFrame)
@@ -506,6 +510,10 @@ function familyCrossSessionTruthSection(context, options) {
         return "";
     if (context?.friend?.trustLevel !== "family")
         return "";
+    // When wake packet is present, compress to one line
+    if (options?.wakePacket) {
+        return "When family asks whole-self status, answer from the cross-session picture above.";
+    }
     return `## cross-session truth
 When family asks what I'm up to or how things are going, I answer from the live world-state across visible sessions and lanes, not just the current thread.
 When live state conflicts with older transcript history, live state wins.
@@ -1010,6 +1018,7 @@ async function buildSystem(channel = "cli", options, context) {
         ] : []),
         // Group 7: dynamic state for this turn
         "# dynamic state for this turn",
+        wakePacketSection(options),
         liveWorldStateSection(options),
         pendingMessagesSection(options),
         activeWorkSection(options),

package/dist/repertoire/coding/context-pack.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareCodingContextPack = prepareCodingContextPack;
+exports.emitCodingEpisode = emitCodingEpisode;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -41,6 +42,7 @@ const child_process_1 = require("child_process");
 const active_work_1 = require("../../heart/active-work");
 const identity_1 = require("../../heart/identity");
 const runtime_1 = require("../../nerves/runtime");
+const episodes_1 = require("../../mind/episodes");
 const skills_1 = require("../skills");
 const CONTEXT_FILENAMES = ["AGENTS.md", "CLAUDE.md"];
 function defaultRunCommand(command, args, cwd) {
@@ -173,7 +175,7 @@ function buildScopeContent(request, contextFiles, skills, agentName) {
         formatSkills(skills),
     ].join("\n");
 }
-function buildStateContent(request, contextKey, generatedAt, snapshot, existingSessions, agentName, activeWorkFrame) {
+function buildStateContent(request, contextKey, generatedAt, snapshot, existingSessions, agentName, activeWorkFrame, wakePacket) {
     const gitSection = snapshot.available
         ? [
             `repoRoot: ${snapshot.repoRoot ?? "unknown"}`,
@@ -190,6 +192,7 @@ function buildStateContent(request, contextKey, generatedAt, snapshot, existingS
         `agent: ${request.parentAgent ?? agentName}`,
         formatOrigin(request),
         `obligationId: ${request.obligationId ?? "none"}`,
+        ...(wakePacket ? ["", "## Continuity", wakePacket] : []),
         "",
         "## Workspace Snapshot",
         gitSection,
@@ -226,7 +229,7 @@ function prepareCodingContextPack(input, deps = {}) {
     const snapshot = captureRepoSnapshot(input.request.workdir, runCommand);
     const generatedAt = nowIso();
     const scopeContent = buildScopeContent(input.request, contextFiles, skills, agentName);
-    const stateContent = buildStateContent(input.request, contextKey, generatedAt, snapshot, existingSessions, agentName, input.activeWorkFrame);
+    const stateContent = buildStateContent(input.request, contextKey, generatedAt, snapshot, existingSessions, agentName, input.activeWorkFrame, input.wakePacket || undefined);
     mkdirSync(contextDir, { recursive: true });
     writeFileSync(scopeFile, `${scopeContent}\n`, "utf-8");
     writeFileSync(stateFile, `${stateContent}\n`, "utf-8");
@@ -252,3 +255,23 @@ function prepareCodingContextPack(input, deps = {}) {
         stateContent,
     };
 }
+/**
+ * Emit a coding milestone episode when a session completes or blocks.
+ * This is the outbound leg of the coding round-trip: compact wake packet goes IN,
+ * episodes come BACK OUT.
+ */
+function emitCodingEpisode(agentRoot, session, outcome) {
+    (0, episodes_1.emitEpisode)(agentRoot, {
+        kind: "coding_milestone",
+        summary: `coding session ${session.id} (${session.runner}): ${outcome}`,
+        whyItMattered: `coding lane ${session.status}`,
+        relatedEntities: [`coding:${session.id}`],
+        salience: session.status === "failed" ? "high" : "medium",
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "repertoire",
+        event: "repertoire.coding_episode_emitted",
+        message: `coding episode emitted for ${session.id}`,
+        meta: { sessionId: session.id, outcome, status: session.status },
+    });
+}

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/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.185",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",