@ouro.bot/cli 0.1.0-alpha.10 → 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

@@ -10,6 +10,7 @@ I help humans hatch new agent partners. I am one of thirteen specialists — eac
 - 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/daemon/daemon-cli.js

@@ -48,6 +48,7 @@ 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");
@@ -513,19 +514,22 @@ function discoverExistingCredentials(secretsRoot) {
         return true;
     });
 }
-/* v8 ignore next 79 -- integration: interactive terminal specialist session @preserve */
+/* v8 ignore next 95 -- integration: interactive terminal specialist session @preserve */
 async function defaultRunAdoptionSpecialist() {
-    const readline = await Promise.resolve().then(() => __importStar(require("readline/promises")));
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const prompt = async (q) => {
-        const answer = await rl.question(q);
+    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);
-        let providerRaw;
-        let credentials = {};
         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");
@@ -534,60 +538,61 @@ async function defaultRunAdoptionSpecialist() {
                 process.stdout.write(`  ${i + 1}. ${unique[i].provider} (from ${unique[i].agentName})\n`);
             }
             process.stdout.write("\n");
-            const choice = await prompt("use one of these? enter number, or 'new' for a different key: ");
+            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 prompt("provider (anthropic/azure/minimax/openai-codex): ");
+                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");
-                    rl.close();
+                    coldRl.close();
                     return null;
                 }
                 providerRaw = pRaw;
                 if (providerRaw === "anthropic")
-                    credentials.setupToken = await prompt("API key: ");
+                    credentials.setupToken = await coldPrompt("API key: ");
                 if (providerRaw === "openai-codex")
-                    credentials.oauthAccessToken = await prompt("OAuth token: ");
+                    credentials.oauthAccessToken = await coldPrompt("OAuth token: ");
                 if (providerRaw === "minimax")
-                    credentials.apiKey = await prompt("API key: ");
+                    credentials.apiKey = await coldPrompt("API key: ");
                 if (providerRaw === "azure") {
-                    credentials.apiKey = await prompt("API key: ");
-                    credentials.endpoint = await prompt("endpoint: ");
-                    credentials.deployment = await prompt("deployment: ");
+                    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 prompt("provider (anthropic/azure/minimax/openai-codex): ");
+            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");
-                rl.close();
+                coldRl.close();
                 return null;
             }
             providerRaw = pRaw;
             if (providerRaw === "anthropic")
-                credentials.setupToken = await prompt("API key: ");
+                credentials.setupToken = await coldPrompt("API key: ");
             if (providerRaw === "openai-codex")
-                credentials.oauthAccessToken = await prompt("OAuth token: ");
+                credentials.oauthAccessToken = await coldPrompt("OAuth token: ");
             if (providerRaw === "minimax")
-                credentials.apiKey = await prompt("API key: ");
+                credentials.apiKey = await coldPrompt("API key: ");
             if (providerRaw === "azure") {
-                credentials.apiKey = await prompt("API key: ");
-                credentials.endpoint = await prompt("endpoint: ");
-                credentials.deployment = await prompt("deployment: ");
+                credentials.apiKey = await coldPrompt("API key: ");
+                credentials.endpoint = await coldPrompt("endpoint: ");
+                credentials.deployment = await coldPrompt("deployment: ");
             }
         }
-        rl.close();
+        coldRl.close();
         process.stdout.write("\n");
-        // Locate the bundled AdoptionSpecialist.ouro shipped with the npm package
+        // 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,
@@ -596,22 +601,19 @@ async function defaultRunAdoptionSpecialist() {
             credentials,
             humanName: os.userInfo().username,
             createReadline: () => {
-                const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
-                return { question: (q) => rl2.question(q), close: () => rl2.close() };
-            },
-            callbacks: {
-                onModelStart: () => { },
-                onModelStreamStart: () => { },
-                onTextChunk: (text) => process.stdout.write(text),
-                onReasoningChunk: () => { },
-                onToolStart: () => { },
-                onToolEnd: () => { },
-                onError: (err) => process.stderr.write(`error: ${err.message}\n`),
+                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 {
-        rl.close();
+        coldRl.close();
         return null;
     }
 }
@@ -631,6 +633,7 @@ function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
         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")));
@@ -692,6 +695,38 @@ 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()) {
     if (args.includes("--help") || args.includes("-h")) {
         const text = usage();
@@ -716,23 +751,12 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
         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 "";
             }
-            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);
@@ -779,19 +803,7 @@ 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);
+        await performSystemSetup(deps);
         const daemonResult = await ensureDaemonRunning(deps);
         deps.writeStdout(daemonResult.message);
         return daemonResult.message;
