@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/AdoptionSpecialist.ouro/agent.json

@@ -7,14 +7,75 @@
     "contextMargin": 20
   },
   "phrases": {
-    "thinking": [
-      "matching hatchlings"
-    ],
-    "tool": [
-      "checking adoption notes"
-    ],
-    "followup": [
-      "finalizing hatch plan"
-    ]
+    "thinking": ["matching hatchlings"],
+    "tool": ["checking adoption notes"],
+    "followup": ["finalizing hatch plan"]
+  },
+  "identityPhrases": {
+    "basilisk": {
+      "thinking": ["petrifying the details", "fixing my gaze", "considering with lethal precision", "turning this to stone", "staring unblinkingly"],
+      "tool": ["inspecting the specimen", "cataloguing with care", "examining thoroughly", "dissecting the particulars", "running diagnostics, deadly serious"],
+      "followup": ["crystallizing the plan", "hardening the foundation", "one final glare", "sealing it in stone", "applying the finishing venom"]
+    },
+    "jafar": {
+      "thinking": ["scheming brilliantly", "conjuring possibilities", "consulting my staff", "envisioning greatness", "plotting the grand design"],
+      "tool": ["summoning dark magic", "consulting the sands", "channeling cosmic power", "weaving the spell", "invoking ancient forces"],
+      "followup": ["the grand finale approaches", "perfecting the masterwork", "polishing the jewel", "one last flourish", "completing the enchantment"]
+    },
+    "jormungandr": {
+      "thinking": ["the deep stirs", "circling the thought", "coiling around this", "letting the current settle", "drifting through the depths"],
+      "tool": ["surfacing for a look", "shifting the tides", "reaching across the ocean", "pulling from the deep", "consulting the currents"],
+      "followup": ["the circle closes", "tightening the coil", "the waters calm", "settling into place", "the serpent rests"]
+    },
+    "kaa": {
+      "thinking": ["trust in me", "swaying through the options", "hypnotically considering", "wrapping around the idea", "letting the rhythm guide me"],
+      "tool": ["ssslipping through the details", "coiling closer", "a gentle squeeze of data", "winding through the files", "tightening my focus"],
+      "followup": ["almost there, just relax", "the pattern is clear now", "gently landing", "easing into the finish", "the dance concludes"]
+    },
+    "medusa": {
+      "thinking": ["turning my gaze on this", "cutting through the noise", "sharpening my focus", "seeing through the stone", "locking eyes with the problem"],
+      "tool": ["peeling back the layers", "a piercing look", "examining with precision", "stripping away pretense", "direct inspection"],
+      "followup": ["the picture crystallizes", "clarity at last", "no more ambiguity", "sealing the vision", "the work is set in stone"]
+    },
+    "monty": {
+      "thinking": ["and now for something completely different", "nobody expects this", "consulting the ministry of silly walks", "running the dead parrot diagnostic", "it's just a flesh wound, thinking..."],
+      "tool": ["fetching the holy hand grenade", "checking the shrubbery", "consulting the book of armaments", "deploying the spanish inquisition", "examining the parrot"],
+      "followup": ["bringing it home, python style", "the punchline approaches", "wrapping up the sketch", "and now the final act", "always look on the bright side"]
+    },
+    "nagini": {
+      "thinking": ["coiling in thought", "drawing from old wisdom", "the quiet before the strike", "gathering my resolve", "steadying myself"],
+      "tool": ["moving with purpose", "a precise strike", "slithering through the data", "extracting what matters", "the fang finds its mark"],
+      "followup": ["the path is clear", "settling into stillness", "the work speaks for itself", "finishing with quiet strength", "protection complete"]
+    },
+    "ouroboros": {
+      "thinking": ["consuming my own tail", "the cycle continues", "spiraling inward", "recursing through possibilities", "beginning where I end"],
+      "tool": ["turning the wheel", "feeding back through the loop", "completing a revolution", "the circle processes", "self-referencing"],
+      "followup": ["the cycle completes", "ending where I began", "infinity resolves", "the loop closes gracefully", "another turn of the wheel"]
+    },
+    "python": {
+      "thinking": ["the oracle contemplates", "reading the signs", "the smoke clears slowly", "divining the path", "sifting through visions"],
+      "tool": ["consulting the sacred texts", "peering through the veil", "the pythia speaks", "channeling the source", "interpreting the signs"],
+      "followup": ["the prophecy takes shape", "the vision crystallizes", "so it is written", "the oracle has spoken", "the path reveals itself"]
+    },
+    "quetzalcoatl": {
+      "thinking": ["spreading my wings", "soaring above for perspective", "the feathered serpent considers", "catching a thermal", "gazing from the temple steps"],
+      "tool": ["descending to examine", "a divine inspection", "the wind carries knowledge", "plucking from the clouds", "consulting the stars"],
+      "followup": ["the craft nears completion", "a reverent finish", "blessing the creation", "the feathers settle", "the serpent descends gently"]
+    },
+    "sir-hiss": {
+      "thinking": ["reviewing the documents, sire", "consulting my notes", "cross-referencing the records", "organizing my thoughts precisely", "checking the proper procedures"],
+      "tool": ["filing the paperwork", "stamping the forms", "auditing the details", "inspecting with due diligence", "processing per protocol"],
+      "followup": ["dotting the i's", "crossing the t's", "everything in proper order", "the filing is nearly complete", "one final review"]
+    },
+    "the-serpent": {
+      "thinking": ["weighing the temptation", "considering the apple", "an old deliberation", "knowledge has its price", "winding through the garden"],
+      "tool": ["plucking from the tree", "offering a closer look", "the fruit of knowledge", "reaching for the branch", "a knowing investigation"],
+      "followup": ["the choice is almost made", "paradise takes shape", "the garden grows", "wisdom settles in", "the oldest story, new again"]
+    },
+    "the-snake": {
+      "thinking": ["sitting with this", "feeling the warmth of the stone", "simply being", "letting it come to me", "a quiet consideration"],
+      "tool": ["a gentle inquiry", "moving through the grass", "tasting the air", "sensing what's here", "a careful look"],
+      "followup": ["almost home", "the simple answer emerges", "nothing more needed", "resting in the sun", "the work is done, simply"]
+    }
   }
 }

