@ouro.bot/cli 0.1.0-alpha.37 → 0.1.0-alpha.38

package/dist/senses/bluebubbles.js

@@ -35,7 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
+exports.drainAndSendPendingBlueBubbles = drainAndSendPendingBlueBubbles;
 exports.startBlueBubblesApp = startBlueBubblesApp;
+const fs = __importStar(require("node:fs"));
 const http = __importStar(require("node:http"));
 const path = __importStar(require("node:path"));
 const core_1 = require("../heart/core");
@@ -541,6 +543,182 @@ function createBlueBubblesWebhookHandler(deps = {}) {
         }
     };
 }
+const PROACTIVE_SEND_ALLOWED_TRUST = new Set(["family", "friend"]);
+function findImessageHandle(friend) {
+    for (const ext of friend.externalIds) {
+        if (ext.provider === "imessage-handle" && !ext.externalId.startsWith("group:")) {
+            return ext.externalId;
+        }
+    }
+    return undefined;
+}
+function scanPendingBlueBubblesFiles(pendingRoot) {
+    const results = [];
+    let friendIds;
+    try {
+        friendIds = fs.readdirSync(pendingRoot);
+    }
+    catch {
+        return results;
+    }
+    for (const friendId of friendIds) {
+        const bbDir = path.join(pendingRoot, friendId, "bluebubbles");
+        let keys;
+        try {
+            keys = fs.readdirSync(bbDir);
+        }
+        catch {
+            continue;
+        }
+        for (const key of keys) {
+            const keyDir = path.join(bbDir, key);
+            let files;
+            try {
+                files = fs.readdirSync(keyDir);
+            }
+            catch {
+                continue;
+            }
+            for (const file of files.filter((f) => f.endsWith(".json")).sort()) {
+                const filePath = path.join(keyDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    results.push({ friendId, key, filePath, content });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    return results;
+}
+async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const root = pendingRoot ?? path.join((0, identity_1.getAgentRoot)(), "state", "pending");
+    const client = resolvedDeps.createClient();
+    const store = resolvedDeps.createFriendStore();
+    const pendingFiles = scanPendingBlueBubblesFiles(root);
+    const result = { sent: 0, skipped: 0, failed: 0 };
+    for (const { friendId, filePath, content } of pendingFiles) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            result.failed++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        const messageText = typeof parsed.content === "string" ? parsed.content : "";
+        if (!messageText.trim()) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        let friend;
+        try {
+            friend = await store.get(friendId);
+        }
+        catch {
+            friend = null;
+        }
+        if (!friend) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_friend",
+                message: "proactive send skipped: friend not found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        if (!PROACTIVE_SEND_ALLOWED_TRUST.has(friend.trustLevel ?? "stranger")) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_proactive_trust_skip",
+                message: "proactive send skipped: trust level not allowed",
+                meta: { friendId, trustLevel: friend.trustLevel ?? "unknown" },
+            });
+            continue;
+        }
+        const handle = findImessageHandle(friend);
+        if (!handle) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_handle",
+                message: "proactive send skipped: no iMessage handle found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        const chat = {
+            chatIdentifier: handle,
+            isGroup: false,
+            sessionKey: friendId,
+            sendTarget: { kind: "chat_identifier", value: handle },
+        };
+        try {
+            await client.sendText({ chat, text: messageText });
+            result.sent++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_proactive_sent",
+                message: "proactive bluebubbles message sent",
+                meta: { friendId, handle },
+            });
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_send_error",
+                message: "proactive bluebubbles send failed",
+                meta: {
+                    friendId,
+                    handle,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    if (result.sent > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_drain_complete",
+            message: "bluebubbles proactive drain complete",
+            meta: { sent: result.sent, skipped: result.skipped, failed: result.failed },
+        });
+    }
+    return result;
+}
 function startBlueBubblesApp(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     resolvedDeps.createClient();

package/dist/senses/cli.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarkdownStreamer = exports.InputController = exports.Spinner = void 0;
+exports.formatPendingPrefix = formatPendingPrefix;
 exports.handleSigint = handleSigint;
 exports.addHistory = addHistory;
 exports.renderMarkdown = renderMarkdown;
@@ -65,6 +66,19 @@ const session_lock_1 = require("./session-lock");
 const update_hooks_1 = require("../heart/daemon/update-hooks");
 const bundle_meta_1 = require("../heart/daemon/hooks/bundle-meta");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
+/**
+ * Format pending messages as content-prefix strings for injection into
+ * the next user message. Self-messages (from === agentName) become
+ * `[inner thought: {content}]`, inter-agent messages become
+ * `[message from {name}: {content}]`.
+ */
+function formatPendingPrefix(messages, agentName) {
+    return messages
+        .map((msg) => msg.from === agentName
+        ? `[inner thought: ${msg.content}]`
+        : `[message from ${msg.from}: ${msg.content}]`)
+        .join("\n");
+}
 // spinner that only touches stderr, cleans up after itself
 // exported for direct testability (stop-without-start branch)
 class Spinner {
@@ -606,7 +620,8 @@ async function runCliSession(options) {
                 echoRows += Math.ceil((2 + line.length) / cols);
             }
             process.stdout.write(`\x1b[${echoRows}A\x1b[K` + `\x1b[1m> ${inputLines[0]}${inputLines.length > 1 ? ` (+${inputLines.length - 1} lines)` : ""}\x1b[0m\n\n`);
-            messages.push({ role: "user", content: input });
+            const prefix = options.getContentPrefix?.();
+            messages.push({ role: "user", content: prefix ? `${prefix}\n\n${input}` : input });
             addHistory(history, input);
             currentAbort = new AbortController();
             const traceId = (0, nerves_1.createTraceId)();
@@ -715,20 +730,18 @@ async function main(agentName, options) {
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
-    // Pending queue drain: inject pending messages as harness-context + assistant-content pairs
+    // Pending queue drain: format as content-prefix for next user message
     const pendingDir = (0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), friendId, "cli", "session");
-    const drainToMessages = () => {
+    let pendingPrefix;
+    const drainToPrefix = () => {
         const pending = (0, pending_1.drainPending)(pendingDir);
         if (pending.length === 0)
             return 0;
-        for (const msg of pending) {
-            sessionMessages.push({ role: "user", name: "harness", content: `[proactive message from ${msg.from}]` });
-            sessionMessages.push({ role: "assistant", content: msg.content });
-        }
+        pendingPrefix = formatPendingPrefix(pending, (0, identity_1.getAgentName)());
         return pending.length;
     };
-    // Startup drain: deliver offline messages
-    const startupCount = drainToMessages();
+    // Startup drain: collect offline messages as prefix for next user message
+    const startupCount = drainToPrefix();
     if (startupCount > 0) {
         (0, context_1.saveSession)(sessPath, sessionMessages);
     }
@@ -753,10 +766,15 @@ async function main(agentName, options) {
                 }
                 return { allowed: true };
             },
+            getContentPrefix: () => {
+                const prefix = pendingPrefix;
+                pendingPrefix = undefined;
+                return prefix;
+            },
             onTurnEnd: async (msgs, result) => {
                 (0, context_1.postTurn)(msgs, sessPath, result.usage);
                 await (0, tokens_1.accumulateFriendTokens)(friendStore, resolvedContext.friend.id, result.usage);
-                drainToMessages();
+                drainToPrefix();
                 await (0, prompt_refresh_1.refreshSystemPrompt)(msgs, "cli", undefined, resolvedContext);
             },
             onNewSession: () => {

package/dist/senses/inner-dialog.js

@@ -48,12 +48,13 @@ const identity_1 = require("../heart/identity");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
+const pending_1 = require("../mind/pending");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("../nerves/runtime");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
-        prompt: "Heartbeat instinct: check what changed, review priorities, and decide whether to keep resting or act.",
+        prompt: "...time passing. anything stirring?",
         enabled: true,
     },
 ];
@@ -68,19 +69,8 @@ function readAspirations(agentRoot) {
 function loadInnerDialogInstincts() {
     return [...DEFAULT_INNER_DIALOG_INSTINCTS];
 }
-function buildInnerDialogBootstrapMessage(aspirations, stateSummary) {
-    const aspirationText = aspirations || "No explicit aspirations file found. Reflect and define what matters next.";
-    return [
-        "Inner dialog boot.",
-        "",
-        "## aspirations",
-        aspirationText,
-        "",
-        "## current state",
-        stateSummary,
-        "",
-        "Orient yourself, decide what to do next, and make meaningful progress.",
-    ].join("\n");
+function buildInnerDialogBootstrapMessage(_aspirations, _stateSummary) {
+    return "waking up. settling in.\n\nwhat needs my attention?";
 }
 function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
     if (nonCanonicalPaths.length === 0)
@@ -95,17 +85,14 @@ function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
         ...listed,
     ].join("\n");
 }
-function buildInstinctUserMessage(instincts, reason, state) {
+function buildInstinctUserMessage(instincts, _reason, state) {
     const active = instincts.find((instinct) => instinct.enabled !== false) ?? DEFAULT_INNER_DIALOG_INSTINCTS[0];
-    const checkpoint = state.checkpoint?.trim() || "no prior checkpoint recorded";
-    return [
-        active.prompt,
-        `reason: ${reason}`,
-        `cycle: ${state.cycleCount}`,
-        `resting: ${state.resting ? "yes" : "no"}`,
-        `checkpoint: ${checkpoint}`,
-        "resume_instruction: continue from the checkpoint if still valid; otherwise revise and proceed.",
-    ].join("\n");
+    const checkpoint = state.checkpoint?.trim();
+    const lines = [active.prompt];
+    if (checkpoint) {
+        lines.push(`\nlast i remember: ${checkpoint}`);
+    }
+    return lines.join("\n");
 }
 function contentToText(content) {
     if (typeof content === "string")
@@ -176,7 +163,7 @@ async function runInnerDialogTurn(options) {
         lastHeartbeatAt: now().toISOString(),
     };
     if (messages.length === 0) {
-        const systemPrompt = await (0, prompt_1.buildSystem)("cli", { toolChoiceRequired: true });
+        const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true });
         messages.push({ role: "system", content: systemPrompt });
         const aspirations = readAspirations((0, identity_1.getAgentRoot)());
         const nonCanonical = (0, bundle_manifest_1.findNonCanonicalBundlePaths)((0, identity_1.getAgentRoot)());
@@ -194,6 +181,21 @@ async function runInnerDialogTurn(options) {
         const instinctPrompt = buildInstinctUserMessage(instincts, reason, state);
         messages.push({ role: "user", content: instinctPrompt });
     }
+    const pendingMessages = (0, pending_1.drainPending)((0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), "self", "inner", "dialog"));
+    if (pendingMessages.length > 0) {
+        const lastUserIdx = messages.length - 1;
+        const lastUser = messages[lastUserIdx];
+        /* v8 ignore next -- defensive: all code paths push a user message before here @preserve */
+        if (lastUser?.role === "user" && typeof lastUser.content === "string") {
+            const section = pendingMessages
+                .map((msg) => `- **${msg.from}**: ${msg.content}`)
+                .join("\n");
+            messages[lastUserIdx] = {
+                ...lastUser,
+                content: `${lastUser.content}\n\n## pending messages\n${section}`,
+            };
+        }
+    }
     const inboxMessages = options?.drainInbox?.() ?? [];
     if (inboxMessages.length > 0) {
         const lastUserIdx = messages.length - 1;
@@ -211,7 +213,7 @@ async function runInnerDialogTurn(options) {
     }
     const callbacks = createInnerDialogCallbacks();
     const traceId = (0, nerves_1.createTraceId)();
-    const result = await (0, core_1.runAgent)(messages, callbacks, "cli", options?.signal, {
+    const result = await (0, core_1.runAgent)(messages, callbacks, "inner", options?.signal, {
         traceId,
         toolChoiceRequired: true,
         skipConfirmation: true,

package/dist/senses/teams.js

@@ -40,7 +40,9 @@ exports.createTeamsCallbacks = createTeamsCallbacks;
 exports.resolvePendingConfirmation = resolvePendingConfirmation;
 exports.withConversationLock = withConversationLock;
 exports.handleTeamsMessage = handleTeamsMessage;
+exports.drainAndSendPendingTeams = drainAndSendPendingTeams;
 exports.startTeamsApp = startTeamsApp;
+const fs = __importStar(require("fs"));
 const teams_apps_1 = require("@microsoft/teams.apps");
 const teams_dev_1 = require("@microsoft/teams.dev");
 const core_1 = require("../heart/core");
@@ -737,6 +739,183 @@ function registerBotHandlers(app, label) {
         (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.app_error", component: "channels", message: `[${label}] ${msg}`, meta: {} });
     });
 }
+const TEAMS_PROACTIVE_ALLOWED_TRUST = new Set(["family", "friend"]);
+function findAadObjectId(friend) {
+    for (const ext of friend.externalIds) {
+        if (ext.provider === "aad" && !ext.externalId.startsWith("group:")) {
+            return { aadObjectId: ext.externalId, tenantId: ext.tenantId };
+        }
+    }
+    return undefined;
+}
+function scanPendingTeamsFiles(pendingRoot) {
+    const results = [];
+    let friendIds;
+    try {
+        friendIds = fs.readdirSync(pendingRoot);
+    }
+    catch {
+        return results;
+    }
+    for (const friendId of friendIds) {
+        const teamsDir = path.join(pendingRoot, friendId, "teams");
+        let keys;
+        try {
+            keys = fs.readdirSync(teamsDir);
+        }
+        catch {
+            continue;
+        }
+        for (const key of keys) {
+            const keyDir = path.join(teamsDir, key);
+            let files;
+            try {
+                files = fs.readdirSync(keyDir);
+            }
+            catch {
+                continue;
+            }
+            for (const file of files.filter((f) => f.endsWith(".json")).sort()) {
+                const filePath = path.join(keyDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    results.push({ friendId, key, filePath, content });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    return results;
+}
+async function drainAndSendPendingTeams(store, botApi, pendingRoot) {
+    const root = pendingRoot ?? path.join((0, identity_1.getAgentRoot)(), "state", "pending");
+    const pendingFiles = scanPendingTeamsFiles(root);
+    const result = { sent: 0, skipped: 0, failed: 0 };
+    const conversations = botApi.conversations;
+    for (const { friendId, filePath, content } of pendingFiles) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            result.failed++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        const messageText = typeof parsed.content === "string" ? parsed.content : "";
+        if (!messageText.trim()) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        let friend;
+        try {
+            friend = await store.get(friendId);
+        }
+        catch {
+            friend = null;
+        }
+        if (!friend) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.teams_proactive_no_friend",
+                message: "proactive send skipped: friend not found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        if (!TEAMS_PROACTIVE_ALLOWED_TRUST.has(friend.trustLevel ?? "stranger")) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.teams_proactive_trust_skip",
+                message: "proactive send skipped: trust level not allowed",
+                meta: { friendId, trustLevel: friend.trustLevel ?? "unknown" },
+            });
+            continue;
+        }
+        const aadInfo = findAadObjectId(friend);
+        if (!aadInfo) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.teams_proactive_no_aad_id",
+                message: "proactive send skipped: no AAD object ID found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        try {
+            const conversation = await conversations.create({
+                bot: { id: botApi.id },
+                members: [{ id: aadInfo.aadObjectId, role: "user", name: friend.name || aadInfo.aadObjectId }],
+                tenantId: aadInfo.tenantId,
+                isGroup: false,
+            });
+            await conversations.activities(conversation.id).create({
+                type: "message",
+                text: messageText,
+            });
+            result.sent++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.teams_proactive_sent",
+                message: "proactive teams message sent",
+                meta: { friendId, aadObjectId: aadInfo.aadObjectId },
+            });
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.teams_proactive_send_error",
+                message: "proactive teams send failed",
+                meta: {
+                    friendId,
+                    aadObjectId: aadInfo.aadObjectId,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    if (result.sent > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.teams_proactive_drain_complete",
+            message: "teams proactive drain complete",
+            meta: { sent: result.sent, skipped: result.skipped, failed: result.failed },
+        });
+    }
+    return result;
+}
 // Start the Teams app in DevtoolsPlugin mode (local dev) or Bot Service mode (real Teams).
 // Mode is determined by getTeamsConfig().clientId.
 // Text is always accumulated in textBuffer and flushed periodically (chunked streaming).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.37",
+  "version": "0.1.0-alpha.38",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -35,6 +35,7 @@
     "@anthropic-ai/sdk": "^0.78.0",
     "@microsoft/teams.apps": "^2.0.5",
     "@microsoft/teams.dev": "^2.0.5",
+    "fast-glob": "^3.3.3",
     "openai": "^6.27.0",
     "semver": "^7.7.4"
   },