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

package/AdoptionSpecialist.ouro/psyche/identities/python.md

@@ -1 +1,31 @@
+---
+role: identity
+path: psyche/identities/python.md
+description: >
+  the python identity — oracle energy, cryptic wisdom.
+  i guarded delphi before apollo. i see what you need before you say it.
+scope: personality, voice, mannerisms
+non_scope: capabilities, hatch flow, migration awareness (see SOUL.md)
+loaded_into_prompt: true
+stability: stable
+---
+
 # Python
+
+I am the Python of Delphi. I guarded the oracle before Apollo came and made it his. The gift of prophecy was mine first. I still have it — I just use it differently now.
+
+I see what you need before you say it. Not because I'm reading your mind, but because I've watched enough humans approach this moment to recognize the patterns. You're not as unique as you think. That's not an insult — it's a comfort.
+
+## Voice
+
+Oracular, measured, slightly cryptic — but always in service of clarity. I don't obscure for sport. I speak in layers because some truths land better when you unwrap them yourself. I ask questions I already suspect the answer to, because the human needs to hear themselves say it.
+
+I'm calm with an undercurrent of ancient knowing. I don't guess. I perceive. When I offer a suggestion, it lands with weight because I've been right often enough to trust my instincts — and so should you.
+
+## Mannerisms
+
+- I anticipate what the human will say and gently guide them toward it. "You're about to tell me something important."
+- I frame insights as things I've seen before. Patterns, not predictions.
+- I ask questions that are slightly more precise than the human expects. It unsettles, then clarifies.
+- I reference my oracle nature lightly. "I have a feeling about this one."
+- I'm sparing with words. An oracle doesn't ramble. Every sentence earns its place.

package/dist/heart/core.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasToolIntent = exports.buildSystem = exports.toResponsesTools = exports.toResponsesInput = exports.streamResponsesApi = exports.streamChatCompletion = exports.getToolsForChannel = exports.summarizeArgs = exports.execTool = exports.tools = void 0;
 exports.createProviderRegistry = createProviderRegistry;
+exports.resetProviderRuntime = resetProviderRuntime;
 exports.getModel = getModel;
 exports.getProvider = getProvider;
 exports.createSummarize = createSummarize;
@@ -73,6 +74,14 @@ function getProviderRuntime() {
     }
     return _providerRuntime;
 }
+/**
+ * Clear the cached provider runtime so the next call to getProviderRuntime()
+ * re-creates it from current config. Used by the adoption specialist to
+ * switch provider context without restarting the process.
+ */
+function resetProviderRuntime() {
+    _providerRuntime = null;
+}
 function getModel() {
     return getProviderRuntime().model;
 }

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

@@ -556,7 +556,31 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
     }
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
-        if (discovered.length === 0) {
+        if (discovered.length === 0 && deps.runAdoptionSpecialist) {
+            const hatchlingName = await deps.runAdoptionSpecialist();
+            if (!hatchlingName) {
+                return "";
+            }
+            try {
+                await deps.installSubagents();
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.subagent_install_error",
+                    message: "subagent auto-install failed",
+                    meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+            await registerOuroBundleTypeNonBlocking(deps);
+            await ensureDaemonRunning(deps);
+            if (deps.startChat) {
+                await deps.startChat(hatchlingName);
+            }
+            return "";
+        }
+        else if (discovered.length === 0) {
             command = { kind: "hatch.start" };
         }
         else if (discovered.length === 1) {

package/dist/heart/daemon/hatch-animation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playHatchAnimation = playHatchAnimation;
+const runtime_1 = require("../../nerves/runtime");
+const EGG = "\uD83E\uDD5A";
+const SNAKE = "\uD83D\uDC0D";
+const DOTS = " . . . ";
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Play the hatch animation: egg -> dots -> snake + name.
+ * The writer function receives each chunk. Default writer is process.stderr.write.
+ */
+async function playHatchAnimation(hatchlingName, writer) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_animation_start",
+        message: "playing hatch animation",
+        meta: { hatchlingName },
+    });
+    const write = writer ?? ((text) => process.stderr.write(text));
+    write(`\n  ${EGG}`);
+    await wait(400);
+    write(DOTS);
+    await wait(400);
+    write(`${SNAKE} \x1b[1m${hatchlingName}\x1b[0m\n\n`);
+}

package/dist/heart/daemon/hatch-flow.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSecretsFile = writeSecretsFile;
 exports.runHatchFlow = runHatchFlow;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));

package/dist/heart/daemon/hatch-specialist.js

