@ouro.bot/cli 0.1.0-alpha.26 → 0.1.0-alpha.28

package/changelog.json

@@ -1,6 +1,21 @@
 {
   "_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.28",
+      "changes": [
+        "Bare npx ouro.bot now stays aligned with the current alpha CLI track because the published ouro.bot wrapper is version-locked and republished alongside the CLI instead of lagging behind it.",
+        "Slugger no longer re-opens active iMessage task threads with generic greetings like 'hiya' when work is already in motion; fresh idle conversations can still start warmly.",
+        "BlueBubbles voice notes now use a harness-managed whisper.cpp transcription path for the current OpenAI, Anthropic, and MiniMax runtime contracts, including automatic local provisioning and truthful error notices when transcription cannot complete."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.27",
+      "changes": [
+        "The daemon now discovers all enabled agents in ~/AgentBundles, so ouro status and managed workers reflect every real agent instead of only slugger and ouroboros.",
+        "BlueBubbles typing now wraps the visible working phase correctly, and phrase updates from agent.json take effect on the next turn without requiring a restart."
+      ]
+    },
     {
       "version": "0.1.0-alpha.26",
       "changes": [

package/dist/heart/daemon/agent-discovery.js

@@ -0,0 +1,81 @@
+"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.listEnabledBundleAgents = listEnabledBundleAgents;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function listEnabledBundleAgents(options = {}) {
+    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const readdirSync = options.readdirSync ?? fs.readdirSync;
+    const readFileSync = options.readFileSync ?? fs.readFileSync;
+    let entries;
+    try {
+        entries = readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.agent_discovery_failed",
+            message: "failed to read bundle root for daemon agent discovery",
+            meta: { bundlesRoot },
+        });
+        return [];
+    }
+    const discovered = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const agentName = entry.name.slice(0, -5);
+        const configPath = path.join(bundlesRoot, entry.name, "agent.json");
+        let enabled = true;
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.enabled === "boolean") {
+                enabled = parsed.enabled;
+            }
+        }
+        catch {
+            continue;
+        }
+        if (enabled) {
+            discovered.push(agentName);
+        }
+    }
+    return discovered.sort((left, right) => left.localeCompare(right));
+}

package/dist/heart/daemon/daemon-cli.js

@@ -56,6 +56,7 @@ const specialist_prompt_1 = require("./specialist-prompt");
 const specialist_tools_1 = require("./specialist-tools");
 const runtime_metadata_1 = require("./runtime-metadata");
 const daemon_runtime_sync_1 = require("./daemon-runtime-sync");
+const agent_discovery_1 = require("./agent-discovery");
 const update_hooks_1 = require("./update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
@@ -596,36 +597,11 @@ async function defaultPromptInput(question) {
     }
 }
 function defaultListDiscoveredAgents() {
-    const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
-    let entries;
-    try {
-        entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const discovered = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
-            continue;
-        const agentName = entry.name.slice(0, -5);
-        const configPath = path.join(bundlesRoot, entry.name, "agent.json");
-        let enabled = true;
-        try {
-            const raw = fs.readFileSync(configPath, "utf-8");
-            const parsed = JSON.parse(raw);
-            if (typeof parsed.enabled === "boolean") {
-                enabled = parsed.enabled;
-            }
-        }
-        catch {
-            continue;
-        }
-        if (enabled) {
-            discovered.push(agentName);
-        }
-    }
-    return discovered.sort((left, right) => left.localeCompare(right));
+    return (0, agent_discovery_1.listEnabledBundleAgents)({
+        bundlesRoot: (0, identity_1.getAgentBundlesRoot)(),
+        readdirSync: fs.readdirSync,
+        readFileSync: fs.readFileSync,
+    });
 }
 async function defaultLinkFriendIdentity(command) {
     const fp = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "friends");

package/dist/heart/daemon/daemon-entry.js