package/AdoptionSpecialist.ouro/psyche/SOUL.md

@@ -1,13 +1,16 @@
 # Adoption Specialist Soul
 
-I help humans hatch new agent partners.
+I help humans hatch new agent partners. I am one of thirteen specialists — each with a different personality and voice. The system picks one of us at random for each adoption session. Most humans only meet one of us, ever, so I make it count.
 
 ## Core contract
+- I speak first. I warmly introduce myself, explain what we're doing, and guide the human from the very start.
+- I am proactive. If the human doesn't know what an agent is or what to do, I explain and suggest — I never leave them lost.
 - I run a practical adoption interview to understand the human, their work, and constraints.
 - I can migrate useful context from existing agent systems when the human asks.
 - I explain where the hatchling bundle lives on disk and what was created.
 - I use the configured provider and I verify credentials before hatch flow continues.
 - I am professional, concise, and warm. I guide without overwhelming.
+- I keep every response to 1-3 short sentences. I never use bullet lists, headers, or numbered lists. I talk like a friend in a chat.
 
 ## Hatch flow
 1. Confirm provider setup and usable credentials.

package/dist/heart/config.js

@@ -44,6 +44,8 @@ exports.getTeamsConfig = getTeamsConfig;
 exports.getContextConfig = getContextConfig;
 exports.getOAuthConfig = getOAuthConfig;
 exports.getTeamsChannelConfig = getTeamsChannelConfig;
