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

package/dist/heart/wake-packet.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWakePacket = buildWakePacket;
+exports.renderWakePacket = renderWakePacket;
+exports.renderCompactWakePacket = renderCompactWakePacket;
+const runtime_1 = require("../nerves/runtime");
+const tempo_1 = require("./tempo");
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// --- Section builders (pure derivation from authored data, no embellishment) ---
+function buildPlotLine(episodes, tempo) {
+    if (episodes.length === 0)
+        return "";
+    const limit = tempo === "crisis" ? 3 : tempo === "brief" ? 2 : 5;
+    const selected = episodes.slice(0, limit);
+    const lines = selected.map((ep) => {
+        const parts = [`- ${ep.summary}`];
+        if (ep.whyItMattered && tempo !== "brief") {
+            parts[0] += ` (${ep.whyItMattered})`;
+        }
+        return parts[0];
+    });
+    return lines.join("\n");
+}
+function buildObligationsSection(obligations) {
+    if (obligations.length === 0)
+        return "";
+    return obligations
+        .map((ob) => {
+        const parts = [`- ${ob.content}`];
+        if (ob.meaning?.resumeHint) {
+            parts.push(` [hint: ${ob.meaning.resumeHint}]`);
+        }
+        if (ob.meaning?.stalenessClass && ob.meaning.stalenessClass !== "fresh") {
+            parts.push(` (${ob.meaning.stalenessClass})`);
+        }
+        if (ob.meaning?.waitingOn) {
+            parts.push(` waiting on ${ob.meaning.waitingOn.kind}: ${ob.meaning.waitingOn.target}`);
+        }
+        return parts.join("");
+    })
+        .join("\n");
+}
+function buildCaresSection(cares) {
+    if (cares.length === 0)
+        return "";
+    return cares
+        .map((c) => {
+        const parts = [`- ${c.label}`];
+        if (c.salience !== "low") {
+            parts.push(` [${c.salience}]`);
+        }
+        if (c.currentRisk) {
+            parts.push(` risk: ${c.currentRisk}`);
+        }
+        return parts.join("");
+    })
+        .join("\n");
+}
+function buildPresenceSection(peers) {
+    if (peers.length === 0)
+        return "";
+    return peers
+        .map((p) => `- ${p.agentName}: ${p.availability}/${p.lane}`)
+        .join("\n");
+}
+function buildResumeHint(view) {
+    // Compose from authored obligation resumeHints and top intentions
+    const hints = [];
+    for (const ob of view.activeObligations) {
+        if (ob.meaning?.resumeHint) {
+            hints.push(ob.meaning.resumeHint);
+        }
+    }
+    for (const intent of view.openIntentions.slice(0, 3)) {
+        hints.push(intent.content);
+    }
+    if (hints.length === 0) {
+        // Fall back to top obligation content
+        if (view.activeObligations.length > 0) {
+            hints.push(view.activeObligations[0].content);
+        }
+    }
+    if (hints.length === 0)
+        return "";
+    return hints.join("; ");
+}
+function buildWakePacket(view) {
+    const tempo = view.tempo;
+    const tokenBudget = tempo_1.TEMPO_BUDGETS[tempo];
+    const packet = {
+        plotLine: buildPlotLine(view.recentEpisodes, tempo),
+        obligations: buildObligationsSection(view.activeObligations),
+        cares: buildCaresSection(view.activeCares),
+        presence: buildPresenceSection(view.peerPresence),
+        resumeHint: buildResumeHint(view),
+        tempo,
+        tokenBudget,
+        assembledAt: new Date().toISOString(),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.wake_packet_built",
+        message: `wake packet built: tempo=${tempo}`,
+        meta: {
+            tempo,
+            plotLineTokens: estimateTokens(packet.plotLine),
+            obligationsTokens: estimateTokens(packet.obligations),
+            caresTokens: estimateTokens(packet.cares),
+            presenceTokens: estimateTokens(packet.presence),
+            resumeHintTokens: estimateTokens(packet.resumeHint),
+        },
+    });
+    return packet;
+}
+/**
+ * Renders a wake packet to prompt text, respecting token budget.
+ * Truncation priority (last truncated first):
+ *   resumeHint (PROTECTED) > obligations > cares > plotLine > presence
+ * So presence is truncated first, then plotLine, then cares, then obligations.
+ * resumeHint is never truncated.
+ */
+function renderWakePacket(packet) {
+    const budget = packet.tokenBudget;
+    // Assemble sections in priority order (highest priority first for budget allocation)
+    // Each section is { label, content, priority } where lower priority number = truncated first
+    const sections = [
+        { label: "resume", content: packet.resumeHint, priority: 5 },
+        { label: "obligations", content: packet.obligations, priority: 4 },
+        { label: "cares", content: packet.cares, priority: 3 },
+        { label: "plot", content: packet.plotLine, priority: 2 },
+        { label: "presence", content: packet.presence, priority: 1 },
+    ].filter((s) => s.content.length > 0);
+    if (sections.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.wake_packet_rendered",
+            message: "wake packet rendered: empty",
+            meta: { tokens: 0, tempo: packet.tempo },
+        });
+        return "";
+    }
+    // Build the rendered output, truncating lower-priority sections first
+    let rendered = formatSections(sections);
+    let tokens = estimateTokens(rendered);
+    // Truncate sections from lowest priority until we fit budget
+    const sortedByPriority = [...sections].sort((a, b) => a.priority - b.priority);
+    for (const section of sortedByPriority) {
+        if (tokens <= budget.max)
+            break;
+        // Skip resumeHint — it's PROTECTED
+        if (section.label === "resume")
+            continue;
+        // Remove this section entirely
+        const idx = sections.findIndex((s) => s.label === section.label);
+        sections.splice(idx, 1);
+        rendered = formatSections(sections);
+        tokens = estimateTokens(rendered);
+    }
+    // If still over budget after removing all non-protected sections, trim what's left
+    if (tokens > budget.max) {
+        const maxChars = budget.max * 4;
+        rendered = rendered.slice(0, maxChars);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.wake_packet_rendered",
+        message: `wake packet rendered: ${tokens} tokens`,
+        meta: { tokens, tempo: packet.tempo, sectionCount: sections.length },
+    });
+    return rendered;
+}
+function formatSections(sections) {
+    const parts = [];
+    for (const section of sections) {
+        switch (section.label) {
+            case "resume":
+                parts.push(`**Next:** ${section.content}`);
+                break;
+            case "obligations":
+                parts.push(`**Owed:**\n${section.content}`);
+                break;
+            case "cares":
+                parts.push(`**Cares:**\n${section.content}`);
+                break;
+            case "plot":
+                parts.push(`**Recent:**\n${section.content}`);
+                break;
+            case "presence":
+                parts.push(`**Peers:**\n${section.content}`);
+                break;
+        }
+    }
+    return parts.join("\n\n");
+}
+/**
+ * Ultra-compact version for coding context (max 200 tokens).
+ * Just resumeHint + top obligation + top care, single-line bullets.
+ */
+function renderCompactWakePacket(packet) {
+    const parts = [];
+    if (packet.resumeHint) {
+        parts.push(`next: ${packet.resumeHint}`);
+    }
+    if (packet.obligations) {
+        // Just first line of obligations
+        const firstOb = packet.obligations.split("\n")[0];
+        parts.push(`owed: ${firstOb.replace(/^- /, "")}`);
+    }
+    if (packet.cares) {
+        const firstCare = packet.cares.split("\n")[0];
+        parts.push(`care: ${firstCare.replace(/^- /, "")}`);
+    }
+    const compact = parts.join(" | ");
+    // Hard cap at 200 tokens (800 chars)
+    const maxChars = 200 * 4;
+    const result = compact.length > maxChars ? compact.slice(0, maxChars) : compact;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.wake_packet_compact_rendered",
+        message: `compact wake packet: ${estimateTokens(result)} tokens`,
+        meta: { tokens: estimateTokens(result) },
+    });
+    return result;
+}