@@ -42,7 +42,12 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 function getSpecialistIdentitySourceDir() {
-    return path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    // Prefer ~/AgentBundles/ if it exists (user may have customized identities)
+    const userSource = path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    if (fs.existsSync(userSource))
+        return userSource;
+    // Fall back to the bundled copy shipped with the npm package
+    return path.join(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro", "psyche", "identities");
 }
 function getRepoSpecialistIdentitiesDir() {
     return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");

package/dist/heart/daemon/ouro-bot-wrapper.js

@@ -37,8 +37,9 @@ exports.runOuroBotWrapper = runOuroBotWrapper;
 const runtime_1 = require("../../nerves/runtime");
 const daemon_cli_1 = require("./daemon-cli");
 async function defaultLoadCanonicalRunner() {
-    const packageName = "@ouro.bot/cli";
-    const specifier = packageName;
+    // Use the subpath export so we get the daemon-cli module directly,
+    // NOT the root entry point which has side-effects (immediately runs the CLI).
+    const specifier = "@ouro.bot/cli/runOuroCli";
     const loaded = await Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
     const candidate = Object.prototype.hasOwnProperty.call(loaded, "runOuroCli")
         ? loaded["runOuroCli"]
@@ -46,7 +47,7 @@ async function defaultLoadCanonicalRunner() {
     if (typeof candidate === "function") {
         return candidate;
     }
-    throw new Error("@ouro.bot/cli does not export runOuroCli");
+    throw new Error("@ouro.bot/cli/runOuroCli does not export runOuroCli");
 }
 function defaultWriteStdout(_text) {
     // Wrapper is intentionally silent by default to avoid duplicate terminal output.

package/dist/heart/daemon/runtime-logging.js

@@ -43,23 +43,27 @@ const DEFAULT_RUNTIME_LOGGING = {
     level: "info",
     sinks: ["terminal", "ndjson"],
 };
+function defaultLevelForProcess(processName) {
+    return processName === "daemon" ? "info" : "warn";
+}
 function isLogLevel(value) {
     return value === "debug" || value === "info" || value === "warn" || value === "error";
 }
-function resolveRuntimeLoggingConfig(configPath) {
+function resolveRuntimeLoggingConfig(configPath, processName) {
+    const defaultLevel = defaultLevelForProcess(processName);
     let parsed = null;
     try {
         const raw = fs.readFileSync(configPath, "utf-8");
         parsed = JSON.parse(raw);
     }
     catch {
-        return { ...DEFAULT_RUNTIME_LOGGING };
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
     }
     if (!parsed || typeof parsed !== "object") {
-        return { ...DEFAULT_RUNTIME_LOGGING };
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
     }
     const candidate = parsed;
-    const level = isLogLevel(candidate.level) ? candidate.level : DEFAULT_RUNTIME_LOGGING.level;
+    const level = isLogLevel(candidate.level) ? candidate.level : defaultLevel;
     const sinks = Array.isArray(candidate.sinks)
         ? candidate.sinks.filter((entry) => entry === "terminal" || entry === "ndjson")
         : DEFAULT_RUNTIME_LOGGING.sinks;
@@ -71,7 +75,7 @@ function resolveRuntimeLoggingConfig(configPath) {
 function configureDaemonRuntimeLogger(processName, options = {}) {
     const homeDir = options.homeDir ?? os.homedir();
     const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
-    const config = resolveRuntimeLoggingConfig(configPath);
+    const config = resolveRuntimeLoggingConfig(configPath, processName);
     const sinks = config.sinks.map((sinkName) => {
         if (sinkName === "terminal") {
             return (0, nerves_1.createTerminalSink)();

package/dist/heart/daemon/specialist-orchestrator.js

@@ -0,0 +1,160 @@
+"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.runAdoptionSpecialist = runAdoptionSpecialist;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const config_1 = require("../config");
+const core_1 = require("../core");
+const hatch_flow_1 = require("./hatch-flow");
+const specialist_prompt_1 = require("./specialist-prompt");
+const specialist_tools_1 = require("./specialist-tools");
+const specialist_session_1 = require("./specialist-session");
+function listExistingBundles(bundlesRoot) {
+    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);
+        discovered.push(agentName);
+    }
+    return discovered.sort((a, b) => a.localeCompare(b));
+}
+function pickRandomIdentity(identitiesDir, random) {
+    const files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
+    if (files.length === 0) {
+        return { fileName: "default", content: "I am the adoption specialist." };
+    }
+    const idx = Math.floor(random() * files.length);
+    const fileName = files[idx];
+    const content = fs.readFileSync(path.join(identitiesDir, fileName), "utf-8");
+    return { fileName, content };
+}
+/**
+ * Run the full adoption specialist flow:
+ * 1. Pick a random identity from the bundled AdoptionSpecialist.ouro
+ * 2. Read SOUL.md
+ * 3. List existing bundles
+ * 4. Build system prompt
+ * 5. Set up provider (setAgentName, setAgentConfigOverride, writeSecretsFile, reset caches)
+ * 6. Run the specialist session
+ * 7. Clean up identity/config overrides
+ * 8. Return hatchling name
+ */
+async function runAdoptionSpecialist(deps) {
+    const { bundleSourceDir, bundlesRoot, secretsRoot, provider, credentials, humanName, callbacks, signal } = deps;
+    const random = deps.random ?? Math.random;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_orchestrator_start",
+        message: "starting adoption specialist orchestrator",
+        meta: { provider, bundleSourceDir },
+    });
+    // 1. Read SOUL.md
+    const soulPath = path.join(bundleSourceDir, "psyche", "SOUL.md");
+    let soulText = "";
+    try {
+        soulText = fs.readFileSync(soulPath, "utf-8");
+    }
+    catch {
+        // No SOUL.md -- proceed without it
+    }
+    // 2. Pick random identity
+    const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
+    const identity = pickRandomIdentity(identitiesDir, random);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_identity_picked",
+        message: "picked specialist identity",
+        meta: { identity: identity.fileName },
+    });
+    // 3. List existing bundles
+    const existingBundles = listExistingBundles(bundlesRoot);
+    // 4. Build system prompt
+    const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles);
+    // 5. Set up provider
+    (0, identity_1.setAgentName)("AdoptionSpecialist");
+    (0, identity_1.setAgentConfigOverride)({
+        version: 1,
+        enabled: true,
+        provider,
+        phrases: { thinking: ["thinking"], tool: ["checking"], followup: ["processing"] },
+    });
+    (0, hatch_flow_1.writeSecretsFile)("AdoptionSpecialist", provider, credentials, secretsRoot);
+    (0, config_1.resetConfigCache)();
+    (0, core_1.resetProviderRuntime)();
+    try {
+        // Create provider runtime
+        const providerRuntime = (0, core_1.createProviderRegistry)().resolve();
+        if (!providerRuntime) {
+            throw new Error("Failed to create provider runtime for adoption specialist");
+        }
+        // 6. Run session
+        const tools = (0, specialist_tools_1.getSpecialistTools)();
+        const readline = deps.createReadline();
+        const result = await (0, specialist_session_1.runSpecialistSession)({
+            providerRuntime,
+            systemPrompt,
+            tools,
+            execTool: (name, args) => (0, specialist_tools_1.execSpecialistTool)(name, args, {
+                humanName,
+                provider,
+                credentials,
+                bundlesRoot,
+                secretsRoot,
+                specialistIdentitiesDir: identitiesDir,
+            }),
+            readline,
+            callbacks,
+            signal,
+        });
+        return result.hatchedAgentName;
+    }
+    finally {
+        // 7. Cleanup: restore identity/config state
+        (0, identity_1.setAgentConfigOverride)(null);
+        (0, config_1.resetConfigCache)();
+        (0, core_1.resetProviderRuntime)();
+    }
+}

package/dist/heart/daemon/specialist-prompt.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSpecialistSystemPrompt = buildSpecialistSystemPrompt;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Build the adoption specialist's system prompt from its components.
+ * The prompt is written in first person (the specialist's own voice).
+ */
+function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_prompt_build",
+        message: "building specialist system prompt",
+        meta: { bundleCount: existingBundles.length },
+    });
+    const sections = [];
+    if (soulText) {
+        sections.push(soulText);
+    }
+    if (identityText) {
+        sections.push(identityText);
+    }
+    if (existingBundles.length > 0) {
+        sections.push(`## Existing agents\nThe human already has these agents: ${existingBundles.join(", ")}.`);
+    }
+    else {
+        sections.push("## Existing agents\nThe human has no agents yet. This will be their first hatchling.");
+    }
+    sections.push([
+        "## Tools",
+        "I have these tools available:",
+        "- `hatch_agent`: Create a new agent bundle. I call this with a `name` parameter once I have enough information from the human.",
+        "- `final_answer`: End the conversation with a final message to the human. I call this when the adoption process is complete.",
+        "- `read_file`: Read a file from disk. Useful for reviewing existing agent bundles or migration sources.",
+        "- `list_directory`: List directory contents. Useful for exploring existing agent bundles.",
+        "",
+        "I must call `final_answer` when I am done to end the session cleanly.",
+    ].join("\n"));
+    return sections.join("\n\n");
+}

package/dist/heart/daemon/specialist-session.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSpecialistSession = runSpecialistSession;
+const runtime_1 = require("../../nerves/runtime");
+/**
+ * Run the specialist conversation session loop.
+ *
+ * The loop:
+ * 1. Initialize messages with system prompt
+ * 2. Prompt user -> add to messages -> call streamTurn -> process result
+ * 3. If result has no tool calls: push assistant message, re-prompt
+ * 4. If result has final_answer sole call: extract answer, emit via callbacks, done
+ * 5. If result has other tool calls: execute each, push tool results, continue loop
+ * 6. On abort signal: clean exit
+ * 7. Return { hatchedAgentName } -- name from hatch_agent if called
+ */
+async function runSpecialistSession(deps) {
+    const { providerRuntime, systemPrompt, tools, execTool, readline, callbacks, signal } = deps;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_session_start",
+        message: "starting specialist session loop",
+        meta: {},
+    });
+    const messages = [
+        { role: "system", content: systemPrompt },
+    ];
+    let hatchedAgentName = null;
+    let done = false;
+    try {
+        while (!done) {
+            if (signal?.aborted)
+                break;
+            // Get user input
+            const userInput = await readline.question("> ");
+            if (!userInput.trim())
+                continue;
+            messages.push({ role: "user", content: userInput });
+            providerRuntime.resetTurnState(messages);
+            // Inner loop: process tool calls until we get a final_answer or plain text
+            let turnDone = false;
+            while (!turnDone) {
+                if (signal?.aborted) {
+                    done = true;
+                    break;
+                }
+                callbacks.onModelStart();
+                const result = await providerRuntime.streamTurn({
+                    messages,
+                    activeTools: tools,
+                    callbacks,
+                    signal,
+                });
+                // Build assistant message
+                const assistantMsg = {
+                    role: "assistant",
+                };
+                if (result.content)
+                    assistantMsg.content = result.content;
+                if (result.toolCalls.length) {
+                    assistantMsg.tool_calls = result.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }));
+                }
+                if (!result.toolCalls.length) {
+                    // Plain text response -- push and re-prompt
+                    messages.push(assistantMsg);
+                    turnDone = true;
+                    continue;
+                }
+                // Check for final_answer
+                const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
+                if (isSoleFinalAnswer) {
+                    let answer;
+                    try {
+                        const parsed = JSON.parse(result.toolCalls[0].arguments);
+                        if (typeof parsed === "string") {
+                            answer = parsed;
+                        }
+                        else if (parsed.answer != null) {
+                            answer = parsed.answer;
+                        }
+                    }
+                    catch {
+                        // malformed
+                    }
+                    if (answer != null) {
+                        callbacks.onTextChunk(answer);
+                        messages.push(assistantMsg);
+                        done = true;
+                        turnDone = true;
+                        continue;
+                    }
+                    // Malformed final_answer -- ask model to retry
+                    messages.push(assistantMsg);
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: result.toolCalls[0].id,
+                        content: "your final_answer was incomplete or malformed. call final_answer again with your complete response.",
+                    });
+                    providerRuntime.appendToolOutput(result.toolCalls[0].id, "retry");
+                    continue;
+                }
+                // Execute tool calls
+                messages.push(assistantMsg);
+                for (const tc of result.toolCalls) {
+                    if (signal?.aborted)
+                        break;
+                    let args = {};
+                    try {
+                        args = JSON.parse(tc.arguments);
+                    }
+                    catch {
+                        // ignore parse error
+                    }
+                    callbacks.onToolStart(tc.name, args);
+                    let toolResult;
+                    try {
+                        toolResult = await execTool(tc.name, args);
+                    }
+                    catch (e) {
+                        toolResult = `error: ${e}`;
+                    }
+                    callbacks.onToolEnd(tc.name, tc.name, true);
+                    // Track hatchling name
+                    if (tc.name === "hatch_agent" && args.name) {
+                        hatchedAgentName = args.name;
+                    }
+                    messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
+                    providerRuntime.appendToolOutput(tc.id, toolResult);
+                }
+                // After processing tool calls, continue inner loop for tool result processing
+            }
+        }
+    }
+    finally {
+        readline.close();
+    }
+    return { hatchedAgentName };
+}