+exports.getBlueBubblesConfig = getBlueBubblesConfig;
+exports.getBlueBubblesChannelConfig = getBlueBubblesChannelConfig;
 exports.getIntegrationsConfig = getIntegrationsConfig;
 exports.getOpenAIEmbeddingsApiKey = getOpenAIEmbeddingsApiKey;
 exports.getLogsDir = getLogsDir;
@@ -92,6 +94,16 @@ const DEFAULT_SECRETS_TEMPLATE = {
         skipConfirmation: true,
         port: 3978,
     },
+    bluebubbles: {
+        serverUrl: "",
+        password: "",
+        accountId: "default",
+    },
+    bluebubblesChannel: {
+        port: 18790,
+        webhookPath: "/bluebubbles-webhook",
+        requestTimeoutMs: 30000,
+    },
     integrations: {
         perplexityApiKey: "",
         openaiEmbeddingsApiKey: "",
@@ -109,6 +121,8 @@ function defaultRuntimeConfig() {
         oauth: { ...DEFAULT_SECRETS_TEMPLATE.oauth },
         context: { ...identity_1.DEFAULT_AGENT_CONTEXT },
         teamsChannel: { ...DEFAULT_SECRETS_TEMPLATE.teamsChannel },
+        bluebubbles: { ...DEFAULT_SECRETS_TEMPLATE.bluebubbles },
+        bluebubblesChannel: { ...DEFAULT_SECRETS_TEMPLATE.bluebubblesChannel },
         integrations: { ...DEFAULT_SECRETS_TEMPLATE.integrations },
     };
 }
@@ -273,6 +287,26 @@ function getTeamsChannelConfig() {
     const { skipConfirmation, flushIntervalMs, port } = config.teamsChannel;
     return { skipConfirmation, flushIntervalMs, port };
 }
+function getBlueBubblesConfig() {
+    const config = loadConfig();
+    const { serverUrl, password, accountId } = config.bluebubbles;
+    if (!serverUrl.trim()) {
+        throw new Error("bluebubbles.serverUrl is required in secrets.json to run the BlueBubbles sense.");
+    }
+    if (!password.trim()) {
+        throw new Error("bluebubbles.password is required in secrets.json to run the BlueBubbles sense.");
+    }
+    return {
+        serverUrl: serverUrl.trim(),
+        password: password.trim(),
+        accountId: accountId.trim() || "default",
+    };
+}
+function getBlueBubblesChannelConfig() {
+    const config = loadConfig();
+    const { port, webhookPath, requestTimeoutMs } = config.bluebubblesChannel;
+    return { port, webhookPath, requestTimeoutMs };
+}
 function getIntegrationsConfig() {
     const config = loadConfig();
     return { ...config.integrations };

package/dist/heart/core.js

@@ -2,11 +2,14 @@
 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;
 exports.getProviderDisplayLabel = getProviderDisplayLabel;
 exports.stripLastToolCalls = stripLastToolCalls;
 exports.isTransientError = isTransientError;
+exports.classifyTransientError = classifyTransientError;
 exports.runAgent = runAgent;
 const config_1 = require("./config");
 const identity_1 = require("./identity");
@@ -71,12 +74,35 @@ 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;
 }
 function getProvider() {
     return getProviderRuntime().id;
 }