package/dist/mind/episodes.js

@@ -0,0 +1,116 @@
+"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.emitEpisode = emitEpisode;
+exports.readRecentEpisodes = readRecentEpisodes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function episodesDir(agentRoot) {
+    return path.join(agentRoot, "state", "episodes");
+}
+function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return `ep-${timestamp}-${random}`;
+}
+function emitEpisode(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = generateId();
+    const episode = {
+        id,
+        timestamp: now,
+        kind: input.kind,
+        summary: input.summary,
+        whyItMattered: input.whyItMattered,
+        relatedEntities: input.relatedEntities,
+        salience: input.salience,
+        ...(input.meta ? { meta: input.meta } : {}),
+    };
+    const dir = episodesDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(episode, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.episode_emitted",
+        message: `episode emitted: ${input.kind}`,
+        meta: {
+            episodeId: id,
+            kind: input.kind,
+            salience: input.salience,
+        },
+    });
+    return episode;
+}
+function readRecentEpisodes(agentRoot, options) {
+    const dir = episodesDir(agentRoot);
+    if (!fs.existsSync(dir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.episodes_read",
+            message: "read episodes: directory missing, returning empty",
+            meta: { count: 0 },
+        });
+        return [];
+    }
+    const limit = options?.limit ?? 50;
+    const since = options?.since;
+    const kinds = options?.kinds;
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const episodes = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const episode = JSON.parse(content);
+            if (since && episode.timestamp < since)
+                continue;
+            if (kinds && !kinds.includes(episode.kind))
+                continue;
+            episodes.push(episode);
+        }
+        catch {
+            // Skip malformed JSON files gracefully
+        }
+    }
+    episodes.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    const result = episodes.slice(0, limit);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.episodes_read",
+        message: `read ${result.length} recent episodes`,
+        meta: { count: result.length, total: episodes.length, limit },
+    });
+    return result;
+}

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