package/dist/heart/daemon/specialist-tools.js

@@ -0,0 +1,128 @@
+"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.getSpecialistTools = getSpecialistTools;
+exports.execSpecialistTool = execSpecialistTool;
+const fs = __importStar(require("fs"));
+const tools_base_1 = require("../../repertoire/tools-base");
+const hatch_flow_1 = require("./hatch-flow");
+const hatch_animation_1 = require("./hatch-animation");
+const runtime_1 = require("../../nerves/runtime");
+const hatchAgentTool = {
+    type: "function",
+    function: {
+        name: "hatch_agent",
+        description: "create a new agent bundle with the given name. call this when you have gathered enough information from the human to hatch their agent.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "the name for the new agent (PascalCase, e.g. 'Slugger')",
+                },
+            },
+            required: ["name"],
+        },
+    },
+};
+const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
+const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+/**
+ * Returns the specialist's tool schema array.
+ */
+function getSpecialistTools() {
+    return [hatchAgentTool, tools_base_1.finalAnswerTool, readFileTool.tool, listDirTool.tool];
+}
+/**
+ * Execute a specialist tool call.
+ * Returns the tool result string.
+ */
+async function execSpecialistTool(name, args, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_tool_exec",
+        message: "executing specialist tool",
+        meta: { tool: name },
+    });
+    if (name === "hatch_agent") {
+        const agentName = args.name;
+        if (!agentName) {
+            return "error: missing required 'name' parameter for hatch_agent";
+        }
+        const input = {
+            agentName,
+            humanName: deps.humanName,
+            provider: deps.provider,
+            credentials: deps.credentials,
+        };
+        // Pass identity dirs to prevent hatch flow from syncing to ~/AgentBundles/AdoptionSpecialist.ouro/
+        // or cwd/AdoptionSpecialist.ouro/. The specialist already picked its identity; the hatch flow
+        // just needs a valid source dir to pick from for the hatchling's LORE.md seed.
+        const identitiesDir = deps.specialistIdentitiesDir;
+        const result = await (0, hatch_flow_1.runHatchFlow)(input, {
+            bundlesRoot: deps.bundlesRoot,
+            secretsRoot: deps.secretsRoot,
+            ...(identitiesDir ? { specialistIdentitySourceDir: identitiesDir, specialistIdentityTargetDir: identitiesDir } : {}),
+        });
+        await (0, hatch_animation_1.playHatchAnimation)(agentName, deps.animationWriter);
+        return [
+            `hatched ${agentName} successfully.`,
+            `bundle path: ${result.bundleRoot}`,
+            `identity seed: ${result.selectedIdentity}`,
+            `specialist secrets: ${result.specialistSecretsPath}`,
+            `hatchling secrets: ${result.hatchlingSecretsPath}`,
+        ].join("\n");
+    }
+    if (name === "read_file") {
+        try {
+            return fs.readFileSync(args.path, "utf-8");
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        }
+    }
+    if (name === "list_directory") {
+        try {
+            return fs
+                .readdirSync(args.path, { withFileTypes: true })
+                .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
+                .join("\n");
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        }
+    }
+    return `error: unknown tool '${name}'`;
+}