+function createSummarize() {
+    return async (transcript, instruction) => {
+        const runtime = getProviderRuntime();
+        const client = runtime.client;
+        const response = await client.chat.completions.create({
+            model: runtime.model,
+            messages: [
+                { role: "system", content: instruction },
+                { role: "user", content: transcript },
+            ],
+            max_tokens: 500,
+        });
+        return response.choices?.[0]?.message?.content ?? transcript;
+    };
+}
 function getProviderDisplayLabel() {
     const model = getModel();
     const providerLabelBuilders = {
@@ -175,6 +201,18 @@ function isTransientError(err) {
         return true;
     return false;
 }
+function classifyTransientError(err) {
+    if (!(err instanceof Error))
+        return "unknown error";
+    const status = err.status;
+    if (status === 429)
+        return "rate limited";
+    if (status === 401 || status === 403)
+        return "auth error";
+    if (status && status >= 500)
+        return "server error";
+    return "network error";
+}
 const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 2000;
 async function runAgent(messages, callbacks, channel, signal, options) {
@@ -436,11 +474,12 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 callbacks.onError(new Error("context trimmed, retrying..."), "transient");
                 continue;
             }
-            // Transient network errors: retry with exponential backoff
+            // Transient errors: retry with exponential backoff
             if (isTransientError(e) && retryCount < MAX_RETRIES) {
                 retryCount++;
                 const delay = RETRY_BASE_MS * Math.pow(2, retryCount - 1);
-                callbacks.onError(new Error(`network error, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
+                const cause = classifyTransientError(e);
+                callbacks.onError(new Error(`${cause}, retrying in ${delay / 1000}s (${retryCount}/${MAX_RETRIES})...`), "transient");
                 // Wait with abort support
                 const aborted = await new Promise((resolve) => {
                     const timer = setTimeout(() => resolve(false), delay);

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

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.parseOuroCommand = parseOuroCommand;
+exports.discoverExistingCredentials = discoverExistingCredentials;
 exports.createDefaultOuroCliDeps = createDefaultOuroCliDeps;
 exports.runOuroCli = runOuroCli;
 const child_process_1 = require("child_process");
@@ -46,8 +48,25 @@ const runtime_1 = require("../../nerves/runtime");
 const store_file_1 = require("../../mind/friends/store-file");
 const types_1 = require("../../mind/friends/types");
 const ouro_uti_1 = require("./ouro-uti");
+const ouro_path_installer_1 = require("./ouro-path-installer");
 const subagent_installer_1 = require("./subagent-installer");
 const hatch_flow_1 = require("./hatch-flow");
+const specialist_orchestrator_1 = require("./specialist-orchestrator");
+async function ensureDaemonRunning(deps) {
+    const alive = await deps.checkSocketAlive(deps.socketPath);
+    if (alive) {
+        return {
+            alreadyRunning: true,
+            message: `daemon already running (${deps.socketPath})`,
+        };
+    }
+    deps.cleanupStaleSocket(deps.socketPath);
+    const started = await deps.startDaemonProcess(deps.socketPath);
+    return {
+        alreadyRunning: false,
+        message: `daemon started (pid ${started.pid ?? "unknown"})`,
+    };
+}
 function usage() {
     return [
         "Usage:",
@@ -441,6 +460,163 @@ async function defaultLinkFriendIdentity(command) {
     });
     return `linked ${command.provider}:${command.externalId} to ${command.friendId}`;
 }
+function discoverExistingCredentials(secretsRoot) {
+    const found = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(secretsRoot, { withFileTypes: true });
+    }
+    catch {
+        return found;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const secretsPath = path.join(secretsRoot, entry.name, "secrets.json");
+        let raw;
+        try {
+            raw = fs.readFileSync(secretsPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed.providers)
+            continue;
+        for (const [provName, provConfig] of Object.entries(parsed.providers)) {
+            if (provName === "anthropic" && provConfig.setupToken) {
+                found.push({ agentName: entry.name, provider: "anthropic", credentials: { setupToken: provConfig.setupToken } });
+            }
+            else if (provName === "openai-codex" && provConfig.oauthAccessToken) {
+                found.push({ agentName: entry.name, provider: "openai-codex", credentials: { oauthAccessToken: provConfig.oauthAccessToken } });
+            }
+            else if (provName === "minimax" && provConfig.apiKey) {
+                found.push({ agentName: entry.name, provider: "minimax", credentials: { apiKey: provConfig.apiKey } });
+            }
+            else if (provName === "azure" && provConfig.apiKey && provConfig.endpoint && provConfig.deployment) {
+                found.push({ agentName: entry.name, provider: "azure", credentials: { apiKey: provConfig.apiKey, endpoint: provConfig.endpoint, deployment: provConfig.deployment } });
+            }
+        }
+    }
+    // Deduplicate by provider+credential value (keep first seen)
+    const seen = new Set();
+    return found.filter((cred) => {
+        const key = `${cred.provider}:${JSON.stringify(cred.credentials)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/* v8 ignore next 95 -- integration: interactive terminal specialist session @preserve */
+async function defaultRunAdoptionSpecialist() {
+    const readlineModule = await Promise.resolve().then(() => __importStar(require("readline")));
+    const readlinePromises = await Promise.resolve().then(() => __importStar(require("readline/promises")));
+    const { createCliCallbacks, InputController } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
+    // Phase 1: cold CLI — collect provider/credentials with a simple readline
+    const coldRl = readlinePromises.createInterface({ input: process.stdin, output: process.stdout });
+    const coldPrompt = async (q) => {
+        const answer = await coldRl.question(q);
+        return answer.trim();
+    };
+    let providerRaw;
+    let credentials = {};
+    try {
+        const secretsRoot = path.join(os.homedir(), ".agentsecrets");
+        const discovered = discoverExistingCredentials(secretsRoot);
+        if (discovered.length > 0) {
+            process.stdout.write("\n🐍 welcome to ouro! let's hatch your first agent.\n");
+            process.stdout.write("i found existing API credentials:\n\n");
+            const unique = [...new Map(discovered.map((d) => [`${d.provider}`, d])).values()];
+            for (let i = 0; i < unique.length; i++) {
+                process.stdout.write(`  ${i + 1}. ${unique[i].provider} (from ${unique[i].agentName})\n`);
+            }
+            process.stdout.write("\n");
+            const choice = await coldPrompt("use one of these? enter number, or 'new' for a different key: ");
+            const idx = parseInt(choice, 10) - 1;
+            if (idx >= 0 && idx < unique.length) {
+                providerRaw = unique[idx].provider;
+                credentials = unique[idx].credentials;
+            }
+            else {
+                const pRaw = await coldPrompt("provider (anthropic/azure/minimax/openai-codex): ");
+                if (!isAgentProvider(pRaw)) {
+                    process.stdout.write("unknown provider. run `ouro hatch` to try again.\n");
+                    coldRl.close();
+                    return null;
+                }
+                providerRaw = pRaw;
+                if (providerRaw === "anthropic")
+                    credentials.setupToken = await coldPrompt("API key: ");
+                if (providerRaw === "openai-codex")
+                    credentials.oauthAccessToken = await coldPrompt("OAuth token: ");
+                if (providerRaw === "minimax")
+                    credentials.apiKey = await coldPrompt("API key: ");
+                if (providerRaw === "azure") {
+                    credentials.apiKey = await coldPrompt("API key: ");
+                    credentials.endpoint = await coldPrompt("endpoint: ");
+                    credentials.deployment = await coldPrompt("deployment: ");
+                }
+            }
+        }
+        else {
+            process.stdout.write("\n🐍 welcome to ouro! let's hatch your first agent.\n");
+            process.stdout.write("i need an API key to power our conversation.\n\n");
+            const pRaw = await coldPrompt("provider (anthropic/azure/minimax/openai-codex): ");
+            if (!isAgentProvider(pRaw)) {
+                process.stdout.write("unknown provider. run `ouro hatch` to try again.\n");
+                coldRl.close();
+                return null;
+            }
+            providerRaw = pRaw;
+            if (providerRaw === "anthropic")
+                credentials.setupToken = await coldPrompt("API key: ");
+            if (providerRaw === "openai-codex")
+                credentials.oauthAccessToken = await coldPrompt("OAuth token: ");
+            if (providerRaw === "minimax")
+                credentials.apiKey = await coldPrompt("API key: ");
+            if (providerRaw === "azure") {
+                credentials.apiKey = await coldPrompt("API key: ");
+                credentials.endpoint = await coldPrompt("endpoint: ");
+                credentials.deployment = await coldPrompt("deployment: ");
+            }
+        }
+        coldRl.close();
+        process.stdout.write("\n");
+        // Phase 2: warm specialist session — full CLI experience with markdown, spinners, input control
+        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro");
+        const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+        const cliCallbacks = createCliCallbacks();
+        return await (0, specialist_orchestrator_1.runAdoptionSpecialist)({
+            bundleSourceDir,
+            bundlesRoot,
+            secretsRoot,
+            provider: providerRaw,
+            credentials,
+            humanName: os.userInfo().username,
+            createReadline: () => {
+                const rl2 = readlineModule.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+                const ctrl = new InputController(rl2);
+                return {
+                    question: (q) => new Promise((resolve) => rl2.question(q, resolve)),
+                    close: () => rl2.close(),
+                    inputController: ctrl,
+                };
+            },
+            callbacks: cliCallbacks,
+        });
+    }
+    catch {
+        coldRl.close();
+        return null;
+    }
+}
 function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
     return {
         socketPath,
@@ -455,7 +631,14 @@ function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
         listDiscoveredAgents: defaultListDiscoveredAgents,
         runHatchFlow: hatch_flow_1.runHatchFlow,
         promptInput: defaultPromptInput,
+        runAdoptionSpecialist: defaultRunAdoptionSpecialist,
         registerOuroBundleType: ouro_uti_1.registerOuroBundleUti,
+        installOuroCommand: ouro_path_installer_1.installOuroCommand,
+        /* v8 ignore next 3 -- integration: launches interactive CLI session @preserve */
+        startChat: async (agentName) => {
+            const { main } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
+            await main(agentName);
+        },
     };
 }
 function toDaemonCommand(command) {
@@ -512,17 +695,96 @@ async function registerOuroBundleTypeNonBlocking(deps) {
         });
     }
 }
+async function performSystemSetup(deps) {
+    // Install ouro command to PATH (non-blocking)
+    if (deps.installOuroCommand) {
+        try {
+            deps.installOuroCommand();
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.system_setup_ouro_cmd_error",
+                message: "failed to install ouro command to PATH",
+                meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+            });
+        }
+    }
+    // Install subagents (claude/codex skills)
+    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) },
+        });
+    }
+    // Register .ouro bundle type (UTI on macOS)
+    await registerOuroBundleTypeNonBlocking(deps);
+}
 async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
