@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

package/dist/mind/{associative-recall.js → note-search.js}

@@ -34,60 +34,43 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosineSimilarity = cosineSimilarity;
-exports.recallFactsForQuery = recallFactsForQuery;
-exports.injectAssociativeRecall = injectAssociativeRecall;
+exports.searchDiaryFactsForQuery = searchDiaryFactsForQuery;
+exports.injectNoteSearchContext = injectNoteSearchContext;
 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 DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+const diary_1 = require("./diary");
+const provenance_trust_1 = require("./provenance-trust");
+const embedding_provider_1 = require("./embedding-provider");
 const DEFAULT_MIN_SCORE = 0.5;
 const DEFAULT_TOP_K = 3;
-class OpenAIEmbeddingProvider {
-    apiKey;
-    model;
-    constructor(apiKey, model = DEFAULT_EMBEDDING_MODEL) {
-        this.apiKey = apiKey;
-        this.model = model;
-    }
-    async embed(texts) {
-        const response = await fetch("https://api.openai.com/v1/embeddings", {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                model: this.model,
-                input: texts,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`embedding request failed: ${response.status} ${response.statusText}`);
-        }
-        const payload = (await response.json());
-        if (!payload.data || payload.data.length !== texts.length) {
-            throw new Error("embedding response missing expected vectors");
-        }
-        return payload.data.map((entry) => entry.embedding);
-    }
-}
 function createDefaultProvider() {
-    const apiKey = (0, config_1.getOpenAIEmbeddingsApiKey)();
-    if (!apiKey) {
+    const provider = (0, embedding_provider_1.createDefaultEmbeddingProvider)();
+    if (!provider) {
         throw new Error("openaiEmbeddingsApiKey not configured");
     }
-    return new OpenAIEmbeddingProvider(apiKey);
+    return provider;
 }
-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--) {
@@ -117,7 +100,7 @@ function cosineSimilarity(left, right) {
         return 0;
     return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
 }
-async function recallFactsForQuery(query, facts, provider, options) {
+async function searchDiaryFactsForQuery(query, facts, provider, options) {
     const trimmed = query.trim();
     if (!trimmed)
         return [];
@@ -133,64 +116,82 @@ async function recallFactsForQuery(query, facts, provider, options) {
         .sort((left, right) => right.score - left.score)
         .slice(0, topK);
 }
-async function injectAssociativeRecall(messages, options) {
+async function injectNoteSearchContext(messages, options) {
     try {
         if (messages[0]?.role !== "system" || typeof messages[0].content !== "string")
             return;
         const query = getLatestUserText(messages);
         if (!query)
             return;
-        const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
-        const facts = readFacts(memoryRoot);
+        const diaryRoot = options?.diaryRoot ?? (0, diary_1.resolveDiaryRoot)();
+        const facts = readFacts(diaryRoot);
         if (facts.length === 0)
             return;
-        let recalled;
+        const resultLines = [];
+        let found;
         try {
             const provider = options?.provider ?? createDefaultProvider();
-            recalled = await recallFactsForQuery(query, facts, provider, options);
+            found = await searchDiaryFactsForQuery(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
+            found = facts
                 .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
                 .slice(0, topK)
                 .map((fact) => ({ ...fact, score: 1 }));
-            if (recalled.length > 0) {
+            if (found.length > 0) {
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
                     component: "mind",
-                    event: "mind.associative_recall_fallback",
+                    event: "mind.note_search_fallback",
                     message: "embeddings unavailable, used substring fallback",
-                    meta: { matchCount: recalled.length },
+                    meta: { matchCount: found.length },
                 });
             }
         }
-        if (recalled.length === 0)
+        for (const fact of found) {
+            let meta = `score=${fact.score.toFixed(3)} source=${fact.source}`;
+            if (fact.provenance) {
+                if (fact.provenance.channel)
+                    meta += ` channel=${fact.provenance.channel}`;
+                if (fact.provenance.friendName)
+                    meta += ` friend=${fact.provenance.friendName}`;
+                if (fact.provenance.trust)
+                    meta += ` trust=${fact.provenance.trust}`;
+            }
+            const tag = (0, provenance_trust_1.classifyProvenanceTrust)(fact.provenance) === "external" ? "diary/external" : "diary";
+            resultLines.push({
+                text: `[${tag}] ${fact.text} [${meta}]`,
+                score: fact.score,
+            });
+        }
+        if (resultLines.length === 0)
             return;
-        const recallSection = recalled
-            .map((fact, index) => `${index + 1}. ${fact.text} [score=${fact.score.toFixed(3)} source=${fact.source}]`)
+        resultLines.sort((left, right) => right.score - left.score);
+        const noteSection = resultLines
+            .map((entry, index) => `${index + 1}. ${entry.text}`)
             .join("\n");
         messages[0] = {
             role: "system",
-            content: `${messages[0].content}\n\n## recalled context\n${recallSection}`,
+            content: `${messages[0].content}\n\n## retrieved from my Desk record diary\n${noteSection}`,
         };
         (0, runtime_1.emitNervesEvent)({
             component: "mind",
-            event: "mind.associative_recall",
-            message: "associative recall injected",
-            meta: { count: recalled.length },
+            event: "mind.note_search_context",
+            message: "note search injected",
+            meta: { count: resultLines.length },
         });
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "mind",
-            event: "mind.associative_recall_error",
-            message: "associative recall failed",
+            event: "mind.note_search_context_error",
+            message: "note search 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/obligation-steering.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findActivePersistentObligation = findActivePersistentObligation;
+exports.findStatusObligation = findStatusObligation;
+exports.renderActiveObligationSteering = renderActiveObligationSteering;
+exports.renderConcreteStatusGuidance = renderConcreteStatusGuidance;
+exports.renderLiveThreadStatusShape = renderLiveThreadStatusShape;
+exports.buildExactStatusReply = buildExactStatusReply;
+exports.renderExactStatusReplyContract = renderExactStatusReplyContract;
+const config_1 = require("../heart/config");
+const active_work_1 = require("../heart/active-work");
+const runtime_1 = require("../nerves/runtime");
+const orientation_frame_1 = require("../heart/orientation-frame");
+function labelSteeringSurface(surface, options) {
+    return typeof options?.resumePriorWork === "boolean"
+        ? (0, orientation_frame_1.labelPriorWorkSurface)(surface, options.resumePriorWork)
+        : surface;
+}
+function findActivePersistentObligation(frame) {
+    if (!frame)
+        return null;
+    return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled") ?? null;
+}
+function obligationTimestampMs(obligation) {
+    return Date.parse(obligation.updatedAt ?? obligation.createdAt);
+}
+function newestObligationFirst(left, right) {
+    return obligationTimestampMs(right) - obligationTimestampMs(left);
+}
+function matchesCurrentSession(frame, obligation) {
+    return matchesSessionOrigin(frame, obligation.origin);
+}
+function matchesSessionOrigin(frame, origin) {
+    return Boolean(frame.currentSession
+        && origin.friendId === frame.currentSession.friendId
+        && origin.channel === frame.currentSession.channel
+        && (0, config_1.sanitizeKey)(origin.key) === (0, config_1.sanitizeKey)(frame.currentSession.key));
+}
+function findStatusObligation(frame) {
+    if (!frame)
+        return null;
+    const openObligations = [...(frame.pendingObligations ?? [])]
+        .filter((obligation) => obligation.status !== "fulfilled")
+        .sort(newestObligationFirst);
+    const sameSession = openObligations.find((obligation) => matchesCurrentSession(frame, obligation));
+    if (sameSession)
+        return sameSession;
+    return openObligations[0] ?? null;
+}
+function findCurrentSessionStatusObligation(frame) {
+    const openObligations = [...(frame.pendingObligations ?? [])]
+        .filter((obligation) => obligation.status !== "fulfilled")
+        .sort(newestObligationFirst);
+    return openObligations.find((obligation) => matchesCurrentSession(frame, obligation)) ?? null;
+}
+function renderActiveObligationSteering(obligation, options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.obligation_steering_rendered",
+        message: "rendered active obligation steering",
+        meta: {
+            hasObligation: Boolean(obligation),
+            hasSurface: Boolean(obligation?.currentSurface?.label),
+        },
+    });
+    if (!obligation)
+        return "";
+    const name = obligation.origin.friendId;
+    const surfaceLine = obligation.currentSurface?.label
+        ? `\nright now that work is happening in ${obligation.currentSurface.label}.`
+        : "";
+    return labelSteeringSurface(`## where my attention is
+i'm already working on something i owe ${name}.${surfaceLine}
+
+i should close that loop before i act like this is a fresh blank turn.`, options);
+}
+function mergeArtifactFallback(obligation) {
+    const trimmed = obligation.content.trim();
+    if (!trimmed)
+        return "the fix";
+    const stripped = trimmed.replace(/^merge(?:\s+|$)/i, "").trim();
+    return stripped || "the fix";
+}
+function formatMergeArtifact(obligation) {
+    const currentArtifact = obligation.currentArtifact?.trim();
+    if (currentArtifact)
+        return currentArtifact;
+    if (obligation.currentSurface?.kind === "merge") {
+        const surfaceLabel = obligation.currentSurface.label.trim();
+        if (surfaceLabel)
+            return surfaceLabel;
+    }
+    return mergeArtifactFallback(obligation);
+}
+function formatActiveLane(frame, obligation) {
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession) {
+        const sameThread = frame.currentSession
+            && liveCodingSession.originSession
+            && liveCodingSession.originSession.friendId === frame.currentSession.friendId
+            && liveCodingSession.originSession.channel === frame.currentSession.channel
+            && liveCodingSession.originSession.key === frame.currentSession.key;
+        return sameThread
+            ? `${liveCodingSession.runner} ${liveCodingSession.id} for this same thread`
+            : liveCodingSession.originSession
+                ? `${liveCodingSession.runner} ${liveCodingSession.id} for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
+                : `${liveCodingSession.runner} ${liveCodingSession.id}`;
+    }
+    return obligation.currentSurface?.label
+        || (matchesCurrentSession(frame, obligation) ? "this same thread" : "this live loop");
+}
+function formatCurrentArtifact(frame, obligation) {
+    if (obligation?.currentArtifact)
+        return obligation.currentArtifact;
+    if (obligation?.currentSurface?.kind === "merge")
+        return obligation.currentSurface.label;
+    if ((frame.codingSessions ?? []).length > 0)
+        return "no PR or merge artifact yet";
+    return obligation ? "no artifact yet" : "";
+}
+function formatNextAction(frame, obligation) {
+    const obligationHasConcreteArtifact = Boolean(obligation?.currentArtifact?.trim())
+        || obligation?.currentSurface?.kind === "merge";
+    if (obligation?.status === "waiting_for_merge") {
+        return obligation.nextAction?.trim() || `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
+    }
+    if (obligation?.status === "updating_runtime") {
+        return obligation.nextAction?.trim() || "update runtime, verify version/changelog, then re-observe";
+    }
+    if (obligationHasConcreteArtifact && obligation?.nextAction?.trim()) {
+        return obligation.nextAction.trim();
+    }
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession?.status === "waiting_input") {
+        return `answer ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
+    }
+    if (liveCodingSession?.status === "stalled") {
+        return `unstick ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
+    }
+    if (liveCodingSession) {
+        return "finish the coding pass and bring the result back here";
+    }
+    if (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
+    if (obligation?.content?.trim()) {
+        return `work on "${obligation.content.trim()}" and bring back a concrete artifact`;
+    }
+    return obligation ? "continue the active loop and bring the result back here" : "";
+}
+function renderConcreteStatusGuidance(frame, obligation, options) {
+    const activeLane = obligation ? formatActiveLane(frame, obligation) : "";
+    const currentArtifact = formatCurrentArtifact(frame, obligation);
+    const nextAction = formatNextAction(frame, obligation);
+    const liveConversation = frame.currentSession
+        ? `${frame.currentSession.channel}/${frame.currentSession.key}`
+        : "";
+    if (!activeLane && !currentArtifact && !nextAction)
+        return "";
+    return labelSteeringSurface(`if someone asks what i'm doing or for status mid-task, i answer from these live facts instead of copying a canned block.
+the live conversation is ${liveConversation || "not in a live conversation"}.
+the active lane is ${activeLane}.
+the current artifact is ${currentArtifact}.
+if i just finished or verified something concrete in this live lane, i name that as the latest checkpoint.
+the next action is ${nextAction}.
+
+i answer naturally from those facts instead of forcing a canned status block.`, options);
+}
+function renderLiveThreadStatusShape(frame, options) {
+    if (!frame.currentSession)
+        return "";
+    return labelSteeringSurface(`if someone asks what i'm doing or for status mid-task in this live thread, i answer in these exact lines, in order, with no intro paragraph:
+live conversation: ${frame.currentSession.channel}/${frame.currentSession.key}
+active lane: this same thread
+current artifact: <actual artifact or "no artifact yet">
+latest checkpoint: <freshest concrete thing i just finished or verified>
+next action: <smallest concrete next step i'm taking now>
+
+no recap paragraph before those lines.
+no option list.
+present tense only.
+if a finished step matters, i label it "just finished" instead of presenting it as current work.`, options);
+}
+function buildExactStatusReply(frame, obligation, latestCheckpoint, statusCheckScope) {
+    const headerObligation = statusCheckScope === "all-sessions-family"
+        ? findCurrentSessionStatusObligation(frame)
+        : obligation;
+    const liveConversation = frame.currentSession
+        ? `${frame.currentSession.channel}/${frame.currentSession.key}`
+        : "not in a live conversation";
+    const activeLane = headerObligation
+        ? formatActiveLane(frame, headerObligation)
+        : (frame.currentSession ? "this same thread" : "this live loop");
+    const currentArtifact = formatCurrentArtifact(frame, headerObligation) || "no artifact yet";
+    const nextAction = formatNextAction(frame, headerObligation) || "continue the active loop and bring the result back here";
+    const latest = latestCheckpoint.trim() || "<freshest concrete thing i just finished or verified>";
+    const lines = [
+        `live conversation: ${liveConversation}`,
+        `active lane: ${activeLane}`,
+        `current artifact: ${currentArtifact}`,
+        `latest checkpoint: ${latest}`,
+        `next action: ${nextAction}`,
+    ];
+    if (statusCheckScope === "all-sessions-family") {
+        lines.push("other active sessions:");
+        const summaries = (0, active_work_1.formatOtherActiveSessionSummaries)(frame);
+        lines.push(...(summaries.length > 0 ? summaries : ["- none"]));
+    }
+    return lines.join("\n");
+}
+function renderExactStatusReplyContract(frame, obligation, statusCheckScope) {
+    const headerObligation = statusCheckScope === "all-sessions-family"
+        ? findCurrentSessionStatusObligation(frame)
+        : obligation;
+    if (statusCheckScope === "all-sessions-family") {
+        return `reply using exactly this status shape and nothing else:
+live conversation: ${frame.currentSession ? `${frame.currentSession.channel}/${frame.currentSession.key}` : "not in a live conversation"}
+active lane: ${headerObligation ? formatActiveLane(frame, headerObligation) : (frame.currentSession ? "this same thread" : "this live loop")}
+current artifact: ${formatCurrentArtifact(frame, headerObligation) || "no artifact yet"}
+latest checkpoint: <freshest concrete thing i just finished or verified>
+next action: ${formatNextAction(frame, headerObligation) || "continue the active loop and bring the result back here"}
+other active sessions:
+- <session label>: <what i'm doing there right now>`;
+    }
+    return `reply using exactly these five lines and nothing else:
+${buildExactStatusReply(frame, obligation, "<freshest concrete thing i just finished or verified>")}
+`;
+}

package/dist/mind/pending.js

@@ -33,24 +33,86 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIVATE_RUNTIME_PENDING = void 0;
 exports.getPendingDir = getPendingDir;
+exports.getDeferredReturnDir = getDeferredReturnDir;
+exports.getPrivateRuntimePendingDir = getPrivateRuntimePendingDir;
+exports.hasPendingMessages = hasPendingMessages;
+exports.queuePendingMessage = queuePendingMessage;
+exports.queuePendingMessageOnce = queuePendingMessageOnce;
+exports.enqueueDeferredReturn = enqueueDeferredReturn;
+exports.drainDeferredReturns = drainDeferredReturns;
 exports.drainPending = drainPending;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const node_crypto_1 = require("node:crypto");
+const identity_1 = require("../heart/identity");
+const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 function getPendingDir(agentName, friendId, channel, key) {
-    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending", friendId, channel, key);
 }
-function drainPending(pendingDir) {
+function getDeferredReturnDir(agentName, friendId) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "pending-returns", friendId);
+}
+/** Canonical private-runtime pending path segments. The path is historical durable state. */
+exports.PRIVATE_RUNTIME_PENDING = { friendId: "self", channel: "inner", key: "dialog" };
+/** Returns the pending dir for this agent's private runtime. */
+function getPrivateRuntimePendingDir(agentName) {
+    return getPendingDir(agentName, exports.PRIVATE_RUNTIME_PENDING.friendId, exports.PRIVATE_RUNTIME_PENDING.channel, exports.PRIVATE_RUNTIME_PENDING.key);
+}
+function hasPendingMessages(pendingDir) {
     if (!fs.existsSync(pendingDir))
-        return [];
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some((entry) => entry.endsWith(".json") || entry.endsWith(".json.processing"));
+    }
+    catch {
+        return false;
+    }
+}
+function writeQueueFile(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify({ ...message, content: (0, session_events_1.capStructuredRecordString)(message.content) }, null, 2));
+    return filePath;
+}
+function queuePendingMessage(pendingDir, message) {
+    writeQueueFile(pendingDir, message);
+}
+function queuePendingMessageOnce(pendingDir, message) {
+    fs.mkdirSync(pendingDir, { recursive: true });
+    const identity = (0, node_crypto_1.createHash)("sha256").update(message.packetId).digest("hex");
+    const filePath = path.join(pendingDir, `${message.timestamp}-${identity}.json`);
+    const temporary = `${filePath}.tmp-${process.pid}`;
+    const content = JSON.stringify({ ...message, content: (0, session_events_1.capStructuredRecordString)(message.content) }, null, 2);
+    try {
+        fs.writeFileSync(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        try {
+            fs.renameSync(temporary, filePath);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            fs.unlinkSync(temporary);
+        }
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    return filePath;
+}
+function drainQueue(queueDir) {
+    if (!fs.existsSync(queueDir))
+        return { messages: [], recovered: 0 };
     let entries;
     try {
-        entries = fs.readdirSync(pendingDir);
+        entries = fs.readdirSync(queueDir);
     }
     catch {
-        return [];
+        return { messages: [], recovered: 0 };
     }
     // Collect both .json (new) and .processing (crash recovery)
     const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
@@ -62,9 +124,9 @@ function drainPending(pendingDir) {
     ].sort((a, b) => a.file.localeCompare(b.file));
     const messages = [];
     for (const { file, needsRename } of allFiles) {
-        const srcPath = path.join(pendingDir, file);
+        const srcPath = path.join(queueDir, file);
         const processingPath = needsRename
-            ? path.join(pendingDir, file + ".processing")
+            ? path.join(queueDir, file + ".processing")
             : srcPath;
         try {
             if (needsRename) {
@@ -83,11 +145,42 @@ function drainPending(pendingDir) {
             catch { /* ignore */ }
         }
     }
+    return {
+        messages,
+        recovered: processingFiles.length,
+    };
+}
+function enqueueDeferredReturn(agentName, friendId, message) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const filePath = writeQueueFile(queueDir, message);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_return_enqueued",
+        component: "mind",
+        message: "deferred return queued for later friend delivery",
+        meta: { friendId, queueDir },
+    });
+    return filePath;
+}
+function drainDeferredReturns(agentName, friendId) {
+    const queueDir = getDeferredReturnDir(agentName, friendId);
+    const { messages } = drainQueue(queueDir);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.deferred_returns_drained",
+        component: "mind",
+        message: "deferred friend returns drained",
+        meta: { friendId, queueDir, count: messages.length },
+    });
+    return messages;
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    const { messages, recovered } = drainQueue(pendingDir);
     (0, runtime_1.emitNervesEvent)({
         event: "mind.pending_drained",
         component: "mind",
         message: "pending queue drained",
-        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+        meta: { pendingDir, count: messages.length, recovered },
     });
     return messages;
 }

package/dist/mind/phrases.js

@@ -16,6 +16,7 @@ function getPhrases() {
         message: "loading phrase pools",
         meta: {},
     });
+    (0, identity_1.resetAgentConfigCache)();
     const phrases = (0, identity_1.loadAgentConfig)().phrases;
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",