@ouro.bot/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/heart/daemon/daemon.js

@@ -39,14 +39,28 @@ const net = __importStar(require("net"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
-function formatStatusSummary(snapshots) {
-    if (snapshots.length === 0)
+function buildWorkerRows(snapshots) {
+    return snapshots.map((snapshot) => ({
+        agent: snapshot.name,
+        worker: snapshot.channel,
+        status: snapshot.status,
+        pid: snapshot.pid,
+        restartCount: snapshot.restartCount,
+        startedAt: snapshot.startedAt,
+    }));
+}
+function formatStatusSummary(payload) {
+    if (payload.overview.workerCount === 0 && payload.overview.senseCount === 0) {
         return "no managed agents";
-    return snapshots
-        .map((snapshot) => {
-        return `${snapshot.name}\t${snapshot.channel}\t${snapshot.status}\tpid=${snapshot.pid ?? "none"}\trestarts=${snapshot.restartCount}`;
-    })
-        .join("\n");
+    }
+    const rows = [
+        ...payload.workers.map((row) => `${row.agent}/${row.worker}:${row.status}`),
+        ...payload.senses
+            .filter((row) => row.enabled)
+            .map((row) => `${row.agent}/${row.sense}:${row.status}`),
+    ];
+    const detail = rows.length > 0 ? `\titems=${rows.join(",")}` : "";
+    return `daemon=${payload.overview.daemon}\tworkers=${payload.overview.workerCount}\tsenses=${payload.overview.senseCount}\thealth=${payload.overview.health}${detail}`;
 }
 function parseIncomingCommand(raw) {
     let parsed;
@@ -71,6 +85,7 @@ class OuroDaemon {
     scheduler;
     healthMonitor;
     router;
+    senseManager;
     bundlesRoot;
     server = null;
     constructor(options) {
@@ -79,6 +94,7 @@ class OuroDaemon {
         this.scheduler = options.scheduler;
         this.healthMonitor = options.healthMonitor;
         this.router = options.router;
+        this.senseManager = options.senseManager ?? null;
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     }
     async start() {
@@ -91,6 +107,7 @@ class OuroDaemon {
             meta: { socketPath: this.socketPath },
         });
         await this.processManager.startAutoStartAgents();
+        await this.senseManager?.startAutoStartSenses();
         this.scheduler.start?.();
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
@@ -178,6 +195,7 @@ class OuroDaemon {
         });
         this.scheduler.stop?.();
         await this.processManager.stopAll();
+        await this.senseManager?.stopAll();
         if (this.server) {
             await new Promise((resolve) => {
                 this.server?.close(() => resolve());
@@ -217,10 +235,23 @@ class OuroDaemon {
                 return { ok: true, message: "daemon stopped" };
             case "daemon.status": {
                 const snapshots = this.processManager.listAgentSnapshots();
+                const workers = buildWorkerRows(snapshots);
+                const senses = this.senseManager?.listSenseRows() ?? [];
+                const data = {
+                    overview: {
+                        daemon: "running",
+                        health: workers.every((worker) => worker.status === "running") ? "ok" : "warn",
+                        socketPath: this.socketPath,
+                        workerCount: workers.length,
+                        senseCount: senses.length,
+                    },
+                    workers,
+                    senses,
+                };
                 return {
                     ok: true,
-                    summary: formatStatusSummary(snapshots),
-                    data: snapshots,
+                    summary: formatStatusSummary(data),
+                    data,
                 };
             }
             case "daemon.health": {

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@latest "$@"
+`;
+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/process-manager.js

@@ -96,7 +96,7 @@ class DaemonProcessManager {
         state.snapshot.status = "starting";
         const runCwd = (0, identity_1.getRepoRoot)();
         const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
-        const args = [entryScript, "--agent", agent, ...(state.config.args ?? [])];
+        const args = [entryScript, "--agent", state.config.agentArg ?? agent, ...(state.config.args ?? [])];
         const child = this.spawnFn("node", args, {
             cwd: runCwd,
             env: state.config.env ? { ...process.env, ...state.config.env } : process.env,

package/dist/heart/daemon/sense-manager.js

@@ -0,0 +1,266 @@
+"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.DaemonSenseManager = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const sense_truth_1 = require("../sense-truth");
+const process_manager_1 = require("./process-manager");
+const DEFAULT_TEAMS_PORT = 3978;
+const DEFAULT_BLUEBUBBLES_PORT = 18790;
+const DEFAULT_BLUEBUBBLES_WEBHOOK_PATH = "/bluebubbles-webhook";
+function defaultSenses() {
+    return {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function readAgentSenses(agentJsonPath) {
+    const defaults = defaultSenses();
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(agentJsonPath, "utf-8"));
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "channels",
+            event: "channel.daemon_sense_agent_config_fallback",
+            message: "using default senses because agent config could not be read",
+            meta: {
+                path: agentJsonPath,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return defaults;
+    }
+    const rawSenses = parsed.senses;
+    if (!rawSenses || typeof rawSenses !== "object" || Array.isArray(rawSenses)) {
+        return defaults;
+    }
+    for (const sense of ["cli", "teams", "bluebubbles"]) {
+        const rawSense = rawSenses[sense];
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            continue;
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled === "boolean") {
+            defaults[sense] = { enabled };
+        }
+    }
+    return defaults;
+}
+function readSecretsPayload(secretsPath) {
+    try {
+        const raw = fs.readFileSync(secretsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { payload: {}, error: "invalid secrets.json object" };
+        }
+        return { payload: parsed, error: null };
+    }
+    catch (error) {
+        return {
+            payload: {},
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function textField(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function numberField(record, key, fallback) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function senseFactsFromSecrets(agent, senses, secretsPath) {
+    const base = {
+        cli: { configured: true, detail: "local interactive terminal" },
+        teams: { configured: false, detail: "not enabled in agent.json" },
+        bluebubbles: { configured: false, detail: "not enabled in agent.json" },
+    };
+    const { payload, error } = readSecretsPayload(secretsPath);
+    const teams = payload.teams;
+    const teamsChannel = payload.teamsChannel;
+    const bluebubbles = payload.bluebubbles;
+    const bluebubblesChannel = payload.bluebubblesChannel;
+    if (senses.teams.enabled) {
+        const missing = [];
+        if (!textField(teams, "clientId"))
+            missing.push("teams.clientId");
+        if (!textField(teams, "clientSecret"))
+            missing.push("teams.clientSecret");
+        if (!textField(teams, "tenantId"))
+            missing.push("teams.tenantId");
+        base.teams = missing.length === 0
+            ? {
+                configured: true,
+                detail: `:${numberField(teamsChannel, "port", DEFAULT_TEAMS_PORT)}`,
+            }
+            : {
+                configured: false,
+                detail: error && !fs.existsSync(secretsPath)
+                    ? `missing secrets.json (${agent})`
+                    : `missing ${missing.join("/")}`,
+            };
+    }
+    if (senses.bluebubbles.enabled) {
+        const missing = [];
+        if (!textField(bluebubbles, "serverUrl"))
+            missing.push("bluebubbles.serverUrl");
+        if (!textField(bluebubbles, "password"))
+            missing.push("bluebubbles.password");
+        base.bluebubbles = missing.length === 0
+            ? {
+                configured: true,
+                detail: `:${numberField(bluebubblesChannel, "port", DEFAULT_BLUEBUBBLES_PORT)} ${textField(bluebubblesChannel, "webhookPath") || DEFAULT_BLUEBUBBLES_WEBHOOK_PATH}`,
+            }
+            : {
+                configured: false,
+                detail: error && !fs.existsSync(secretsPath)
+                    ? `missing secrets.json (${agent})`
+                    : `missing ${missing.join("/")}`,
+            };
+    }
+    return base;
+}
+function parseSenseSnapshotName(name) {
+    const parts = name.split(":");
+    if (parts.length !== 2)
+        return null;
+    const [agent, sense] = parts;
+    if (sense !== "teams" && sense !== "bluebubbles")
+        return null;
+    return { agent, sense };
+}
+function runtimeInfoFor(status) {
+    if (status === "running")
+        return { runtime: "running" };
+    return { runtime: "error" };
+}
+class DaemonSenseManager {
+    processManager;
+    contexts;
+    constructor(options) {
+        const bundlesRoot = options.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
+        const secretsRoot = options.secretsRoot ?? path.join(os.homedir(), ".agentsecrets");
+        this.contexts = new Map(options.agents.map((agent) => {
+            const senses = readAgentSenses(path.join(bundlesRoot, `${agent}.ouro`, "agent.json"));
+            const facts = senseFactsFromSecrets(agent, senses, path.join(secretsRoot, agent, "secrets.json"));
+            return [agent, { senses, facts }];
+        }));
+        const managedSenseAgents = [...this.contexts.entries()].flatMap(([agent, context]) => {
+            return ["teams", "bluebubbles"]
+                .filter((sense) => context.senses[sense].enabled && context.facts[sense].configured)
+                .map((sense) => ({
+                name: `${agent}:${sense}`,
+                agentArg: agent,
+                entry: sense === "teams" ? "senses/teams-entry.js" : "senses/bluebubbles-entry.js",
+                channel: sense,
+                autoStart: true,
+            }));
+        });
+        this.processManager = options.processManager ?? new process_manager_1.DaemonProcessManager({
+            agents: managedSenseAgents,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.daemon_sense_manager_init",
+            message: "initialized daemon sense manager",
+            meta: {
+                agents: options.agents,
+                managedSenseProcesses: managedSenseAgents.map((entry) => entry.name),
+            },
+        });
+    }
+    async startAutoStartSenses() {
+        await this.processManager.startAutoStartAgents();
+    }
+    async stopAll() {
+        await this.processManager.stopAll();
+    }
+    listSenseRows() {
+        const runtime = new Map();
+        for (const snapshot of this.processManager.listAgentSnapshots()) {
+            const parsed = parseSenseSnapshotName(snapshot.name);
+            if (!parsed)
+                continue;
+            const current = runtime.get(parsed.agent) ?? {};
+            current[parsed.sense] = runtimeInfoFor(snapshot.status);
+            runtime.set(parsed.agent, current);
+        }
+        const rows = [...this.contexts.entries()].flatMap(([agent, context]) => {
+            const runtimeInfo = {
+                cli: { configured: true },
+                teams: {
+                    configured: context.facts.teams.configured,
+                    ...(runtime.get(agent)?.teams ?? {}),
+                },
+                bluebubbles: {
+                    configured: context.facts.bluebubbles.configured,
+                    ...(runtime.get(agent)?.bluebubbles ?? {}),
+                },
+            };
+            const inventory = (0, sense_truth_1.getSenseInventory)({ senses: context.senses }, runtimeInfo);
+            return inventory.map((entry) => ({
+                agent,
+                sense: entry.sense,
+                label: entry.label,
+                enabled: entry.enabled,
+                status: entry.status,
+                detail: entry.enabled ? context.facts[entry.sense].detail : "not enabled in agent.json",
+            }));
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.daemon_sense_rows_built",
+            message: "built daemon sense status rows",
+            meta: {
+                rows: rows.map((row) => ({
+                    agent: row.agent,
+                    sense: row.sense,
+                    status: row.status,
+                })),
+            },
+        });
+        return rows;
+    }
+}
+exports.DaemonSenseManager = DaemonSenseManager;

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