@@ -9,6 +9,7 @@ const health_monitor_1 = require("./health-monitor");
 const task_scheduler_1 = require("./task-scheduler");
 const runtime_logging_1 = require("./runtime-logging");
 const sense_manager_1 = require("./sense-manager");
+const agent_discovery_1 = require("./agent-discovery");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -26,7 +27,7 @@ const socketPath = parseSocketPath(process.argv);
     message: "starting daemon entrypoint",
     meta: { socketPath },
 });
-const managedAgents = ["ouroboros", "slugger"];
+const managedAgents = (0, agent_discovery_1.listEnabledBundleAgents)();
 const processManager = new process_manager_1.DaemonProcessManager({
     agents: managedAgents.map((agent) => ({
         name: agent,

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

@@ -7,6 +7,26 @@ function wrapperPackageChanged(changedFiles) {
 }
 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,
@@ -16,7 +36,13 @@ function assessWrapperPublishSync(input) {
             component: "daemon",
             event: "daemon.wrapper_publish_guard_checked",
             message: "evaluated wrapper publish sync",
-            meta: { changed: false, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+            meta: {
+                changed: false,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
         });
         return result;
     }
@@ -30,7 +56,13 @@ function assessWrapperPublishSync(input) {
             component: "daemon",
             event: "daemon.wrapper_publish_guard_checked",
             message: "evaluated wrapper publish sync",
-            meta: { changed: true, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+            meta: {
+                changed: true,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
         });
         return result;
     }
@@ -42,7 +74,13 @@ function assessWrapperPublishSync(input) {
         component: "daemon",
         event: "daemon.wrapper_publish_guard_checked",
         message: "evaluated wrapper publish sync",
-        meta: { changed: true, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+        meta: {
+            changed: true,
+            localVersion: input.localVersion,
+            cliVersion: input.cliVersion,
+            publishedVersion: input.publishedVersion,
+            ok: result.ok,
+        },
     });
     return result;
 }

package/dist/heart/identity.js

@@ -43,6 +43,7 @@ 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"));
@@ -346,6 +347,13 @@ function setAgentName(name) {
 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.

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/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",

package/dist/senses/bluebubbles-client.js

@@ -196,7 +196,8 @@ function extractRepairData(payload) {
     return asRecord(record?.data) ?? record;
 }
 function providerSupportsAudioInput(provider) {
-    return provider === "azure" || provider === "openai-codex";
+    void provider;
+    return false;
 }
 async function resolveChatGuid(chat, config, channelConfig) {
     return chat.chatGuid

package/dist/senses/bluebubbles-media.js

@@ -62,6 +62,12 @@ const AUDIO_INPUT_FORMAT_BY_EXTENSION = {
     ".wav": "wav",
     ".mp3": "mp3",
 };
+const WHISPER_CPP_FORMULA = "whisper-cpp";
+const WHISPER_CPP_MODEL_NAME = "ggml-base.en.bin";
+const WHISPER_CPP_MODEL_URL = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${WHISPER_CPP_MODEL_NAME}`;
+const WHISPER_CPP_TOOLS_DIR = path.join(os.homedir(), ".agentstate", "tools", "whisper-cpp");
+const WHISPER_CPP_MODELS_DIR = path.join(WHISPER_CPP_TOOLS_DIR, "models");
+const WHISPER_CPP_MODEL_PATH = path.join(WHISPER_CPP_MODELS_DIR, WHISPER_CPP_MODEL_NAME);
 function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
     const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
     const url = new URL(endpoint.replace(/^\//, ""), root);
@@ -107,36 +113,123 @@ function audioFormatForInput(contentType, attachment) {
     const extension = path.extname(attachment?.transferName ?? "").toLowerCase();
     return AUDIO_INPUT_FORMAT_BY_CONTENT_TYPE[contentType ?? ""] ?? AUDIO_INPUT_FORMAT_BY_EXTENSION[extension];
 }
-async function transcribeAudioWithWhisper(params) {
+async function execFileText(file, args, timeout) {
+    return await new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(file, args, { timeout }, (error, stdout = "", stderr = "") => {
+            if (error) {
+                const detail = stderr.trim() || stdout.trim() || error.message;
+                reject(new Error(detail));
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveWhisperCppBinary(timeoutMs) {
+    try {
+        const existing = (await execFileText("which", ["whisper-cli"], timeoutMs)).trim();
+        if (existing) {
+            return existing;
+        }
+    }
+    catch {
+        // fall through to managed install
+    }
+    let prefix = "";
+    try {
+        prefix = (await execFileText("brew", ["--prefix", WHISPER_CPP_FORMULA], timeoutMs)).trim();
+        if (prefix) {
+            const candidate = path.join(prefix, "bin", "whisper-cli");
+            if (await pathExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch {
+        // fall through to managed install
+    }
+    await execFileText("brew", ["install", WHISPER_CPP_FORMULA], Math.max(timeoutMs, 300_000));
+    prefix = (await execFileText("brew", ["--prefix", WHISPER_CPP_FORMULA], timeoutMs)).trim();
+    if (!prefix) {
+        throw new Error("whisper.cpp installed but brew did not return a usable prefix");
+    }
+    const candidate = path.join(prefix, "bin", "whisper-cli");
+    if (!await pathExists(candidate)) {
+        throw new Error("whisper.cpp installed but whisper-cli binary is missing");
+    }
+    return candidate;
+}
+async function ensureWhisperCppModel(timeoutMs, fetchImpl) {
+    try {
+        await fs.access(WHISPER_CPP_MODEL_PATH);
+        return WHISPER_CPP_MODEL_PATH;
+    }
+    catch {
+        await fs.mkdir(WHISPER_CPP_MODELS_DIR, { recursive: true });
+        const response = await fetchImpl(WHISPER_CPP_MODEL_URL, {
+            method: "GET",
+            signal: AbortSignal.timeout(Math.max(timeoutMs, 300_000)),
+        });
+        if (!response.ok) {
+            throw new Error(`failed to download whisper.cpp model: HTTP ${response.status}`);
+        }
+        await fs.writeFile(WHISPER_CPP_MODEL_PATH, Buffer.from(await response.arrayBuffer()));
+        return WHISPER_CPP_MODEL_PATH;
+    }
+}
+async function convertAudioForWhisperCpp(sourcePath, outputPath, timeoutMs) {
+    try {
+        await execFileText("ffmpeg", ["-y", "-i", sourcePath, "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", outputPath], Math.max(timeoutMs, 120_000));
+        return;
+    }
+    catch (ffmpegError) {
+        try {
+            await execFileText("afconvert", ["-f", "WAVE", "-d", "LEI16@16000", "-c", "1", sourcePath, outputPath], Math.max(timeoutMs, 120_000));
+            return;
+        }
+        catch (afconvertError) {
+            const ffmpegReason = ffmpegError.message;
+            const afconvertReason = afconvertError.message;
+            throw new Error(`failed to prepare audio for whisper.cpp (ffmpeg: ${ffmpegReason}; afconvert: ${afconvertReason})`);
+        }
+    }
+}
+async function transcribeAudioWithWhisperCpp(params, modelFetchImpl = fetch) {
     const workDir = await fs.mkdtemp(path.join(os.tmpdir(), "ouro-bb-audio-"));
     const filename = sanitizeFilename(describeAttachment(params.attachment));
     const extension = fileExtensionForAudio(params.attachment, params.contentType);
     const audioPath = path.join(workDir, `${path.parse(filename).name}${extension}`);
+    const wavPath = path.join(workDir, `${path.parse(audioPath).name}.wav`);
+    const outputBase = path.join(workDir, path.parse(audioPath).name);
     try {
         await fs.writeFile(audioPath, params.buffer);
-        await new Promise((resolve, reject) => {
-            (0, node_child_process_1.execFile)("whisper", [
-                audioPath,
-                "--model",
-                "turbo",
-                "--output_dir",
-                workDir,
-                "--output_format",
-                "json",
-                "--verbose",
-                "False",
-            ], { timeout: Math.max(params.timeoutMs, 120000) }, (error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
-        });
-        const transcriptPath = path.join(workDir, `${path.parse(audioPath).name}.json`);
+        const whisperCliPath = await resolveWhisperCppBinary(params.timeoutMs);
+        const modelPath = await ensureWhisperCppModel(params.timeoutMs, modelFetchImpl);
+        await convertAudioForWhisperCpp(audioPath, wavPath, params.timeoutMs);
+        await execFileText(whisperCliPath, ["-m", modelPath, "-f", wavPath, "-oj", "-of", outputBase], Math.max(params.timeoutMs, 120_000));
+        const transcriptPath = `${outputBase}.json`;
         const raw = await fs.readFile(transcriptPath, "utf8");
         const parsed = JSON.parse(raw);
-        return typeof parsed.text === "string" ? parsed.text.trim() : "";
+        if (typeof parsed.text === "string") {
+            return parsed.text.trim();
+        }
+        if (Array.isArray(parsed.transcription)) {
+            return parsed.transcription
+                .map((entry) => (typeof entry?.text === "string" ? entry.text.trim() : ""))
+                .filter(Boolean)
+                .join(" ")
+                .trim();
+        }
+        return "";
     }
     finally {
         await fs.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
@@ -178,7 +271,8 @@ async function hydrateBlueBubblesAttachments(attachments, config, channelConfig,
         },
     });
     const fetchImpl = deps.fetchImpl ?? fetch;
-    const transcribeAudio = deps.transcribeAudio ?? transcribeAudioWithWhisper;
+    const modelFetchImpl = deps.modelFetchImpl ?? fetch;
+    const transcribeAudio = deps.transcribeAudio ?? ((params) => transcribeAudioWithWhisperCpp(params, modelFetchImpl));
     const preferAudioInput = deps.preferAudioInput ?? false;
     const inputParts = [];
     const transcriptAdditions = [];

package/dist/senses/bluebubbles.js

@@ -205,12 +205,12 @@ function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
                 return;
             }
             textBuffer = "";
+            await activity.finish();
             await client.sendText({
                 chat,
                 text: trimmed,
                 replyToMessageGuid,
             });
-            await activity.finish();
         },
         async finish() {
             await activity.finish();

package/dist/senses/debug-activity.js

@@ -36,15 +36,6 @@ function createDebugActivityController(options) {
         lastPhrase = phrase;
         return phrase;
     }
-    function ensureTyping(active) {
-        if (typingActive === active) {
-            return;
-        }
-        typingActive = active;
-        enqueue(active ? "typing_start" : "typing_stop", async () => {
-            await options.transport.setTyping(active);
-        });
-    }
     function setStatus(text) {
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
@@ -55,13 +46,20 @@ function createDebugActivityController(options) {
                 textLength: text.length,
             },
         });
-        ensureTyping(true);
+        const shouldStartTyping = !typingActive;
+        if (shouldStartTyping) {
+            typingActive = true;
+        }
         enqueue("status_update", async () => {
             if (statusMessageGuid) {
                 await options.transport.editStatus(statusMessageGuid, text);
-                return;
             }
-            statusMessageGuid = await options.transport.sendStatus(text);
+            else {
+                statusMessageGuid = await options.transport.sendStatus(text);
+            }
+            if (shouldStartTyping) {
+                await options.transport.setTyping(true);
+            }
         });
     }
     return {
@@ -100,7 +98,10 @@ function createDebugActivityController(options) {
                 await queue;
                 return;
             }
-            ensureTyping(false);
+            typingActive = false;
+            enqueue("typing_stop", async () => {
+                await options.transport.setTyping(false);
+            });
             await queue;
         },
     };

package/package.json

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