@ouro.bot/cli 0.1.0-alpha.611 → 0.1.0-alpha.612

package/changelog.json

@@ -1,6 +1,16 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.612",
+      "changes": [
+        "Drop the session archive and route durable history lookup through notes.",
+        "`query_session` keeps `mode=search` parseable during the deprecation cycle, but now returns a structured deprecation stub pointing agents to `search_notes` or `consult_notes`; the search mode is targeted for removal in alpha.616.",
+        "Session `.archive.ndjson` files are no longer written or read. Existing files under `~/AgentBundles/<agent>.ouro/state/sessions/**/*.archive.ndjson` are operationally inert and safe to delete with `rm`; the harness deliberately does not provide a built-in delete command now that archive pressure is gone and pruning is unnecessary, though an optional `ouro session archive prune` follow-up may land later if user demand emerges.",
+        "Canonical notes now have self-trust-only `note` and `consult_notes` tools backed by a rebuildable `notes/.index.json` version 1 semantic index derived from markdown notes.",
+        "Wire `daemon.sense_revive` through the live sense manager so `revive_sense({ sense: \"bluebubbles\" })` can recover BlueBubbles in the actual daemon topology."
+      ]
+    },
     {
       "version": "0.1.0-alpha.611",
       "changes": [

package/dist/arc/cares.js

@@ -39,6 +39,7 @@ exports.readActiveCares = readActiveCares;
 exports.updateCare = updateCare;
 exports.resolveCare = resolveCare;
 const path = __importStar(require("path"));
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const json_store_1 = require("./json-store");
 function caresDir(agentRoot) {
@@ -49,8 +50,8 @@ function createCare(agentRoot, input) {
     const id = (0, json_store_1.generateTimestampId)("care");
     const care = {
         id,
-        label: input.label,
-        why: input.why,
+        label: (0, session_events_1.capStructuredRecordString)(input.label),
+        why: (0, session_events_1.capStructuredRecordString)(input.why),
         kind: input.kind,
         status: input.status,
         salience: input.salience,
@@ -59,7 +60,7 @@ function createCare(agentRoot, input) {
         relatedAgentIds: input.relatedAgentIds,
         relatedObligationIds: input.relatedObligationIds,
         relatedEpisodeIds: input.relatedEpisodeIds,
-        currentRisk: input.currentRisk,
+        currentRisk: input.currentRisk === null ? null : (0, session_events_1.capStructuredRecordString)(input.currentRisk),
         nextCheckAt: input.nextCheckAt,
         createdAt: now,
         updatedAt: now,
@@ -107,6 +108,9 @@ function updateCare(agentRoot, id, updates) {
     const updated = {
         ...care,
         ...updates,
+        ...(typeof updates.label === "string" ? { label: (0, session_events_1.capStructuredRecordString)(updates.label) } : {}),
+        ...(typeof updates.why === "string" ? { why: (0, session_events_1.capStructuredRecordString)(updates.why) } : {}),
+        ...(typeof updates.currentRisk === "string" ? { currentRisk: (0, session_events_1.capStructuredRecordString)(updates.currentRisk) } : {}),
         id: care.id, // protect ID from overwrite
         createdAt: care.createdAt, // protect createdAt
         updatedAt: now,

package/dist/arc/episodes.js

@@ -37,6 +37,7 @@ exports.emitEpisode = emitEpisode;
 exports.readRecentEpisodes = readRecentEpisodes;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 function episodesDir(agentRoot) {
     return path.join(agentRoot, "arc", "episodes");
@@ -53,11 +54,11 @@ function emitEpisode(agentRoot, input) {
         id,
         timestamp: now,
         kind: input.kind,
-        summary: input.summary,
-        whyItMattered: input.whyItMattered,
+        summary: (0, session_events_1.capStructuredRecordString)(input.summary),
+        whyItMattered: (0, session_events_1.capStructuredRecordString)(input.whyItMattered),
         relatedEntities: input.relatedEntities,
         salience: input.salience,
-        ...(input.meta ? { meta: input.meta } : {}),
+        ...(input.meta ? { meta: (0, session_events_1.capStructuredRecordStringLeaves)(input.meta) } : {}),
     };
     const dir = episodesDir(agentRoot);
     fs.mkdirSync(dir, { recursive: true });

package/dist/arc/intentions.js

@@ -38,6 +38,7 @@ exports.readOpenIntentions = readOpenIntentions;
 exports.resolveIntention = resolveIntention;
 exports.dismissIntention = dismissIntention;
 const path = __importStar(require("path"));
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const json_store_1 = require("./json-store");
 function intentionsDir(agentRoot) {
@@ -58,7 +59,7 @@ function captureIntention(agentRoot, input) {
     const id = (0, json_store_1.generateTimestampId)("int");
     const intention = {
         id,
-        content: input.content,
+        content: (0, session_events_1.capStructuredRecordString)(input.content),
         status: "open",
         createdAt: now,
         updatedAt: now,

package/dist/arc/obligations.js

@@ -50,6 +50,7 @@ exports.advanceReturnObligation = advanceReturnObligation;
 exports.listActiveReturnObligations = listActiveReturnObligations;
 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) {
@@ -68,7 +69,7 @@ function createObligation(agentRoot, input) {
         id,
         origin: input.origin,
         ...(input.bridgeId ? { bridgeId: input.bridgeId } : {}),
-        content: input.content,
+        content: (0, session_events_1.capStructuredRecordString)(input.content),
         status: "pending",
         createdAt: now,
         updatedAt: now,
@@ -110,13 +111,13 @@ function advanceObligation(agentRoot, obligationId, update) {
         obligation.currentSurface = update.currentSurface;
     }
     if (typeof update.currentArtifact === "string") {
-        obligation.currentArtifact = update.currentArtifact;
+        obligation.currentArtifact = (0, session_events_1.capStructuredRecordString)(update.currentArtifact);
     }
     if (typeof update.nextAction === "string") {
-        obligation.nextAction = update.nextAction;
+        obligation.nextAction = (0, session_events_1.capStructuredRecordString)(update.nextAction);
     }
     if (typeof update.latestNote === "string") {
-        obligation.latestNote = update.latestNote;
+        obligation.latestNote = (0, session_events_1.capStructuredRecordString)(update.latestNote);
     }
     obligation.updatedAt = new Date().toISOString();
     (0, json_store_1.writeJsonFile)(dir, obligationId, obligation);
@@ -165,7 +166,14 @@ function enrichObligation(agentRoot, id, meaning) {
         throw new Error(`Obligation not found: ${id}`);
     }
     const obligation = existing;
-    obligation.meaning = meaning;
+    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)({
@@ -188,7 +196,11 @@ function getReturnObligationsDir(agentName) {
 }
 function createReturnObligation(agentName, obligation) {
     const dir = getReturnObligationsDir(agentName);
-    (0, json_store_1.writeJsonFile)(dir, obligation.id, obligation);
+    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",

package/dist/arc/packets.js

@@ -41,6 +41,7 @@ exports.revisePonderPacket = revisePonderPacket;
 exports.advancePonderPacket = advancePonderPacket;
 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");
@@ -92,14 +93,14 @@ function createPonderPacket(agentRoot, input) {
         kind: input.kind,
         sop: packetSop(input.kind),
         status: "drafting",
-        objective: input.objective,
-        summary: input.summary,
-        successCriteria: input.successCriteria,
+        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: input.payload,
+        payload: (0, session_events_1.capStructuredRecordStringLeaves)(input.payload),
         createdAt: now,
         updatedAt: now,
     };
@@ -124,10 +125,10 @@ function revisePonderPacket(agentRoot, packetId, input) {
         ...existing,
         kind: input.kind,
         sop: packetSop(input.kind),
-        objective: input.objective,
-        summary: input.summary,
-        successCriteria: input.successCriteria,
-        payload: input.payload,
+        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);

package/dist/heart/awaiting/await-runtime-state.js

@@ -39,6 +39,7 @@ exports.writeAwaitRuntimeState = writeAwaitRuntimeState;
 exports.recordAwaitCheck = recordAwaitCheck;
 const path = __importStar(require("path"));
 const json_store_1 = require("../../arc/json-store");
+const session_events_1 = require("../session-events");
 const runtime_1 = require("../../nerves/runtime");
 function awaitRuntimeStateDir(agentRoot) {
     return path.join(agentRoot, "state", "awaits");
@@ -67,7 +68,9 @@ function writeAwaitRuntimeState(agentRoot, name, partial) {
     const existing = readAwaitRuntimeState(agentRoot, name);
     const merged = {
         last_checked: partial.last_checked ?? existing?.last_checked ?? null,
-        last_observation: partial.last_observation ?? existing?.last_observation ?? null,
+        last_observation: partial.last_observation != null
+            ? (0, session_events_1.capStructuredRecordString)(partial.last_observation)
+            : existing?.last_observation ?? null,
         checked_count: partial.checked_count ?? existing?.checked_count ?? 0,
     };
     const record = {

package/dist/heart/bridges/store.js

@@ -38,6 +38,7 @@ exports.createBridgeStore = createBridgeStore;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
+const session_events_1 = require("../session-events");
 const runtime_1 = require("../../nerves/runtime");
 function sessionIdentityMatches(session, candidate) {
     return (session.friendId === candidate.friendId
@@ -58,7 +59,18 @@ function createBridgeStore(options = {}) {
     return {
         save(bridge) {
             ensureRoot();
-            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(bridge, null, 2), "utf-8");
+            const cappedBridge = {
+                ...bridge,
+                objective: (0, session_events_1.capStructuredRecordString)(bridge.objective),
+                summary: (0, session_events_1.capStructuredRecordString)(bridge.summary),
+                attachedSessions: bridge.attachedSessions.map((session) => ({
+                    ...session,
+                    snapshot: typeof session.snapshot === "string"
+                        ? (0, session_events_1.capStructuredRecordString)(session.snapshot)
+                        : session.snapshot,
+                })),
+            };
+            fs.writeFileSync(bridgeFilePath(rootDir, bridge.id), JSON.stringify(cappedBridge, null, 2), "utf-8");
             (0, runtime_1.emitNervesEvent)({
                 component: "engine",
                 event: "engine.bridge_store_save",
@@ -68,7 +80,7 @@ function createBridgeStore(options = {}) {
                     rootDir,
                 },
             });
-            return bridge;
+            return cappedBridge;
         },
         get(id) {
             const filePath = bridgeFilePath(rootDir, id);

package/dist/heart/daemon/daemon.js

@@ -449,6 +449,11 @@ function parseIncomingCommand(raw) {
     }
     return parsed;
 }
+function isValidSenseReviveCommand(command) {
+    return typeof command.agent === "string"
+        && typeof command.sense === "string"
+        && typeof command.reason === "string";
+}
 /**
  * Handle agent.senseTurn command: runs a full agent turn via the daemon process.
  * Dynamic import lazy-loads shared-turn. Hot-reload works because ouro dev
@@ -1114,6 +1119,48 @@ class OuroDaemon {
                     message: "log streaming available via ouro logs",
                     data: { logDir: "~/AgentBundles/<agent>.ouro/state/daemon/logs" },
                 };
+            case "daemon.sense_revive": {
+                if (!isValidSenseReviveCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid daemon.sense_revive payload: expected string fields 'agent', 'sense', and 'reason'.",
+                    };
+                }
+                const revivedSenseRow = await this.senseManager?.reviveSense?.(command.agent, command.sense);
+                if (revivedSenseRow) {
+                    return {
+                        ok: true,
+                        message: `revived ${command.agent}/${command.sense}`,
+                        data: revivedSenseRow,
+                    };
+                }
+                const managedSenseSnapshots = this.processManager.listAgentSnapshots()
+                    .filter((snapshot) => snapshot.name.startsWith(`${command.agent}:`));
+                if (managedSenseSnapshots.length === 0) {
+                    return {
+                        ok: false,
+                        error: `No managed agent '${command.agent}' is registered with daemon-managed senses.`,
+                    };
+                }
+                const exactTargetName = `${command.agent}:${command.sense}`;
+                const target = managedSenseSnapshots.find((snapshot) => snapshot.name === exactTargetName)
+                    ?? managedSenseSnapshots.find((snapshot) => snapshot.channel === command.sense);
+                if (!target) {
+                    return {
+                        ok: false,
+                        error: `No managed sense '${command.sense}' is registered for agent '${command.agent}'.`,
+                    };
+                }
+                this.processManager.resetAgentFailureState(target.name);
+                await this.processManager.startAgent(target.name);
+                const freshSnapshot = this.processManager.listAgentSnapshots()
+                    .find((snapshot) => snapshot.name === target.name) ?? target;
+                return {
+                    ok: true,
+                    message: `revived ${command.agent}/${command.sense}`,
+                    data: freshSnapshot,
+                };
+            }
             case "agent.start":
                 await this.processManager.startAgent(command.agent);
                 return { ok: true, message: `started ${command.agent}` };

package/dist/heart/daemon/process-manager.js

@@ -502,6 +502,19 @@ class DaemonProcessManager {
             await this.stopAgent(state.config.name);
         }
     }
+    resetAgentFailureState(agent) {
+        const state = this.requireAgent(agent);
+        this.clearRestartTimer(state);
+        this.clearCooldownTimer(state);
+        state.cooldownRetryCount = 0;
+        state.crashTimestamps = [];
+        state.fastCrashCount = 0;
+        state.respawnLoopTripped = false;
+        state.orchestratedRestartTimestamps = [];
+        state.snapshot.errorReason = null;
+        state.snapshot.fixHint = null;
+        this.notifySnapshotChange(state.snapshot);
+    }
     sendToAgent(agent, message) {
         const state = this.requireAgent(agent);
         if (!state.process)

package/dist/heart/daemon/sense-manager.js

@@ -667,6 +667,18 @@ class DaemonSenseManager {
         }
         await this.processManager.startAgent?.(managedName);
     }
+    async reviveSense(agent, sense) {
+        const parsed = parseSenseSnapshotName(`${agent}:${sense}`);
+        if (!parsed)
+            return null;
+        const context = this.contexts.get(parsed.agent);
+        if (!context || !context.senses[parsed.sense].enabled)
+            return null;
+        const managedName = `${parsed.agent}:${parsed.sense}`;
+        this.processManager.resetAgentFailureState?.(managedName);
+        await this.processManager.startAgent?.(managedName);
+        return this.listSenseRows().find((row) => row.agent === parsed.agent && row.sense === parsed.sense) ?? null;
+    }
     listSenseRows() {
         const runtime = new Map();
         for (const snapshot of this.processManager.listAgentSnapshots()) {

package/dist/heart/mailbox/readers/runtime-readers.js

@@ -53,6 +53,7 @@ const daemon_health_1 = require("../../daemon/daemon-health");
 const shared_1 = require("./shared");
 const agent_machine_1 = require("./agent-machine");
 const sessions_1 = require("./sessions");
+const NOTES_VIEW_LIMIT = 20;
 /* v8 ignore start — defensive parsing of on-disk JSON, fallback branches are safety nets */
 function readCodingDeep(agentRoot) {
     const stateFilePath = path.join(agentRoot, "state", "coding", "sessions.json");
@@ -376,13 +377,117 @@ function readNotesView(agentRoot) {
         // no journal index
     }
     journalEntries.sort((a, b) => b.mtime - a.mtime);
+    const canonicalNotes = readCanonicalNotes(agentRoot);
     return {
         diaryEntryCount: diaryEntries.length,
-        recentDiaryEntries: diaryEntries.slice(0, 20),
+        recentDiaryEntries: diaryEntries.slice(0, NOTES_VIEW_LIMIT),
         journalEntryCount: journalEntries.length,
-        recentJournalEntries: journalEntries.slice(0, 20),
+        recentJournalEntries: journalEntries.slice(0, NOTES_VIEW_LIMIT),
+        canonicalNoteCount: canonicalNotes.length,
+        recentCanonicalNotes: canonicalNotes.slice(0, NOTES_VIEW_LIMIT),
     };
 }
+function readCanonicalNotes(agentRoot) {
+    const notesRoot = path.join(agentRoot, "notes");
+    const notes = [];
+    for (const filename of (0, shared_1.safeReaddir)(notesRoot)) {
+        if (!filename.endsWith(".md"))
+            continue;
+        const filePath = path.join(notesRoot, filename);
+        if ((0, shared_1.safeIsDirectory)(filePath))
+            continue;
+        try {
+            const raw = fs.readFileSync(filePath, "utf-8");
+            const { frontmatter, body } = parseMarkdownFrontmatter(raw);
+            const writtenAt = safeCanonicalNoteTimestamp(frontmatter.created_at, filePath);
+            notes.push({
+                filename,
+                title: firstMarkdownHeading(body) ?? titleFromFilename(filename),
+                tags: Array.isArray(frontmatter.tags) ? frontmatter.tags : [],
+                preview: body.slice(0, 200),
+                writtenAt,
+            });
+        }
+        catch {
+            // skip unreadable notes
+        }
+    }
+    notes.sort((a, b) => b.writtenAt.localeCompare(a.writtenAt) || b.filename.localeCompare(a.filename));
+    return notes;
+}
+function safeCanonicalNoteTimestamp(value, filePath) {
+    const fallback = (0, shared_1.safeFileMtime)(filePath);
+    if (typeof value !== "string")
+        return fallback;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return fallback;
+    return Number.isNaN(new Date(trimmed).getTime()) ? fallback : trimmed;
+}
+function parseMarkdownFrontmatter(raw) {
+    const lines = raw.split(/\r?\n/);
+    if (lines[0] !== "---")
+        return { frontmatter: {}, body: raw };
+    const endIndex = lines.findIndex((line, index) => index > 0 && line === "---");
+    if (endIndex === -1)
+        return { frontmatter: {}, body: raw };
+    return {
+        frontmatter: parseMinimalFrontmatter(lines.slice(1, endIndex)),
+        body: lines.slice(endIndex + 1).join("\n").replace(/^\n/, ""),
+    };
+}
+function parseMinimalFrontmatter(lines) {
+    const frontmatter = {};
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const match = line?.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        const key = match[1];
+        const rawValue = match[2];
+        if (key === "tags") {
+            frontmatter.tags = parseFrontmatterTags(rawValue, lines, index + 1);
+            continue;
+        }
+        frontmatter[key] = rawValue.trim();
+    }
+    return frontmatter;
+}
+function parseFrontmatterTags(rawValue, lines, startIndex) {
+    const trimmed = rawValue.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return parsed.filter((item) => typeof item === "string");
+        }
+        catch {
+            return trimmed.slice(1, -1).split(",").map((tag) => tag.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+        }
+    }
+    if (trimmed.length > 0)
+        return [trimmed];
+    const tags = [];
+    for (let index = startIndex; index < lines.length; index += 1) {
+        const itemMatch = lines[index]?.match(/^\s*-\s*(.+)$/);
+        if (!itemMatch)
+            break;
+        const tag = itemMatch[1].trim().replace(/^['"]|['"]$/g, "");
+        if (tag)
+            tags.push(tag);
+    }
+    return tags;
+}
+function firstMarkdownHeading(body) {
+    const heading = body
+        .split(/\r?\n/)
+        .map((line) => line.match(/^#\s+(.+)$/)?.[1]?.trim())
+        .find((title) => title && title.length > 0);
+    return heading ?? null;
+}
+function titleFromFilename(filename) {
+    const stem = filename.replace(/\.md$/i, "").replace(/^\d{4}-\d{2}-\d{2}-/, "");
+    return stem.replace(/[-_]+/g, " ").trim() || filename;
+}
 function readFriendView(agentName, options = {}) {
     const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);

package/dist/heart/mailbox/readers/sessions.js

@@ -213,8 +213,7 @@ function readSessionTranscript(agentName, friendId, channel, key, options = {})
     const envelope = (0, shared_1.readSessionEnvelope)(sessionPath);
     if (!envelope)
         return null;
-    // Use full event history (envelope + archive) for complete transcript
-    const rawMessages = (0, session_events_1.loadFullEventHistory)(sessionPath);
+    const rawMessages = envelope.events;
     const friendsDir = path.join(agentRoot, "friends");
     const friendName = (0, shared_1.resolveFriendName)(friendsDir, friendId);
     const messages = rawMessages;
@@ -225,6 +224,7 @@ function readSessionTranscript(agentName, friendId, channel, key, options = {})
         key,
         sessionPath,
         messageCount: messages.length,
+        truncatedHistory: envelope.projection.trimmed,
         lastUsage: parseSessionUsage(envelope.lastUsage),
         continuity: parseSessionContinuity(envelope.state),
         messages,