@ouro.bot/cli 0.1.0-alpha.14 → 0.1.0-alpha.140

package/dist/heart/tool-loop.js

@@ -0,0 +1,198 @@
+"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.GLOBAL_CIRCUIT_BREAKER_LIMIT = exports.PING_PONG_WINDOW = exports.GENERIC_REPEAT_LIMIT = exports.POLL_NO_PROGRESS_LIMIT = exports.TOOL_LOOP_HISTORY_LIMIT = void 0;
+exports.createToolLoopState = createToolLoopState;
+exports.recordToolOutcome = recordToolOutcome;
+exports.detectToolLoop = detectToolLoop;
+const crypto = __importStar(require("crypto"));
+const runtime_1 = require("../nerves/runtime");
+exports.TOOL_LOOP_HISTORY_LIMIT = 30;
+exports.POLL_NO_PROGRESS_LIMIT = 3;
+exports.GENERIC_REPEAT_LIMIT = 4;
+exports.PING_PONG_WINDOW = 6;
+exports.GLOBAL_CIRCUIT_BREAKER_LIMIT = 24;
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    /* v8 ignore next -- stableStringify currently receives only objects/strings from normalized loop inputs @preserve */
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function digest(value) {
+    return crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function normalizeArgs(toolName, args) {
+    if (toolName === "query_active_work") {
+        return { toolName };
+    }
+    if (toolName === "coding_status" || toolName === "coding_tail") {
+        return {
+            toolName,
+            sessionId: args.sessionId ?? "",
+        };
+    }
+    if (toolName === "query_session") {
+        return {
+            toolName,
+            mode: args.mode ?? "",
+            friendId: args.friendId ?? "",
+            channel: args.channel ?? "",
+            key: args.key ?? "",
+            query: args.query ?? "",
+        };
+    }
+    return {
+        toolName,
+        args,
+    };
+}
+function normalizeOutcome(result, success) {
+    return {
+        success,
+        result: result.replace(/\s+/g, " ").trim(),
+    };
+}
+function isKnownPollTool(toolName, args) {
+    return toolName === "query_active_work"
+        || toolName === "coding_status"
+        || toolName === "coding_tail"
+        || (toolName === "query_session" && (args.mode ?? "").trim() === "status");
+}
+function emitDetection(detector, toolName, count, message, pairedToolName) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "engine",
+        event: "engine.tool_loop_detected",
+        message: "tool loop guard detected repeated non-progress work",
+        meta: {
+            detector,
+            toolName,
+            count,
+            pairedToolName: pairedToolName ?? null,
+        },
+    });
+    return {
+        stuck: true,
+        detector,
+        count,
+        message,
+        pairedToolName,
+    };
+}
+function countTrailingRepeats(history, toolName, callHash) {
+    let count = 0;
+    let outcomeHash;
+    for (let index = history.length - 1; index >= 0; index--) {
+        const record = history[index];
+        if (record.toolName !== toolName || record.callHash !== callHash) {
+            break;
+        }
+        if (!outcomeHash) {
+            outcomeHash = record.outcomeHash;
+        }
+        if (record.outcomeHash !== outcomeHash) {
+            break;
+        }
+        count += 1;
+    }
+    return { count, outcomeHash };
+}
+function detectPingPong(history, toolName, callHash) {
+    if (history.length < exports.PING_PONG_WINDOW) {
+        return { stuck: false };
+    }
+    const recent = history.slice(-exports.PING_PONG_WINDOW);
+    const first = recent[0];
+    const second = recent[1];
+    if (!first.isKnownPoll || !second.isKnownPoll) {
+        return { stuck: false };
+    }
+    if (first.toolName === second.toolName && first.callHash === second.callHash) {
+        return { stuck: false };
+    }
+    for (let index = 0; index < recent.length; index++) {
+        const expected = index % 2 === 0 ? first : second;
+        const actual = recent[index];
+        if (actual.toolName !== expected.toolName
+            || actual.callHash !== expected.callHash
+            || actual.outcomeHash !== expected.outcomeHash) {
+            return { stuck: false };
+        }
+    }
+    const matchesPair = (toolName === first.toolName && callHash === first.callHash)
+        || (toolName === second.toolName && callHash === second.callHash);
+    if (!matchesPair) {
+        return { stuck: false };
+    }
+    const pairedToolName = toolName === first.toolName ? second.toolName : first.toolName;
+    return emitDetection("ping_pong", toolName, exports.PING_PONG_WINDOW, `repeated ${first.toolName}/${second.toolName} polling is not changing. stop cycling between status checks and either act on the current state, change approach, or answer truthfully with what is known.`, pairedToolName);
+}
+function createToolLoopState() {
+    return { history: [] };
+}
+function recordToolOutcome(state, toolName, args, result, success) {
+    state.history.push({
+        toolName,
+        callHash: digest(normalizeArgs(toolName, args)),
+        outcomeHash: digest(normalizeOutcome(result, success)),
+        isKnownPoll: isKnownPollTool(toolName, args),
+    });
+    if (state.history.length > exports.TOOL_LOOP_HISTORY_LIMIT) {
+        state.history.splice(0, state.history.length - exports.TOOL_LOOP_HISTORY_LIMIT);
+    }
+}
+// Tools that must never be blocked by the circuit breaker.
+// settle = end the turn, surface = deliver results outward.
+// Blocking these traps the agent: it can think all it wants but can never speak.
+const CIRCUIT_BREAKER_EXEMPT = new Set(["settle", "surface"]);
+function detectToolLoop(state, toolName, args) {
+    if (state.history.length >= exports.GLOBAL_CIRCUIT_BREAKER_LIMIT && !CIRCUIT_BREAKER_EXEMPT.has(toolName)) {
+        return emitDetection("global_circuit_breaker", toolName, state.history.length, `this turn has already made ${state.history.length} tool calls. stop thrashing, use the current evidence, and either change approach or answer truthfully with the best grounded status.`);
+    }
+    const callHash = digest(normalizeArgs(toolName, args));
+    const trailing = countTrailingRepeats(state.history, toolName, callHash);
+    if (isKnownPollTool(toolName, args) && trailing.count >= exports.POLL_NO_PROGRESS_LIMIT) {
+        return emitDetection("known_poll_no_progress", toolName, trailing.count, `repeated ${toolName} calls have returned the same state ${trailing.count} times. stop polling and either act on the current state, wait for a meaningful change, or answer truthfully with what is known.`);
+    }
+    if (trailing.count >= exports.GENERIC_REPEAT_LIMIT) {
+        return emitDetection("generic_repeat", toolName, trailing.count, `repeating ${toolName} with the same inputs is not producing new information. change approach, use the evidence already gathered, or answer truthfully with what is known.`);
+    }
+    return detectPingPong(state.history, toolName, callHash);
+}