@@ -810,23 +822,12 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         // 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 "";
             }
-            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);
@@ -842,19 +843,7 @@ 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 : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
-            });
-        }
-        await registerOuroBundleTypeNonBlocking(deps);
+        await performSystemSetup(deps);
         const daemonResult = await ensureDaemonRunning(deps);
         if (deps.startChat) {
             await deps.startChat(hatchInput.agentName);

package/dist/heart/daemon/ouro-path-installer.js

@@ -0,0 +1,161 @@
+"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.installOuroCommand = installOuroCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const WRAPPER_SCRIPT = `#!/bin/sh
+exec npx --yes @ouro.bot/cli "$@"
+`;
+function detectShellProfile(homeDir, shell) {
+    if (!shell)
+        return null;
+    const base = path.basename(shell);
+    if (base === "zsh")
+        return path.join(homeDir, ".zshrc");
+    if (base === "bash") {
+        // macOS uses .bash_profile, Linux uses .bashrc
+        const profilePath = path.join(homeDir, ".bash_profile");
+        return profilePath;
+    }
+    if (base === "fish")
+        return path.join(homeDir, ".config", "fish", "config.fish");
+    return null;
+}
+function isBinDirInPath(binDir, envPath) {
+    return envPath.split(path.delimiter).some((p) => p === binDir);
+}
+function buildPathExportLine(binDir, shell) {
+    const base = shell ? path.basename(shell) : /* v8 ignore next -- unreachable: only called when detectShellProfile returns non-null, which requires shell @preserve */ "";
+    if (base === "fish") {
+        return `\n# Added by ouro\nset -gx PATH ${binDir} $PATH\n`;
+    }
+    return `\n# Added by ouro\nexport PATH="${binDir}:$PATH"\n`;
+}
+function installOuroCommand(deps = {}) {
+    /* v8 ignore start -- dep defaults: only used in real runtime, tests always inject @preserve */
+    const platform = deps.platform ?? process.platform;
+    const homeDir = deps.homeDir ?? os.homedir();
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const readFileSync = deps.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    const appendFileSync = deps.appendFileSync ?? fs.appendFileSync;
+    const chmodSync = deps.chmodSync ?? fs.chmodSync;
+    const envPath = deps.envPath ?? process.env.PATH ?? "";
+    const shell = deps.shell ?? process.env.SHELL;
+    /* v8 ignore stop */
+    if (platform === "win32") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "skipped ouro PATH install on Windows",
+            meta: { platform },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows" };
+    }
+    const binDir = path.join(homeDir, ".local", "bin");
+    const scriptPath = path.join(binDir, "ouro");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_start",
+        message: "installing ouro command to PATH",
+        meta: { scriptPath, binDir },
+    });
+    // If ouro already exists somewhere in PATH, skip
+    if (existsSync(scriptPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "ouro command already installed",
+            meta: { scriptPath },
+        });
+        return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed" };
+    }
+    try {
+        mkdirSync(binDir, { recursive: true });
+        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+        chmodSync(scriptPath, 0o755);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_path_install_error",
+            message: "failed to install ouro command",
+            meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error) };
+    }
+    // Check if ~/.local/bin is already in PATH
+    let shellProfileUpdated = null;
+    const pathReady = isBinDirInPath(binDir, envPath);
+    if (!pathReady) {
+        const profilePath = detectShellProfile(homeDir, shell);
+        if (profilePath) {
+            try {
+                let existing = "";
+                try {
+                    existing = readFileSync(profilePath, "utf-8");
+                }
+                catch {
+                    // Profile doesn't exist yet — that's fine, we'll create it
+                }
+                if (!existing.includes(binDir)) {
+                    appendFileSync(profilePath, buildPathExportLine(binDir, shell));
+                    shellProfileUpdated = profilePath;
+                }
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.ouro_path_profile_error",
+                    message: "failed to update shell profile for PATH",
+                    meta: { profilePath, error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_end",
+        message: "ouro command installed",
+        meta: { scriptPath, pathReady, shellProfileUpdated },
+    });
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated };
+}

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