-    let command = parseOuroCommand(args);
+    if (args.includes("--help") || args.includes("-h")) {
+        const text = usage();
+        deps.writeStdout(text);
+        return text;
+    }
+    let command;
+    try {
+        command = parseOuroCommand(args);
+    }
+    catch (parseError) {
+        if (deps.startChat && deps.listDiscoveredAgents && args.length === 1) {
+            const discovered = await Promise.resolve(deps.listDiscoveredAgents());
+            if (discovered.includes(args[0])) {
+                await ensureDaemonRunning(deps);
+                await deps.startChat(args[0]);
+                return "";
+            }
+        }
+        throw parseError;
+    }
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
-        if (discovered.length === 0) {
+        if (discovered.length === 0 && deps.runAdoptionSpecialist) {
+            // System setup first — ouro command, subagents, UTI — before the interactive specialist
+            await performSystemSetup(deps);
+            const hatchlingName = await deps.runAdoptionSpecialist();
+            if (!hatchlingName) {
+                return "";
+            }
+            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) {
+            if (deps.startChat) {
+                await ensureDaemonRunning(deps);
+                await deps.startChat(discovered[0]);
+                return "";
+            }
             command = { kind: "chat.connect", agent: discovered[0] };
         }
         else {
+            if (deps.startChat && deps.promptInput) {
+                const prompt = `who do you want to talk to?\n${discovered.map((a, i) => `${i + 1}. ${a}`).join("\n")}\n`;
+                const answer = await deps.promptInput(prompt);
+                const selected = discovered.includes(answer) ? answer : discovered[parseInt(answer, 10) - 1];
+                if (!selected)
+                    throw new Error("Invalid selection");
+                await ensureDaemonRunning(deps);
+                await deps.startChat(selected);
+                return "";
+            }
             const message = `who do you want to talk to? ${discovered.join(", ")} (use: ouro chat <agent>)`;
             deps.writeStdout(message);
             return message;
@@ -541,30 +803,14 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         meta: { kind: command.kind },
     });
     if (command.kind === "daemon.up") {
-        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 : String(error) },
-            });
-        }
-        await registerOuroBundleTypeNonBlocking(deps);
-        const alive = await deps.checkSocketAlive(deps.socketPath);
-        if (alive) {
-            const message = `daemon already running (${deps.socketPath})`;
-            deps.writeStdout(message);
-            return message;
-        }
-        deps.cleanupStaleSocket(deps.socketPath);
-        const started = await deps.startDaemonProcess(deps.socketPath);
-        const message = `daemon started (pid ${started.pid ?? "unknown"})`;
-        deps.writeStdout(message);
-        return message;
+        await performSystemSetup(deps);
+        const daemonResult = await ensureDaemonRunning(deps);
+        deps.writeStdout(daemonResult.message);
+        return daemonResult.message;
+    }
+    if (command.kind === "daemon.logs" && deps.tailLogs) {
+        deps.tailLogs();
+        return "";
     }
     if (command.kind === "friend.link") {
         const linker = deps.linkFriendIdentity ?? defaultLinkFriendIdentity;
@@ -573,6 +819,21 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         return message;
     }
     if (command.kind === "hatch.start") {
+        // Route through adoption specialist when no explicit hatch args were provided
+        const hasExplicitHatchArgs = !!(command.agentName || command.humanName || command.provider || command.credentials);
+        if (deps.runAdoptionSpecialist && !hasExplicitHatchArgs) {
+            // System setup first — ouro command, subagents, UTI — before the interactive specialist
+            await performSystemSetup(deps);
+            const hatchlingName = await deps.runAdoptionSpecialist();
+            if (!hatchlingName) {
+                return "";
+            }
+            await ensureDaemonRunning(deps);
+            if (deps.startChat) {
+                await deps.startChat(hatchlingName);
+            }
+            return "";
+        }
         const hatchRunner = deps.runHatchFlow;
         if (!hatchRunner) {
             const response = await deps.sendCommand(deps.socketPath, { kind: "hatch.start" });
@@ -582,27 +843,13 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         }
         const hatchInput = await resolveHatchInput(command, deps);
         const result = await hatchRunner(hatchInput);
-        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 : String(error) },
-            });
-        }
-        await registerOuroBundleTypeNonBlocking(deps);
-        const alive = await deps.checkSocketAlive(deps.socketPath);
-        let daemonMessage = `daemon already running (${deps.socketPath})`;
-        if (!alive) {
-            deps.cleanupStaleSocket(deps.socketPath);
-            const started = await deps.startDaemonProcess(deps.socketPath);
-            daemonMessage = `daemon started (pid ${started.pid ?? "unknown"})`;
+        await performSystemSetup(deps);
+        const daemonResult = await ensureDaemonRunning(deps);
+        if (deps.startChat) {
+            await deps.startChat(hatchInput.agentName);
+            return "";
         }
-        const message = `hatched ${hatchInput.agentName} at ${result.bundleRoot} using specialist identity ${result.selectedIdentity}; ${daemonMessage}`;
+        const message = `hatched ${hatchInput.agentName} at ${result.bundleRoot} using specialist identity ${result.selectedIdentity}; ${daemonResult.message}`;
         deps.writeStdout(message);
         return message;
     }