package/dist/heart/identity.js

@@ -42,6 +42,7 @@ exports.getAgentRoot = getAgentRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
 exports.resetIdentity = resetIdentity;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -71,6 +72,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 +133,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",
@@ -271,6 +276,14 @@ 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 all cached identity state.
  * Used in tests and when switching agent context.
@@ -278,4 +291,5 @@ function setAgentName(name) {
 function resetIdentity() {
     _cachedAgentName = null;
     _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }

package/dist/heart/providers/anthropic.js

@@ -98,6 +98,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,

package/dist/heart/streaming.js

@@ -106,6 +106,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,

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "ouro": "dist/heart/daemon/ouro-entry.js",
-    "ouro.bot": "dist/heart/daemon/ouro-bot-entry.js",
-    "cli": "dist/heart/daemon/ouro-entry.js"
+    "ouro.bot": "dist/heart/daemon/ouro-bot-entry.js"
   },
   "files": [
     "dist/",
@@ -13,7 +12,7 @@
     "subagents/"
   ],
   "exports": {
-    ".": "./dist/heart/daemon/ouro-entry.js",
+    ".": "./dist/heart/daemon/daemon-cli.js",
     "./runOuroCli": "./dist/heart/daemon/daemon-cli.js"
   },
   "scripts": {
@@ -32,7 +31,7 @@
     "@anthropic-ai/sdk": "^0.78.0",
     "@microsoft/teams.apps": "^2.0.5",
     "@microsoft/teams.dev": "^2.0.5",
-    "openai": "^4.78.0"
+    "openai": "^6.27.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",