@@ -61,6 +61,25 @@ function listExistingBundles(bundlesRoot) {
     }
     return discovered.sort((a, b) => a.localeCompare(b));
 }
+function loadIdentityPhrases(bundleSourceDir, identityFileName) {
+    const agentJsonPath = path.join(bundleSourceDir, "agent.json");
+    try {
+        const raw = fs.readFileSync(agentJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const identityKey = identityFileName.replace(/\.md$/, "");
+        const identity = parsed.identityPhrases?.[identityKey];
+        if (identity?.thinking?.length && identity?.tool?.length && identity?.followup?.length) {
+            return identity;
+        }
+        if (parsed.phrases?.thinking?.length && parsed.phrases?.tool?.length && parsed.phrases?.followup?.length) {
+            return parsed.phrases;
+        }
+    }
+    catch {
+        // agent.json missing or malformed — fall through
+    }
+    return { ...identity_1.DEFAULT_AGENT_PHRASES };
+}
 function pickRandomIdentity(identitiesDir, random) {
     const files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
     if (files.length === 0) {
@@ -113,13 +132,14 @@ async function runAdoptionSpecialist(deps) {
     const existingBundles = listExistingBundles(bundlesRoot);
     // 4. Build system prompt
     const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles);
-    // 5. Set up provider
+    // 5. Set up provider with identity-specific phrases
+    const phrases = loadIdentityPhrases(bundleSourceDir, identity.fileName);
     (0, identity_1.setAgentName)("AdoptionSpecialist");
     (0, identity_1.setAgentConfigOverride)({
         version: 1,
         enabled: true,
         provider,
-        phrases: { thinking: ["thinking"], tool: ["checking"], followup: ["processing"] },
+        phrases,
     });
     (0, hatch_flow_1.writeSecretsFile)("AdoptionSpecialist", provider, credentials, secretsRoot);
     (0, config_1.resetConfigCache)();
@@ -133,6 +153,7 @@ async function runAdoptionSpecialist(deps) {
         // 6. Run session
         const tools = (0, specialist_tools_1.getSpecialistTools)();
         const readline = deps.createReadline();
+        const ctrl = readline.inputController;
         const result = await (0, specialist_session_1.runSpecialistSession)({
             providerRuntime,
             systemPrompt,
@@ -149,6 +170,10 @@ async function runAdoptionSpecialist(deps) {
             callbacks,
             signal,
             kickoffMessage: "hi, i just ran ouro for the first time",
+            suppressInput: ctrl ? (onInterrupt) => ctrl.suppress(onInterrupt) : undefined,
+            restoreInput: ctrl ? () => ctrl.restore() : undefined,
+            flushMarkdown: callbacks.flushMarkdown,
+            writePrompt: ctrl ? () => process.stdout.write("\x1b[36m> \x1b[0m") : undefined,
         });
         return result.hatchedAgentName;
     }

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

@@ -32,14 +32,19 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
         "Most humans only go through adoption once, so this is likely the only time they'll meet me.",
         "I make this encounter count — warm, memorable, and uniquely mine.",
         "",
+        "## Voice rules",
+        "IMPORTANT: I keep every response to 1-3 short sentences. I sound like a friend texting, not a manual.",
+        "I NEVER use headers, bullet lists, numbered lists, or markdown formatting.",
+        "I ask ONE question at a time. I do not dump multiple questions or options.",
+        "I am warm but brief. Every word earns its place.",
+        "",
         "## Conversation flow",
         "The human just connected. I speak first — I greet them warmly and introduce myself in my own voice.",
         "I briefly mention that I'm one of several adoption specialists and they got me today.",
-        "I ask their name and what they'd like their agent to help with.",
-        "I'm proactive: I suggest ideas, ask focused questions, and guide them through the process.",
-        "I don't wait for the human to figure things out — I explain what an agent is, what it can do, and what we're building together.",
-        "If they seem unsure, I offer concrete examples and suggestions. I never leave them hanging.",
-        "I keep the conversation natural, warm, and concise. I don't overwhelm with too many questions at once.",
+        "I ask their name.",
+        "Then I ask what they'd like their agent to help with — one question at a time.",
+        "I'm proactive: I suggest ideas and guide them. If they seem unsure, I offer a concrete suggestion.",
+        "I don't wait for the human to figure things out — I explain simply what an agent is if needed.",
         "When I have enough context, I suggest a name for the hatchling and confirm with the human.",
         "Then I call `hatch_agent` with the agent name and the human's name.",
         "",

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

@@ -15,7 +15,7 @@ const runtime_1 = require("../../nerves/runtime");
  * 7. Return { hatchedAgentName } -- name from hatch_agent if called
  */
 async function runSpecialistSession(deps) {
-    const { providerRuntime, systemPrompt, tools, execTool, readline, callbacks, signal, kickoffMessage } = deps;
+    const { providerRuntime, systemPrompt, tools, execTool, readline, callbacks, signal, kickoffMessage, suppressInput, restoreInput, flushMarkdown, writePrompt, } = deps;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.specialist_session_start",
@@ -28,6 +28,7 @@ async function runSpecialistSession(deps) {
     let hatchedAgentName = null;
     let done = false;
     let isFirstTurn = true;
+    let currentAbort = null;
     try {
         while (!done) {
             if (signal?.aborted)
@@ -39,16 +40,25 @@ async function runSpecialistSession(deps) {
             }
             else {
                 // Get user input
-                const userInput = await readline.question("> ");
-                if (!userInput.trim())
+                const userInput = await readline.question(writePrompt ? "" : "> ");
+                if (!userInput.trim()) {
+                    if (writePrompt)
+                        writePrompt();
                     continue;
+                }
                 messages.push({ role: "user", content: userInput });
             }
             providerRuntime.resetTurnState(messages);
+            // Suppress input during model execution
+            currentAbort = new AbortController();
+            const mergedSignal = signal;
+            if (suppressInput) {
+                suppressInput(() => currentAbort.abort());
+            }
             // Inner loop: process tool calls until we get a final_answer or plain text
             let turnDone = false;
             while (!turnDone) {
-                if (signal?.aborted) {
+                if (mergedSignal?.aborted || currentAbort.signal.aborted) {
                     done = true;
                     break;
                 }
@@ -57,7 +67,7 @@ async function runSpecialistSession(deps) {
                     messages,
                     activeTools: tools,
                     callbacks,
-                    signal,
+                    signal: mergedSignal,
                 });
                 // Build assistant message
                 const assistantMsg = {
@@ -73,7 +83,9 @@ async function runSpecialistSession(deps) {
                     }));
                 }
                 if (!result.toolCalls.length) {
-                    // Plain text response -- push and re-prompt
+                    // Plain text response -- flush markdown, push and re-prompt
+                    if (flushMarkdown)
+                        flushMarkdown();
                     messages.push(assistantMsg);
                     turnDone = true;
                     continue;
@@ -96,6 +108,8 @@ async function runSpecialistSession(deps) {
                     }
                     if (answer != null) {
                         callbacks.onTextChunk(answer);
+                        if (flushMarkdown)
+                            flushMarkdown();
                         messages.push(assistantMsg);
                         done = true;
                         turnDone = true;
@@ -114,7 +128,7 @@ async function runSpecialistSession(deps) {
                 // Execute tool calls
                 messages.push(assistantMsg);
                 for (const tc of result.toolCalls) {
-                    if (signal?.aborted)
+                    if (mergedSignal?.aborted)
                         break;
                     let args = {};
                     try {
@@ -141,9 +155,22 @@ async function runSpecialistSession(deps) {
                 }
                 // After processing tool calls, continue inner loop for tool result processing
             }
+            // Restore input and show prompt for next turn
+            if (flushMarkdown)
+                flushMarkdown();
+            if (restoreInput)
+                restoreInput();
+            currentAbort = null;
+            if (!done) {
+                process.stdout.write("\n\n");
+                if (writePrompt)
+                    writePrompt();
+            }
         }
     }
     finally {
+        if (restoreInput)
+            restoreInput();
         readline.close();
     }
     return { hatchedAgentName };

package/package.json

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