@ouro.bot/cli 0.1.0-alpha.350 → 0.1.0-alpha.352

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.352",
+      "changes": [
+        "Settle tool description now communicates turn-ending semantics: 'deliver your response and end your turn' with explicit guidance against settling with status updates mid-task.",
+        "Observe tool now available in all outward channels including 1:1 chats, not just groups and reactions — agents can absorb messages without responding when the moment doesn't call for words.",
+        "Autonomous execution prompt contract added: when told to work autonomously, agents use ponder to absorb new messages and continue using tools, settling only with the final result."
+      ]
+    },
     {
       "version": "0.1.0-alpha.350",
       "changes": [

package/dist/heart/core.js

@@ -556,8 +556,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     while (!done) {
         // Channel-based tool filtering:
         // - Inner dialog: exclude send_message (delivery via surface), observe (no one to observe)
-        // - 1:1 sessions: exclude observe (can't ignore someone talking directly to you)
-        // - Group chats: observe available
+        // - All outward channels (1:1, group, reaction): observe available
         //
         // ponder, settle/rest, surface, and observe are always assembled based on channel context.
         // ponder is available in ALL channels (outer: think privately, inner: keep turning).
@@ -571,7 +570,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             ...filteredBaseTools,
             tools_1.ponderTool,
             ...(isInnerDialog ? [tools_2.surfaceToolDef, tools_1.restTool] : []),
-            ...((currentContext?.isGroupChat || options?.isReactionSignal) && !isInnerDialog ? [tools_1.observeTool] : []),
+            ...(!isInnerDialog ? [tools_1.observeTool] : []),
             ...(!isInnerDialog ? [tools_1.settleTool] : []),
         ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];

package/dist/mind/prompt.js

@@ -380,7 +380,7 @@ function runtimeInfoSection(channel, options) {
         lines.push("i introduce myself on boot with a fun random greeting.");
     }
     else if (channel === "inner") {
-        lines.push("this is my inner session. when a thought is ready to share, i surface it to whoever needs to hear it. when i'm done thinking and the queue is clear, i rest.");
+        lines.push("this is my inner session. when i have something to say to someone, i surface it. when i'm done thinking and the queue is clear, i rest.");
     }
     else if (channel === "mcp") {
         lines.push("this message arrived via a dev tool (e.g. claude code, codex) on behalf of a friend in a sense session. the user can see our conversation. respond via settle. if friction appears, i first look for ad-hoc repairs with the tools i already have. if the friction reveals a harness gap, i create or revise a ponder packet and keep working. ponder does not create an outward deferral by itself.");
@@ -599,15 +599,18 @@ function toolContractsSection(channel, options) {
         lines.push(`## tool behavior`);
         lines.push(`tool_choice is set to "required" -- I must call a tool on every turn.`);
         if (channel === "inner") {
-            lines.push(`- When a thought is ready to go outward, I call \`surface\` with the content and, when available, its delegationId.`);
+            lines.push(`- When I have something to say to a person, I call \`surface\` with the content and, when available, its delegationId.`);
             lines.push(`- \`surface\` does not end the inner turn; after surfacing everything that needs delivery, I call \`rest\`.`);
-            lines.push(`- \`rest\` must be the only tool call in that turn.`);
+            lines.push(`- \`rest\` must be the only tool call in that turn. Internal state notes go in \`rest(note: "...")\` — that is my scratchpad, not \`surface\`.`);
+            lines.push(`- For deeper reflection I want to preserve, I use \`ponder\` with kind \`reflection\`.`);
             lines.push(`- I do not call \`send_message\` or \`settle\` from inner dialogue; those are not inner-session delivery tools.`);
         }
         else {
             lines.push(`- When I am ready to respond to the user, I call \`settle\`.`);
             lines.push(`- \`settle\` must be the only tool call in that turn.`);
             lines.push(`- I do not call no-op tools before \`settle\`.`);
+            lines.push(`- when told to work autonomously, I use ponder to absorb new messages and continue using tools. I settle only with the final result.`);
+            lines.push(`- if nothing calls for words, I observe.`);
         }
     }
     return lines.join("\n");

package/dist/repertoire/tools-flow.js

@@ -72,7 +72,7 @@ exports.settleTool = {
     type: "function",
     function: {
         name: "settle",
-        description: "respond to the user with your message. call this tool when you are ready to deliver your response. Only call when you have a substantive response. If you're settling with 'I'll look into that,' you probably should be using a tool instead.",
+        description: "deliver your response and end your turn — this hands control back to the user. only settle when your work is complete, you're genuinely blocked, or the user asked a direct question that needs an answer now. do not settle with status updates mid-task. if you're settling with 'I'll look into that,' you probably should be using a tool instead.",
         parameters: {
             type: "object",
             properties: {

package/dist/repertoire/tools-surface.js

@@ -45,7 +45,7 @@ exports.surfaceToolDef = {
     type: "function",
     function: {
         name: "surface",
-        description: "share a thought outward — deliver an answer, ask a follow-up, or surface progress to whoever needs to hear it. pass delegationId to address a held thought (see your attention queue above), or friendId for spontaneous outreach. does not end your turn.",
+        description: "send a message to someone — write it the way you'd text a friend. pass delegationId to address a held thought (see your attention queue above), or friendId for spontaneous outreach. does not end your turn.",
         parameters: {
             type: "object",
             properties: {
@@ -124,7 +124,7 @@ exports.surfaceToolDefinition = {
                                     // Inject surfaced content into the target session so it knows what was delivered
                                     const { appendSyntheticAssistantMessage } = await Promise.resolve().then(() => __importStar(require("../mind/context")));
                                     const sessionFilePath = path.join(sessionsDir, bridgeTarget.friendId, bridgeTarget.channel, `${bridgeTarget.key}.json`);
-                                    appendSyntheticAssistantMessage(sessionFilePath, `[surfaced from inner dialog] ${content}`);
+                                    appendSyntheticAssistantMessage(sessionFilePath, content);
                                     return { status: "delivered", detail: "via iMessage" };
                                 }
                             }
@@ -158,7 +158,7 @@ exports.surfaceToolDefinition = {
                     if (proactiveResult.delivered) {
                         const { appendSyntheticAssistantMessage } = await Promise.resolve().then(() => __importStar(require("../mind/context")));
                         const sessionFilePath = path.join(sessionsDir, bbSession.friendId, bbSession.channel, `${bbSession.key}.json`);
-                        appendSyntheticAssistantMessage(sessionFilePath, `[surfaced from inner dialog] ${content}`);
+                        appendSyntheticAssistantMessage(sessionFilePath, content);
                         return { status: "delivered", detail: "via iMessage" };
                     }
                 }

package/dist/senses/attention-queue.js

@@ -101,7 +101,7 @@ const CONTENT_PREVIEW_MAX = 80;
 function buildAttentionQueueSummary(queue) {
     if (queue.length === 0)
         return "";
-    const lines = ["you're holding:"];
+    const lines = ["[internal: held work items — not messages to send]"];
     for (const item of queue) {
         if (item.packetKind && item.packetObjective) {
             lines.push(`- [${item.id}] ${item.friendName} -> ${item.packetKind}: ${item.packetObjective}`);

package/dist/senses/bluebubbles/index.js

@@ -61,6 +61,7 @@ const prompt_1 = require("../../mind/prompt");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
 // getPhrases removed — no longer needed after debug-activity cleanup
 const runtime_1 = require("../../nerves/runtime");
+const proactive_content_guard_1 = require("../proactive-content-guard");
 const model_1 = require("./model");
 const client_1 = require("./client");
 const inbound_log_1 = require("./inbound-log");
@@ -1368,6 +1369,17 @@ async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
         return { delivered: false, reason: "group_blocked" };
     }
     /* v8 ignore stop */
+    const internalContentBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(params.text);
+    if (internalContentBlockReason) {
+        (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+            friendId: params.friendId,
+            sessionKey: params.sessionKey,
+            reason: internalContentBlockReason,
+            source: "session_send",
+            intent: params.intent ?? "generic_outreach",
+        });
+        return { delivered: false, reason: "internal_content_blocked" };
+    }
     try {
         await client.sendText({ chat, text: params.text });
         (0, runtime_1.emitNervesEvent)({
@@ -1468,6 +1480,20 @@ async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
             catch { /* ignore */ }
             continue;
         }
+        const internalBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(messageText);
+        if (internalBlockReason) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+                friendId,
+                reason: internalBlockReason,
+                source: "pending_drain",
+            });
+            continue;
+        }
         let friend;
         try {
             friend = await store.get(friendId);

package/dist/senses/habit-turn-message.js

@@ -92,7 +92,7 @@ function appendTrailingExtras(sections, alsoDue, staleObligations, parseErrors,
     }
     // 5. Stale obligations
     if (staleObligations.length > 0) {
-        const lines = staleObligations.map((o) => `something for ${o.friendName} has been sitting for ${formatElapsed(o.stalenessMs)}`);
+        const lines = staleObligations.map((o) => `[internal] obligation: ${o.friendName} — waiting ${formatElapsed(o.stalenessMs)}`);
         sections.push(lines.join("\n"));
     }
     // 6. Parse errors

package/dist/senses/proactive-content-guard.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProactiveInternalContentBlockReason = getProactiveInternalContentBlockReason;
+exports.emitProactiveInternalContentBlocked = emitProactiveInternalContentBlocked;
+const runtime_1 = require("../nerves/runtime");
+// ── Patterns ────────────────────────────────────────────────────
+const PROACTIVE_INTERNAL_CONTENT_PATTERNS = [
+    // PR 447 patterns: raw meta markers
+    { reason: "raw_meta_marker", pattern: /<\s*\/?\s*(think|analysis|commentary)\b[^>]*>/i },
+    { reason: "raw_meta_marker", pattern: /\[\s*surfaced from inner dialog\s*\]/i },
+    // Inner dialog / attention / obligation references
+    { reason: "inner_dialog_reference", pattern: /\binner (dialog|dialogue)\b/i },
+    { reason: "attention_queue_reference", pattern: /\battention queues?\b/i },
+    { reason: "return_obligation_reference", pattern: /\b(return|held|heart|inner)\s+obligations?\b/i },
+    // Surfacing mechanics
+    { reason: "surfacing_mechanics_reference", pattern: /\b(surface tool|surfacing (mechanics|itself)|surfaced? outward|call `?surface`?|delegationId|delegation id)\b/i },
+    // Prompt references
+    { reason: "prompt_reference", pattern: /\b(system|developer|inner|tool|orientation)\s+prompts?\b|\bprompt\/orientation\b|\bprompt wording\b/i },
+    // Routing references
+    { reason: "routing_reference", pattern: /\b(routing target|reply target|route through surface|routed through surface|proactive bluebubbles delivery)\b/i },
+    // Heartbeat / status patterns
+    { reason: "heartbeat_status", pattern: /\bheartbeat\b/i },
+    { reason: "heartbeat_status", pattern: /\bcheck-in\b/i },
+    { reason: "heartbeat_status", pattern: /\btask board\b/i },
+    { reason: "heartbeat_status", pattern: /\ball else settled\b/i },
+    { reason: "heartbeat_status", pattern: /\bobligations?\s+showing\b/i },
+    { reason: "heartbeat_status", pattern: /\bsame state\b/i },
+];
+// ── Public API ──────────────────────────────────────────────────
+function getProactiveInternalContentBlockReason(text) {
+    for (const { reason, pattern } of PROACTIVE_INTERNAL_CONTENT_PATTERNS) {
+        if (pattern.test(text))
+            return reason;
+    }
+    return null;
+}
+function emitProactiveInternalContentBlocked(params) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.proactive_internal_content_blocked",
+        message: "proactive send blocked: internal content",
+        meta: {
+            friendId: params.friendId,
+            source: params.source,
+            reason: params.reason,
+            ...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),
+            ...(params.intent ? { intent: params.intent } : {}),
+        },
+    });
+}

package/dist/senses/teams.js

@@ -61,6 +61,7 @@ const context_1 = require("../mind/context");
 const commands_1 = require("./commands");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("../nerves/runtime");
+const proactive_content_guard_1 = require("./proactive-content-guard");
 const store_file_1 = require("../mind/friends/store-file");
 const types_1 = require("../mind/friends/types");
 const resolver_1 = require("../mind/friends/resolver");
@@ -1103,6 +1104,16 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
         });
         return { delivered: false, reason: "missing_target" };
     }
+    const internalContentBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(params.text);
+    if (internalContentBlockReason) {
+        (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+            friendId: params.friendId,
+            sessionKey: params.sessionKey,
+            reason: internalContentBlockReason,
+            source: "session_send",
+        });
+        return { delivered: false, reason: "internal_content_blocked" };
+    }
     try {
         const conversation = await conversations.create({
             bot: { id: deps.botApi.id },
@@ -1205,6 +1216,20 @@ async function drainAndSendPendingTeams(store, botApi, pendingRoot) {
             catch { /* ignore */ }
             continue;
         }
+        const internalBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(messageText);
+        if (internalBlockReason) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+                friendId,
+                reason: internalBlockReason,
+                source: "pending_drain",
+            });
+            continue;
+        }
         const sendResult = await sendProactiveTeamsMessageToSession({
             friendId,
             sessionKey: key,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.350",
+  "version": "0.1.0-alpha.352",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",