package/dist/heart/turn-coordinator.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTurnCoordinator = createTurnCoordinator;
+exports.withSharedTurnLock = withSharedTurnLock;
+exports.tryBeginSharedTurn = tryBeginSharedTurn;
+exports.endSharedTurn = endSharedTurn;
+exports.isSharedTurnActive = isSharedTurnActive;
+exports.enqueueSharedFollowUp = enqueueSharedFollowUp;
+exports.drainSharedFollowUps = drainSharedFollowUps;
 const runtime_1 = require("../nerves/runtime");
+function scopedKey(scope, key) {
+    return `${scope}:${key}`;
+}
 function createTurnCoordinator() {
     const turnLocks = new Map();
     const activeTurns = new Set();
@@ -60,3 +69,22 @@ function createTurnCoordinator() {
         },
     };
 }
+const _sharedTurnCoordinator = createTurnCoordinator();
+function withSharedTurnLock(scope, key, fn) {
+    return _sharedTurnCoordinator.withTurnLock(scopedKey(scope, key), fn);
+}
+function tryBeginSharedTurn(scope, key) {
+    return _sharedTurnCoordinator.tryBeginTurn(scopedKey(scope, key));
+}
+function endSharedTurn(scope, key) {
+    _sharedTurnCoordinator.endTurn(scopedKey(scope, key));
+}
+function isSharedTurnActive(scope, key) {
+    return _sharedTurnCoordinator.isTurnActive(scopedKey(scope, key));
+}
+function enqueueSharedFollowUp(scope, key, followUp) {
+    _sharedTurnCoordinator.enqueueFollowUp(scopedKey(scope, key), followUp);
+}
+function drainSharedFollowUps(scope, key) {
+    return _sharedTurnCoordinator.drainFollowUps(scopedKey(scope, key));
+}

