@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/mind/memory.js

@@ -38,6 +38,7 @@ exports.ensureMemoryStorePaths = ensureMemoryStorePaths;
 exports.appendFactsWithDedup = appendFactsWithDedup;
 exports.readMemoryFacts = readMemoryFacts;
 exports.saveMemoryFact = saveMemoryFact;
+exports.backfillEmbeddings = backfillEmbeddings;
 exports.searchMemoryFacts = searchMemoryFacts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -265,6 +266,67 @@ async function saveMemoryFact(options) {
     };
     return appendFactsWithDedup(stores, [fact]);
 }
+async function backfillEmbeddings(options) {
+    const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    if (!fs.existsSync(factsPath))
+        return { total: 0, backfilled: 0, failed: 0 };
+    const facts = readExistingFacts(factsPath);
+    const needsEmbedding = facts.filter((f) => !Array.isArray(f.embedding) || f.embedding.length === 0);
+    if (needsEmbedding.length === 0)
+        return { total: facts.length, backfilled: 0, failed: 0 };
+    const provider = options?.embeddingProvider ?? createDefaultEmbeddingProvider();
+    if (!provider) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_backfill_skipped",
+            message: "embedding provider unavailable for backfill",
+            meta: { needsEmbedding: needsEmbedding.length },
+        });
+        return { total: facts.length, backfilled: 0, failed: needsEmbedding.length };
+    }
+    const batchSize = options?.batchSize ?? 50;
+    let backfilled = 0;
+    let failed = 0;
+    for (let i = 0; i < needsEmbedding.length; i += batchSize) {
+        const batch = needsEmbedding.slice(i, i + batchSize);
+        try {
+            const vectors = await provider.embed(batch.map((f) => f.text));
+            for (let j = 0; j < batch.length; j++) {
+                batch[j].embedding = vectors[j] ?? [];
+                if (batch[j].embedding.length > 0)
+                    backfilled++;
+                else
+                    failed++;
+            }
+        }
+        catch (error) {
+            failed += batch.length;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.memory_backfill_batch_error",
+                message: "embedding backfill batch failed",
+                meta: {
+                    batchStart: i,
+                    batchSize: batch.length,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    // Rewrite facts file with updated embeddings
+    const lines = facts.map((f) => JSON.stringify(f)).join("\n") + "\n";
+    fs.writeFileSync(factsPath, lines, "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.memory_backfill_complete",
+        message: "embedding backfill completed",
+        meta: { total: facts.length, backfilled, failed },
+    });
+    return { total: facts.length, backfilled, failed };
+}
 function substringMatches(queryLower, facts) {
     return facts.filter((fact) => fact.text.toLowerCase().includes(queryLower));
 }

package/dist/mind/pending.js

@@ -0,0 +1,93 @@
+"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.getPendingDir = getPendingDir;
+exports.drainPending = drainPending;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const runtime_1 = require("../nerves/runtime");
+function getPendingDir(agentName, friendId, channel, key) {
+    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir);
+    }
+    catch {
+        return [];
+    }
+    // Collect both .json (new) and .processing (crash recovery)
+    const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
+    const processingFiles = entries.filter(f => f.endsWith(".json.processing"));
+    // Sort by filename (timestamp prefix gives chronological order)
+    const allFiles = [
+        ...processingFiles.map(f => ({ file: f, needsRename: false })),
+        ...jsonFiles.map(f => ({ file: f, needsRename: true })),
+    ].sort((a, b) => a.file.localeCompare(b.file));
+    const messages = [];
+    for (const { file, needsRename } of allFiles) {
+        const srcPath = path.join(pendingDir, file);
+        const processingPath = needsRename
+            ? path.join(pendingDir, file + ".processing")
+            : srcPath;
+        try {
+            if (needsRename) {
+                fs.renameSync(srcPath, processingPath);
+            }
+            const raw = fs.readFileSync(processingPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            messages.push(parsed);
+            fs.unlinkSync(processingPath);
+        }
+        catch {
+            // Skip unparseable files — still try to clean up
+            try {
+                fs.unlinkSync(processingPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.pending_drained",
+        component: "mind",
+        message: "pending queue drained",
+        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+    });
+    return messages;
+}

package/dist/mind/prompt-refresh.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshSystemPrompt = refreshSystemPrompt;
+const prompt_1 = require("./prompt");
+const runtime_1 = require("../nerves/runtime");
+async function refreshSystemPrompt(messages, channel, options, context) {
+    const newSystem = await (0, prompt_1.buildSystem)(channel, options, context);
+    if (messages.length > 0 && messages[0].role === "system") {
+        messages[0] = { role: "system", content: newSystem };
+    }
+    else {
+        messages.unshift({ role: "system", content: newSystem });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.system_prompt_refreshed",
+        component: "mind",
+        message: "system prompt refreshed",
+        meta: { channel },
+    });
+}

package/dist/mind/prompt.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetPsycheCache = resetPsycheCache;
+exports.buildSessionSummary = buildSessionSummary;
 exports.runtimeInfoSection = runtimeInfoSection;
 exports.contextSection = contextSection;
 exports.buildSystem = buildSystem;
@@ -43,6 +44,7 @@ const core_1 = require("../heart/core");
 const tools_1 = require("../repertoire/tools");
 const skills_1 = require("../repertoire/skills");
 const identity_1 = require("../heart/identity");
+const os = __importStar(require("os"));
 const channel_1 = require("./friends/channel");
 const runtime_1 = require("../nerves/runtime");
 const first_impressions_1 = require("./first-impressions");
@@ -73,6 +75,94 @@ function loadPsyche() {
 function resetPsycheCache() {
     _psycheCache = null;
 }
+const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
+function resolveFriendName(friendId, friendsDir, agentName) {
+    if (friendId === "self")
+        return agentName;
+    try {
+        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
+        const record = JSON.parse(raw);
+        return record.name ?? friendId;
+    }
+    catch {
+        return friendId;
+    }
+}
+function buildSessionSummary(options) {
+    const { sessionsDir, friendsDir, agentName, currentFriendId, currentChannel, currentKey, activeThresholdMs = DEFAULT_ACTIVE_THRESHOLD_MS, } = options;
+    if (!fs.existsSync(sessionsDir))
+        return "";
+    const now = Date.now();
+    const entries = [];
+    let friendDirs;
+    try {
+        friendDirs = fs.readdirSync(sessionsDir);
+    }
+    catch {
+        return "";
+    }
+    for (const friendId of friendDirs) {
+        const friendPath = path.join(sessionsDir, friendId);
+        let channels;
+        try {
+            channels = fs.readdirSync(friendPath);
+        }
+        catch {
+            continue;
+        }
+        for (const channel of channels) {
+            const channelPath = path.join(friendPath, channel);
+            let keys;
+            try {
+                keys = fs.readdirSync(channelPath);
+            }
+            catch {
+                continue;
+            }
+            for (const keyFile of keys) {
+                if (!keyFile.endsWith(".json"))
+                    continue;
+                const key = keyFile.replace(/\.json$/, "");
+                // Exclude current session
+                if (friendId === currentFriendId && channel === currentChannel && key === currentKey) {
+                    continue;
+                }
+                const filePath = path.join(channelPath, keyFile);
+                let mtimeMs;
+                try {
+                    mtimeMs = fs.statSync(filePath).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (now - mtimeMs > activeThresholdMs)
+                    continue;
+                const displayName = resolveFriendName(friendId, friendsDir, agentName);
+                entries.push({ friendId, displayName, channel, key, lastActivityMs: mtimeMs });
+            }
+        }
+    }
+    if (entries.length === 0)
+        return "";
+    // Sort by most recent first
+    entries.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+    const lines = ["## active sessions"];
+    for (const entry of entries) {
+        const ago = formatTimeAgo(now - entry.lastActivityMs);
+        lines.push(`- ${entry.displayName}/${entry.channel}/${entry.key} (last: ${ago})`);
+    }
+    return lines.join("\n");
+}
+function formatTimeAgo(ms) {
+    const minutes = Math.floor(ms / 60000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
 function soulSection() {
     return loadPsyche().soul;
 }
@@ -108,6 +198,9 @@ function runtimeInfoSection(channel) {
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
+    else if (channel === "bluebubbles") {
+        lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
+    }
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
     }
@@ -238,6 +331,14 @@ async function buildSystem(channel = "cli", options, context) {
         toolsSection(channel, options),
         skillsSection(),
         taskBoardSection(),
+        buildSessionSummary({
+            sessionsDir: path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions"),
+            friendsDir: path.join((0, identity_1.getAgentRoot)(), "friends"),
+            agentName: (0, identity_1.getAgentName)(),
+            currentFriendId: context?.friend?.id,
+            currentChannel: channel,
+            currentKey: "session",
+        }),
         memoryFriendToolContractSection(),
         toolBehaviorSection(options),
         contextSection(context),

package/dist/nerves/coverage/file-completeness.js

@@ -11,12 +11,22 @@ exports.isTypeOnlyFile = isTypeOnlyFile;
 exports.checkFileCompleteness = checkFileCompleteness;
 /**
  * Determines if a source file is type-only (no executable code).
- * A file is type-only if it contains no function, class, or const declarations.
+ * A file is type-only if it contains no function, class, or mutable declarations.
+ * `const ... as const` declarations are treated as type-equivalent (frozen
+ * compile-time values with no side effects).
  */
 function isTypeOnlyFile(source) {
-    // Look for executable code markers: function, class, const/let/var declarations
-    const executablePattern = /\b(function|class|const|let|var)\s/;
-    return !executablePattern.test(source);
+    const lines = source.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip lines that are const+as-const (type-equivalent frozen values)
+        if (/\bconst\s/.test(trimmed) && /\bas\s+const\b/.test(trimmed))
+            continue;
+        // Check for executable code markers
+        if (/\b(function|class|const|let|var)\s/.test(trimmed))
+            return false;
+    }
+    return true;
 }
 /**
  * Check that all production files have at least one emitNervesEvent call.

package/dist/repertoire/tools-base.js

@@ -41,6 +41,7 @@ const skills_1 = require("./skills");
 const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
+const os = __importStar(require("os"));
 const tasks_1 = require("./tasks");
 const tools_1 = require("./coding/tools");
 const memory_1 = require("../mind/memory");
@@ -602,6 +603,97 @@ exports.baseToolDefinitions = [
             }
         },
     },
+    // -- cross-session awareness --
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_session",
+                description: "read the last messages from another session. use this to check on a conversation with a friend or review your own inner dialog.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        key: { type: "string", description: "session key (defaults to 'session')" },
+                        messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
+                    },
+                    required: ["friendId", "channel"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            try {
+                const friendId = args.friendId;
+                const channel = args.channel;
+                const key = args.key || "session";
+                const count = parseInt(args.messageCount || "20", 10);
+                const sessFile = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "sessions", friendId, channel, `${key}.json`);
+                const raw = fs.readFileSync(sessFile, "utf-8");
+                const data = JSON.parse(raw);
+                const messages = (data.messages || [])
+                    .filter((m) => m.role !== "system");
+                const tail = messages.slice(-count);
+                if (tail.length === 0)
+                    return "session exists but has no non-system messages.";
+                const transcript = tail.map((m) => `[${m.role}] ${m.content}`).join("\n");
+                // LLM summarization when summarize function is available
+                if (ctx?.summarize) {
+                    const trustLevel = ctx.context?.friend?.trustLevel ?? "family";
+                    const isSelfQuery = friendId === "self";
+                    const instruction = isSelfQuery
+                        ? "summarize this session transcript fully and transparently. this is my own inner dialog — include all details, decisions, and reasoning."
+                        : `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+                    return await ctx.summarize(transcript, instruction);
+                }
+                return transcript;
+            }
+            catch {
+                return "no session found for that friend/channel/key combination.";
+            }
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "send_message",
+                description: "send a message to a friend's session. the message is queued as a pending file and delivered when the target session drains its queue.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        key: { type: "string", description: "session key (defaults to 'session')" },
+                        content: { type: "string", description: "the message content to send" },
+                    },
+                    required: ["friendId", "channel", "content"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const content = args.content;
+            const now = Date.now();
+            const pendingDir = path.join(os.homedir(), ".agentstate", (0, identity_1.getAgentName)(), "pending", friendId, channel, key);
+            fs.mkdirSync(pendingDir, { recursive: true });
+            const fileName = `${now}-${Math.random().toString(36).slice(2, 10)}.json`;
+            const filePath = path.join(pendingDir, fileName);
+            const envelope = {
+                from: (0, identity_1.getAgentName)(),
+                friendId,
+                channel,
+                key,
+                content,
+                timestamp: now,
+            };
+            fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
+            const preview = content.length > 80 ? content.slice(0, 80) + "…" : content;
+            return `message queued for delivery to ${friendId} on ${channel}/${key}. preview: "${preview}". it will be delivered when their session is next active.`;
+        },
+    },
     ...tools_1.codingToolDefinitions,
 ];
 // Backward-compat: extract just the OpenAI tool schemas

package/dist/repertoire/tools.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "teamsTools", { enumerable: true, get: function (
 const allDefinitions = [...tools_base_1.baseToolDefinitions, ...tools_teams_1.teamsToolDefinitions, ...ado_semantic_1.adoSemanticToolDefinitions, ...tools_github_1.githubToolDefinitions];
 const REMOTE_BLOCKED_LOCAL_TOOLS = new Set(["shell", "read_file", "write_file", "git_commit", "gh_cli"]);
 function baseToolsForCapabilities(capabilities) {
-    const isRemoteChannel = capabilities?.channel === "teams";
+    const isRemoteChannel = capabilities?.channel === "teams" || capabilities?.channel === "bluebubbles";
     if (!isRemoteChannel)
         return tools_base_1.tools;
     return tools_base_1.tools.filter((tool) => !REMOTE_BLOCKED_LOCAL_TOOLS.has(tool.function.name));
@@ -87,7 +87,7 @@ async function execTool(name, args, ctx) {
         });
         return `unknown: ${name}`;
     }
-    const isRemoteChannel = ctx?.context?.channel?.channel === "teams";
+    const isRemoteChannel = ctx?.context?.channel?.channel === "teams" || ctx?.context?.channel?.channel === "bluebubbles";
     if (isRemoteChannel && REMOTE_BLOCKED_LOCAL_TOOLS.has(name)) {
         const message = "I can't do that from here because I'm talking to multiple people in a shared remote channel, and local shell/file/git/gh operations could let conversations interfere with each other. Ask me for a remote-safe alternative (Graph/ADO/web), or run that operation from CLI.";
         (0, runtime_1.emitNervesEvent)({
@@ -95,7 +95,7 @@ async function execTool(name, args, ctx) {
             event: "tool.error",
             component: "tools",
             message: "blocked local tool in remote channel",
-            meta: { name, channel: "teams" },
+            meta: { name, channel: ctx?.context?.channel?.channel },
         });
         return message;
     }