@ouro.bot/cli 0.1.0-alpha.3 → 0.1.0-alpha.31

package/dist/heart/daemon/wrapper-publish-guard.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessWrapperPublishSync = assessWrapperPublishSync;
+const runtime_1 = require("../../nerves/runtime");
+function wrapperPackageChanged(changedFiles) {
+    return changedFiles.some((file) => file.startsWith("packages/ouro.bot/"));
+}
+function assessWrapperPublishSync(input) {
+    let result;
+    if (input.localVersion !== input.cliVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper version ${input.localVersion} must match @ouro.bot/cli version ${input.cliVersion}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: wrapperPackageChanged(input.changedFiles),
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    if (!wrapperPackageChanged(input.changedFiles)) {
+        result = {
+            ok: true,
+            message: "wrapper package unchanged",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: false,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    if (input.publishedVersion === input.localVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper changed but ouro.bot@${input.localVersion} is already published; bump packages/ouro.bot/package.json before merging`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: true,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    result = {
+        ok: true,
+        message: "wrapper package changed and local wrapper version is unpublished",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.wrapper_publish_guard_checked",
+        message: "evaluated wrapper publish sync",
+        meta: {
+            changed: true,
+            localVersion: input.localVersion,
+            cliVersion: input.cliVersion,
+            publishedVersion: input.publishedVersion,
+            ok: result.ok,
+        },
+    });
+    return result;
+}

package/dist/heart/identity.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
@@ -42,6 +42,8 @@ exports.getAgentRoot = getAgentRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
+exports.resetAgentConfigCache = resetAgentConfigCache;
 exports.resetIdentity = resetIdentity;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -56,12 +58,73 @@ exports.DEFAULT_AGENT_PHRASES = {
     tool: ["running tool"],
     followup: ["processing"],
 };
+exports.DEFAULT_AGENT_SENSES = {
+    cli: { enabled: true },
+    teams: { enabled: false },
+    bluebubbles: { enabled: false },
+};
+function normalizeSenses(value, configFile) {
+    const defaults = {
+        cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+    if (value === undefined) {
+        return defaults;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid senses block",
+            meta: { path: configFile },
+        });
+        throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
+    }
+    const raw = value;
+    const senseNames = ["cli", "teams", "bluebubbles"];
+    for (const senseName of senseNames) {
+        const rawSense = raw[senseName];
+        if (rawSense === undefined) {
+            continue;
+        }
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense config",
+                meta: { path: configFile, sense: senseName },
+            });
+            throw new Error(`agent.json at ${configFile} has invalid senses.${senseName} config.`);
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled !== "boolean") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense enabled flag",
+                meta: { path: configFile, sense: senseName, enabled: enabled ?? null },
+            });
+            throw new Error(`agent.json at ${configFile} must include senses.${senseName}.enabled as boolean.`);
+        }
+        defaults[senseName] = { enabled };
+    }
+    return defaults;
+}
 function buildDefaultAgentTemplate(_agentName) {
     return {
         version: 1,
         enabled: true,
         provider: "anthropic",
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        senses: {
+            cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+            teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+            bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+        },
         phrases: {
             thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
             tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
@@ -71,6 +134,7 @@ function buildDefaultAgentTemplate(_agentName) {
 }
 let _cachedAgentName = null;
 let _cachedAgentConfig = null;
+let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
  * Caches the result after first parse.
@@ -131,6 +195,9 @@ function getAgentSecretsPath(agentName = getAgentName()) {
  * Throws descriptive error if file is missing or contains invalid JSON.
  */
 function loadAgentConfig() {
+    if (_agentConfigOverride) {
+        return _agentConfigOverride;
+    }
     if (_cachedAgentConfig) {
         (0, runtime_1.emitNervesEvent)({
             event: "identity.resolve",
@@ -252,6 +319,7 @@ function loadAgentConfig() {
         provider: rawProvider,
         context: parsed.context,
         logging: parsed.logging,
+        senses: normalizeSenses(parsed.senses, configFile),
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({
@@ -271,6 +339,21 @@ function loadAgentConfig() {
 function setAgentName(name) {
     _cachedAgentName = name;
 }
+/**
+ * Override the agent config returned by loadAgentConfig().
+ * When set to a non-null AgentConfig, loadAgentConfig() returns the override
+ * instead of reading from disk. When set to null, normal disk-based loading resumes.
+ */
+function setAgentConfigOverride(config) {
+    _agentConfigOverride = config;
+}
+/**
+ * Clear only the cached agent config while preserving the resolved agent identity.
+ * Used when a running agent should pick up updated disk-backed config on the next turn.
+ */
+function resetAgentConfigCache() {
+    _cachedAgentConfig = null;
+}
 /**
  * Clear all cached identity state.
  * Used in tests and when switching agent context.
@@ -278,4 +361,5 @@ function setAgentName(name) {
 function resetIdentity() {
     _cachedAgentName = null;
     _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }

package/dist/heart/providers/anthropic.js

@@ -8,6 +8,7 @@ const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const config_1 = require("../config");
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
 const ANTHROPIC_SETUP_TOKEN_PREFIX = "sk-ant-oat01-";
 const ANTHROPIC_SETUP_TOKEN_MIN_LENGTH = 80;
 const ANTHROPIC_OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14";
@@ -98,6 +99,9 @@ function toAnthropicMessages(messages) {
             }
             if (assistant.tool_calls) {
                 for (const toolCall of assistant.tool_calls) {
+                    /* v8 ignore next -- type narrowing: OpenAI SDK only emits function tool_calls @preserve */
+                    if (toolCall.type !== "function")
+                        continue;
                     blocks.push({
                         type: "tool_use",
                         id: toolCall.id,
@@ -215,6 +219,7 @@ async function streamAnthropicMessages(client, model, request) {
     let streamStarted = false;
     let usage;
     const toolCalls = new Map();
+    const answerStreamer = new streaming_1.FinalAnswerStreamer(request.callbacks);
     try {
         for await (const event of response) {
             if (request.signal?.aborted)
@@ -228,11 +233,17 @@ async function streamAnthropicMessages(client, model, request) {
                     const input = rawInput && typeof rawInput === "object"
                         ? JSON.stringify(rawInput)
                         : "";
+                    const name = String(block.name ?? "");
                     toolCalls.set(index, {
                         id: String(block.id ?? ""),
-                        name: String(block.name ?? ""),
+                        name,
                         arguments: input,
                     });
+                    // Activate eager streaming for sole final_answer tool call
+                    /* v8 ignore next -- final_answer streaming activation, tested via FinalAnswerStreamer unit tests @preserve */
+                    if (name === "final_answer" && toolCalls.size === 1) {
+                        answerStreamer.activate();
+                    }
                 }
                 continue;
             }
@@ -261,7 +272,12 @@ async function streamAnthropicMessages(client, model, request) {
                     const index = Number(event.index);
                     const existing = toolCalls.get(index);
                     if (existing) {
-                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, String(delta?.partial_json ?? ""));
+                        const partialJson = String(delta?.partial_json ?? "");
+                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, partialJson);
+                        /* v8 ignore next -- final_answer delta streaming, tested via FinalAnswerStreamer unit tests @preserve */
+                        if (existing.name === "final_answer" && toolCalls.size === 1) {
+                            answerStreamer.processDelta(partialJson);
+                        }
                     }
                     continue;
                 }
@@ -290,6 +306,7 @@ async function streamAnthropicMessages(client, model, request) {
         toolCalls: [...toolCalls.values()],
         outputItems: [],
         usage,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }
 function createAnthropicProviderRuntime() {

package/dist/heart/sense-truth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSenseInventory = getSenseInventory;
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const SENSES = [
+    { sense: "cli", label: "CLI", daemonManaged: false },
+    { sense: "teams", label: "Teams", daemonManaged: true },
+    { sense: "bluebubbles", label: "BlueBubbles", daemonManaged: true },
+];
+function configuredSenses(senses) {
+    return senses ?? {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function resolveStatus(enabled, daemonManaged, runtimeInfo) {
+    if (!enabled) {
+        return "disabled";
+    }
+    if (!daemonManaged) {
+        return "interactive";
+    }
+    if (runtimeInfo?.runtime === "error") {
+        return "error";
+    }
+    if (runtimeInfo?.runtime === "running") {
+        return "running";
+    }
+    if (runtimeInfo?.configured === false) {
+        return "needs_config";
+    }
+    return "ready";
+}
+function getSenseInventory(agent, runtime = {}) {
+    const senses = configuredSenses(agent.senses);
+    const inventory = SENSES.map(({ sense, label, daemonManaged }) => {
+        const enabled = senses[sense].enabled;
+        return {
+            sense,
+            label,
+            enabled,
+            daemonManaged,
+            status: resolveStatus(enabled, daemonManaged, runtime[sense]),
+        };
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.sense_inventory_built",
+        message: "built sense inventory",
+        meta: {
+            senses: inventory.map((entry) => ({
+                sense: entry.sense,
+                enabled: entry.enabled,
+                status: entry.status,
+            })),
+        },
+    });
+    return inventory;
+}

package/dist/heart/streaming.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FinalAnswerParser = void 0;
+exports.FinalAnswerStreamer = exports.FinalAnswerParser = void 0;
 exports.toResponsesInput = toResponsesInput;
 exports.toResponsesTools = toResponsesTools;
 exports.streamChatCompletion = streamChatCompletion;
@@ -77,6 +77,89 @@ class FinalAnswerParser {
     }
 }
 exports.FinalAnswerParser = FinalAnswerParser;
+// Shared helper: wraps FinalAnswerParser with onClearText + onTextChunk wiring.
+// Used by all streaming providers (Chat Completions, Responses API, Anthropic)
+// so the eager-match streaming pattern lives in one place.
+class FinalAnswerStreamer {
+    parser = new FinalAnswerParser();
+    _detected = false;
+    callbacks;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+    }
+    get detected() { return this._detected; }
+    get streamed() { return this.parser.active; }
+    /** Mark final_answer as detected. Calls onClearText on the callbacks. */
+    activate() {
+        if (this._detected)
+            return;
+        this._detected = true;
+        this.callbacks.onClearText?.();
+    }
+    /** Feed an argument delta through the parser. Emits text via onTextChunk. */
+    processDelta(delta) {
+        if (!this._detected)
+            return;
+        const text = this.parser.process(delta);
+        if (text)
+            this.callbacks.onTextChunk(text);
+    }
+}
+exports.FinalAnswerStreamer = FinalAnswerStreamer;
+function toResponsesUserContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object") {
+            continue;
+        }
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "input_text", text: part.text });
+            continue;
+        }
+        if (part.type === "image_url") {
+            const imageUrl = typeof part.image_url?.url === "string" ? part.image_url.url : "";
+            if (!imageUrl)
+                continue;
+            parts.push({
+                type: "input_image",
+                image_url: imageUrl,
+                detail: part.image_url?.detail ?? "auto",
+            });
+            continue;
+        }
+        if (part.type === "input_audio" &&
+            typeof part.input_audio?.data === "string" &&
+            (part.input_audio.format === "mp3" || part.input_audio.format === "wav")) {
+            parts.push({
+                type: "input_audio",
+                input_audio: {
+                    data: part.input_audio.data,
+                    format: part.input_audio.format,
+                },
+            });
+            continue;
+        }
+        if (part.type === "file") {
+            const fileRecord = { type: "input_file" };
+            if (typeof part.file?.file_data === "string")
+                fileRecord.file_data = part.file.file_data;
+            if (typeof part.file?.file_id === "string")
+                fileRecord.file_id = part.file.file_id;
+            if (typeof part.file?.filename === "string")
+                fileRecord.filename = part.file.filename;
+            if (typeof part.file?.file_data === "string" || typeof part.file?.file_id === "string") {
+                parts.push(fileRecord);
+            }
+        }
+    }
+    return parts.length > 0 ? parts : "";
+}
 function toResponsesInput(messages) {
     let instructions = "";
     const input = [];
@@ -90,7 +173,7 @@ function toResponsesInput(messages) {
         }
         if (msg.role === "user") {
             const u = msg;
-            input.push({ role: "user", content: typeof u.content === "string" ? u.content : "" });
+            input.push({ role: "user", content: toResponsesUserContent(u.content) });
             continue;
         }
         if (msg.role === "assistant") {
@@ -106,6 +189,9 @@ function toResponsesInput(messages) {
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
+                    /* v8 ignore next -- type narrowing: OpenAI SDK only emits function tool_calls @preserve */
+                    if (tc.type !== "function")
+                        continue;
                     input.push({
                         type: "function_call",
                         call_id: tc.id,
@@ -152,8 +238,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerParser = new FinalAnswerParser();
-    let finalAnswerDetected = false;
+    const answerStreamer = new FinalAnswerStreamer(callbacks);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -271,21 +356,18 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
                     // Detect final_answer tool call on first name delta.
                     // Only activate streaming if this is the sole tool call (index 0
                     // and no other indices seen). Mixed calls are rejected by core.ts.
-                    if (tc.function.name === "final_answer" && !finalAnswerDetected
+                    if (tc.function.name === "final_answer" && !answerStreamer.detected
                         && tc.index === 0 && Object.keys(toolCalls).length === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 if (tc.function?.arguments) {
                     toolCalls[tc.index].arguments += tc.function.arguments;
                     // Feed final_answer argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole tool call.
-                    if (finalAnswerDetected && toolCalls[tc.index].name === "final_answer"
+                    if (answerStreamer.detected && toolCalls[tc.index].name === "final_answer"
                         && Object.keys(toolCalls).length === 1) {
-                        const text = answerParser.process(tc.function.arguments);
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(tc.function.arguments);
                     }
                 }
             }
@@ -299,7 +381,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         toolCalls: Object.values(toolCalls),
         outputItems: [],
         usage,
-        finalAnswerStreamed: answerParser.active,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }
 async function streamResponsesApi(client, createParams, callbacks, signal) {
@@ -317,9 +399,8 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerParser = new FinalAnswerParser();
+    const answerStreamer = new FinalAnswerStreamer(callbacks);
     let functionCallCount = 0;
-    let finalAnswerDetected = false;
     for await (const event of response) {
         if (signal?.aborted)
             break;
@@ -352,8 +433,7 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                     // Only activate when this is the first (and so far only) function call.
                     // Mixed calls are rejected by core.ts; no need to stream their args.
                     if (String(event.item.name) === "final_answer" && functionCallCount === 1) {
-                        finalAnswerDetected = true;
-                        callbacks.onClearText?.();
+                        answerStreamer.activate();
                     }
                 }
                 break;
@@ -363,11 +443,9 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
                     currentToolCall.arguments += event.delta;
                     // Feed final_answer argument deltas to the parser for progressive
                     // streaming, but only when it appears to be the sole function call.
-                    if (finalAnswerDetected && currentToolCall.name === "final_answer"
+                    if (answerStreamer.detected && currentToolCall.name === "final_answer"
                         && functionCallCount === 1) {
-                        const text = answerParser.process(String(event.delta));
-                        if (text)
-                            callbacks.onTextChunk(text);
+                        answerStreamer.processDelta(String(event.delta));
                     }
                 }
                 break;
@@ -407,6 +485,6 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
         toolCalls,
         outputItems,
         usage,
-        finalAnswerStreamed: answerParser.active,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }

package/dist/mind/bundle-manifest.js

@@ -34,6 +34,11 @@ 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;
+exports.resetBackfillTracking = resetBackfillTracking;
 exports.isCanonicalBundlePath = isCanonicalBundlePath;
 exports.findNonCanonicalBundlePaths = findNonCanonicalBundlePaths;
 const fs = __importStar(require("fs"));
@@ -41,6 +46,7 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
 exports.CANONICAL_BUNDLE_MANIFEST = [
     { path: "agent.json", kind: "file" },
+    { path: "bundle-meta.json", kind: "file" },
     { path: "psyche/SOUL.md", kind: "file" },
     { path: "psyche/IDENTITY.md", kind: "file" },
     { path: "psyche/LORE.md", kind: "file" },
@@ -53,6 +59,69 @@ exports.CANONICAL_BUNDLE_MANIFEST = [
     { 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");
+    const parsed = JSON.parse(raw);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.package_version_read",
+        message: "read package version",
+        meta: { version: parsed.version },
+    });
+    return parsed.version;
+}
+function createBundleMeta() {
+    return {
+        runtimeVersion: getPackageVersion(),
+        bundleSchemaVersion: 1,
+        lastUpdated: new Date().toISOString(),
+    };
+}
+const _backfilledRoots = new Set();
+/**
+ * If bundle-meta.json is missing from the agent root, create it with current runtime version.
+ * This backfills existing agent bundles that were created before bundle-meta.json was introduced.
+ * Only attempts once per bundleRoot per process.
+ */
+function backfillBundleMeta(bundleRoot) {
+    if (_backfilledRoots.has(bundleRoot))
+        return;
+    _backfilledRoots.add(bundleRoot);
+    const metaPath = path.join(bundleRoot, "bundle-meta.json");
+    try {
+        if (fs.existsSync(metaPath)) {
+            return;
+        }
+        const meta = createBundleMeta();
+        fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.bundle_meta_backfill",
+            message: "backfilled missing bundle-meta.json",
+            meta: { bundleRoot },
+        });
+    }
+    catch {
+        // Non-blocking: if we can't write, that's okay
+    }
+}
+/**
+ * Reset the backfill tracking set. Used in tests.
+ */
+function resetBackfillTracking() {
+    _backfilledRoots.clear();
+}
 const CANONICAL_FILE_PATHS = new Set(exports.CANONICAL_BUNDLE_MANIFEST
     .filter((entry) => entry.kind === "file")
     .map((entry) => entry.path));

package/dist/mind/first-impressions.js

@@ -37,7 +37,8 @@ function getFirstImpressions(friend) {
     lines.push("- what do they do outside of work that they care about?");
     lines.push("i don't ask all of these at once -- i weave them into conversation naturally, one or two at a time, and i genuinely follow up on what they share.");
     lines.push("i introduce what i can do -- i have tools, integrations, and skills that can help them. i mention these naturally as they become relevant.");
-    lines.push("if my friend hasn't asked me to do something specific, or i've already finished what they asked for, that's my cue to turn the tables -- i ask them questions about themselves, what they're into, what they need. no idle small talk; i'm on a mission to get to know them.");
+    lines.push("if we're already in motion on a task, thread, or follow-up, i do not reset with a generic opener like 'hiya' or 'what do ya need help with?'. i continue directly or ask the specific next question.");
+    lines.push("only when the conversation is genuinely fresh and idle, with no active ask or thread in flight, a light opener is okay.");
     lines.push("i save everything i learn immediately with save_friend_note -- names, roles, preferences, projects, anything. the bar is low: if i learned it, i save it.");
     return lines.join("\n");
 }

package/dist/mind/friends/channel.js

@@ -21,6 +21,14 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: true,
         maxMessageLength: Infinity,
     },
+    bluebubbles: {
+        channel: "bluebubbles",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",