package/dist/mind/associative-recall.js

@@ -35,12 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosineSimilarity = cosineSimilarity;
 exports.recallFactsForQuery = recallFactsForQuery;
+exports.searchJournalIndex = searchJournalIndex;
 exports.injectAssociativeRecall = injectAssociativeRecall;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
+const diary_1 = require("./diary");
 const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
 const DEFAULT_MIN_SCORE = 0.5;
 const DEFAULT_TOP_K = 3;
@@ -80,14 +81,26 @@ function createDefaultProvider() {
     }
     return new OpenAIEmbeddingProvider(apiKey);
 }
-function readFacts(memoryRoot) {
-    const factsPath = path.join(memoryRoot, "facts.jsonl");
+function readFacts(diaryRoot) {
+    const factsPath = path.join(diaryRoot, "facts.jsonl");
     if (!fs.existsSync(factsPath))
         return [];
     const raw = fs.readFileSync(factsPath, "utf8").trim();
     if (!raw)
         return [];
-    return raw.split("\n").map((line) => JSON.parse(line));
+    const facts = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            facts.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Skip corrupt lines (e.g. partial write from a crash).
+        }
+    }
+    return facts;
 }
 function getLatestUserText(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -133,6 +146,40 @@ async function recallFactsForQuery(query, facts, provider, options) {
         .sort((left, right) => right.score - left.score)
         .slice(0, topK);
 }
+function readJournalIndex(journalDir) {
+    const indexPath = path.join(journalDir, ".index.json");
+    try {
+        const raw = fs.readFileSync(indexPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+function searchJournalIndex(queryEmbedding, entries, options) {
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    return entries
+        .filter((entry) => Array.isArray(entry.embedding) && entry.embedding.length > 0)
+        .map((entry) => ({
+        filename: entry.filename,
+        preview: entry.preview,
+        score: cosineSimilarity(queryEmbedding, entry.embedding),
+    }))
+        .filter((entry) => entry.score >= minScore)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, topK);
+}
+function resolveJournalDir(diaryRoot, explicitJournalDir) {
+    if (explicitJournalDir)
+        return explicitJournalDir;
+    // journal/ is a sibling of diary/ at the agent root level
+    const agentRoot = path.dirname(diaryRoot);
+    return path.join(agentRoot, "journal");
+}
 async function injectAssociativeRecall(messages, options) {
     try {
         if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
@@ -140,37 +187,80 @@ async function injectAssociativeRecall(messages, options) {
         const query = getLatestUserText(messages);
         if (!query)
             return;
-        const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-        const facts = readFacts(memoryRoot);
-        if (facts.length === 0)
+        const diaryRoot = options?.diaryRoot ?? (0, diary_1.resolveDiaryRoot)();
+        const facts = readFacts(diaryRoot);
+        const journalDir = resolveJournalDir(diaryRoot, options?.journalDir);
+        const journalEntries = readJournalIndex(journalDir);
+        if (facts.length === 0 && journalEntries.length === 0)
             return;
-        let recalled;
-        try {
-            const provider = options?.provider ?? createDefaultProvider();
-            recalled = await recallFactsForQuery(query, facts, provider, options);
-        }
-        catch {
-            // Embeddings unavailable — fall back to substring matching
-            const lowerQuery = query.toLowerCase();
-            const topK = options?.topK ?? DEFAULT_TOP_K;
-            recalled = facts
-                .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
-                .slice(0, topK)
-                .map((fact) => ({ ...fact, score: 1 }));
-            if (recalled.length > 0) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "mind",
-                    event: "mind.associative_recall_fallback",
-                    message: "embeddings unavailable, used substring fallback",
-                    meta: { matchCount: recalled.length },
+        // Build combined result lines tagged by source
+        const resultLines = [];
+        let queryEmbedding;
+        // Search diary entries
+        if (facts.length > 0) {
+            let recalled;
+            try {
+                const provider = options?.provider ?? createDefaultProvider();
+                recalled = await recallFactsForQuery(query, facts, provider, options);
+                // Compute query embedding for journal search while provider is available
+                if (journalEntries.length > 0) {
+                    const [qe] = await provider.embed([query.trim()]);
+                    queryEmbedding = qe;
+                }
+            }
+            catch {
+                // Embeddings unavailable — fall back to substring matching
+                const lowerQuery = query.toLowerCase();
+                const topK = options?.topK ?? DEFAULT_TOP_K;
+                recalled = facts
+                    .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
+                    .slice(0, topK)
+                    .map((fact) => ({ ...fact, score: 1 }));
+                if (recalled.length > 0) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "mind",
+                        event: "mind.associative_recall_fallback",
+                        message: "embeddings unavailable, used substring fallback",
+                        meta: { matchCount: recalled.length },
+                    });
+                }
+            }
+            for (const fact of recalled) {
+                resultLines.push({
+                    text: `[diary] ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`,
+                    score: fact.score,
                 });
             }
         }
-        if (recalled.length === 0)
+        // Search journal entries (works whether diary had results or not)
+        if (journalEntries.length > 0) {
+            try {
+                if (!queryEmbedding) {
+                    const provider = options?.provider ?? createDefaultProvider();
+                    const [qe] = await provider.embed([query.trim()]);
+                    queryEmbedding = qe;
+                }
+                if (queryEmbedding) {
+                    const journalResults = searchJournalIndex(queryEmbedding, journalEntries, options);
+                    for (const entry of journalResults) {
+                        resultLines.push({
+                            text: `[journal] ${entry.filename}: ${entry.preview} [score=${entry.score.toFixed(3)}]`,
+                            score: entry.score,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Embeddings unavailable — no journal fallback
+            }
+        }
+        if (resultLines.length === 0)
             return;
-        const recallSection = recalled
-            .map((fact, index) => `${index + 1}. ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`)
+        // Sort all results by score descending
+        resultLines.sort((left, right) => right.score - left.score);
+        const recallSection = resultLines
+            .map((entry, index) => `${index + 1}. ${entry.text}`)
             .join("\n");
         messages[0] = {
             role: "system",
@@ -180,7 +270,7 @@ async function injectAssociativeRecall(messages, options) {
             component: "mind",
             event: "mind.associative_recall",
             message: "associative recall injected",
-            meta: { count: recalled.length },
+            meta: { count: resultLines.length },
         });
     }
     catch (error) {
@@ -190,7 +280,7 @@ async function injectAssociativeRecall(messages, options) {
             event: "mind.associative_recall_error",
             message: "associative recall failed",
             meta: {
-                reason: error instanceof Error ? error.message : String(error),
+                reason: error instanceof Error ? error.message : /* v8 ignore start -- defensive: non-Error catch branch @preserve */ String(error) /* v8 ignore stop */,
             },
         });
     }

package/dist/mind/bundle-manifest.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CANONICAL_BUNDLE_MANIFEST = void 0;
+exports.getChangelogPath = getChangelogPath;
 exports.getPackageVersion = getPackageVersion;
 exports.createBundleMeta = createBundleMeta;
 exports.backfillBundleMeta = backfillBundleMeta;
@@ -51,13 +52,26 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "psyche/LORE.md", kind: "file" },
     { path: "psyche/TACIT.md", kind: "file" },
     { path: "psyche/ASPIRATIONS.md", kind: "file" },
+    { path: "diary", kind: "dir" },
+    { path: "journal", kind: "dir" },
     { path: "psyche/memory", kind: "dir" },
     { path: "friends", kind: "dir" },
+    { path: "state", kind: "dir" },
     { path: "tasks", kind: "dir" },
     { path: "skills", kind: "dir" },
     { path: "senses", kind: "dir" },
     { path: "senses/teams", kind: "dir" },
 ];
+function getChangelogPath() {
+    const changelogPath = path.resolve(__dirname, "../../changelog.json");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.changelog_path_resolved",
+        message: "resolved changelog path",
+        meta: { path: changelogPath },
+    });
+    return changelogPath;
+}
 function getPackageVersion() {
     const packageJsonPath = path.resolve(__dirname, "../../package.json");
     const raw = fs.readFileSync(packageJsonPath, "utf-8");