@ouro.bot/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

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

@@ -35,6 +35,7 @@ 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");
@@ -47,8 +48,150 @@ 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");
+const specialist_prompt_1 = require("./specialist-prompt");
+const specialist_tools_1 = require("./specialist-tools");
+const runtime_metadata_1 = require("./runtime-metadata");
+function stringField(value) {
+    return typeof value === "string" ? value : null;
+}
+function numberField(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function booleanField(value) {
+    return typeof value === "boolean" ? value : null;
+}
+function parseStatusPayload(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return null;
+    const raw = data;
+    const overview = raw.overview;
+    const senses = raw.senses;
+    const workers = raw.workers;
+    if (!overview || typeof overview !== "object" || Array.isArray(overview))
+        return null;
+    if (!Array.isArray(senses) || !Array.isArray(workers))
+        return null;
+    const parsedOverview = {
+        daemon: stringField(overview.daemon) ?? "unknown",
+        health: stringField(overview.health) ?? "unknown",
+        socketPath: stringField(overview.socketPath) ?? "unknown",
+        version: stringField(overview.version) ?? "unknown",
+        lastUpdated: stringField(overview.lastUpdated) ?? "unknown",
+        workerCount: numberField(overview.workerCount) ?? 0,
+        senseCount: numberField(overview.senseCount) ?? 0,
+    };
+    const parsedSenses = senses.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const sense = stringField(row.sense);
+        const status = stringField(row.status);
+        const detail = stringField(row.detail);
+        const enabled = booleanField(row.enabled);
+        if (!agent || !sense || !status || detail === null || enabled === null)
+            return null;
+        return {
+            agent,
+            sense,
+            label: stringField(row.label) ?? undefined,
+            enabled,
+            status,
+            detail,
+        };
+    });
+    const parsedWorkers = workers.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return null;
+        const row = entry;
+        const agent = stringField(row.agent);
+        const worker = stringField(row.worker);
+        const status = stringField(row.status);
+        const restartCount = numberField(row.restartCount);
+        const hasPid = Object.prototype.hasOwnProperty.call(row, "pid");
+        const pid = row.pid === null ? null : numberField(row.pid);
+        const pidInvalid = !hasPid || (row.pid !== null && pid === null);
+        if (!agent || !worker || !status || restartCount === null || pidInvalid)
+            return null;
+        return {
+            agent,
+            worker,
+            status,
+            pid,
+            restartCount,
+        };
+    });
+    if (parsedSenses.some((row) => row === null) || parsedWorkers.some((row) => row === null))
+        return null;
+    return {
+        overview: parsedOverview,
+        senses: parsedSenses,
+        workers: parsedWorkers,
+    };
+}
+function humanizeSenseName(sense, label) {
+    if (label)
+        return label;
+    if (sense === "cli")
+        return "CLI";
+    if (sense === "bluebubbles")
+        return "BlueBubbles";
+    if (sense === "teams")
+        return "Teams";
+    return sense;
+}
+function formatTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
+    const renderRow = (row) => `| ${row.map((cell, index) => cell.padEnd(widths[index])).join(" | ")} |`;
+    const divider = `|-${widths.map((width) => "-".repeat(width)).join("-|-")}-|`;
+    return [
+        renderRow(headers),
+        divider,
+        ...rows.map(renderRow),
+    ].join("\n");
+}
+function formatDaemonStatusOutput(response, fallback) {
+    const payload = parseStatusPayload(response.data);
+    if (!payload)
+        return fallback;
+    const overviewRows = [
+        ["Daemon", payload.overview.daemon],
+        ["Socket", payload.overview.socketPath],
+        ["Version", payload.overview.version],
+        ["Last Updated", payload.overview.lastUpdated],
+        ["Workers", String(payload.overview.workerCount)],
+        ["Senses", String(payload.overview.senseCount)],
+        ["Health", payload.overview.health],
+    ];
+    const senseRows = payload.senses.map((row) => [
+        row.agent,
+        humanizeSenseName(row.sense, row.label),
+        row.enabled ? "ON" : "OFF",
+        row.status,
+        row.detail,
+    ]);
+    const workerRows = payload.workers.map((row) => [
+        row.agent,
+        row.worker,
+        row.status,
+        row.pid === null ? "n/a" : String(row.pid),
+        String(row.restartCount),
+    ]);
+    return [
+        "Overview",
+        formatTable(["Item", "Value"], overviewRows),
+        "",
+        "Senses",
+        formatTable(["Agent", "Sense", "Enabled", "State", "Detail"], senseRows),
+        "",
+        "Workers",
+        formatTable(["Agent", "Worker", "State", "PID", "Restarts"], workerRows),
+    ].join("\n");
+}
 async function ensureDaemonRunning(deps) {
     const alive = await deps.checkSocketAlive(deps.socketPath);
     if (alive) {
@@ -69,12 +212,49 @@ function usage() {
         "Usage:",
         "  ouro [up]",
         "  ouro stop|status|logs|hatch",
+        "  ouro -v|--version",
         "  ouro chat <agent>",
         "  ouro msg --to <agent> [--session <id>] [--task <ref>] <message>",
         "  ouro poke <agent> --task <task-id>",
         "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
     ].join("\n");
 }
+function formatVersionOutput() {
+    return (0, runtime_metadata_1.getRuntimeMetadata)().version;
+}
+function buildStoppedStatusPayload(socketPath) {
+    const metadata = (0, runtime_metadata_1.getRuntimeMetadata)();
+    return {
+        overview: {
+            daemon: "stopped",
+            health: "warn",
+            socketPath,
+            version: metadata.version,
+            lastUpdated: metadata.lastUpdated,
+            workerCount: 0,
+            senseCount: 0,
+        },
+        senses: [],
+        workers: [],
+    };
+}
+function daemonUnavailableStatusOutput(socketPath) {
+    return [
+        formatDaemonStatusOutput({
+            ok: true,
+            summary: "daemon not running",
+            data: buildStoppedStatusPayload(socketPath),
+        }, "daemon not running"),
+        "",
+        "daemon not running; run `ouro up`",
+    ].join("\n");
+}
+function isDaemonUnavailableError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code ?? "")
+        : "";
+    return code === "ENOENT" || code === "ECONNREFUSED";
+}
 function parseMessageCommand(args) {
     let to;
     let sessionId;
@@ -433,7 +613,8 @@ function defaultListDiscoveredAgents() {
     return discovered.sort((left, right) => left.localeCompare(right));
 }
 async function defaultLinkFriendIdentity(command) {
-    const friendStore = new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "friends"));
+    const fp = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`, "friends");
+    const friendStore = new store_file_1.FileFriendStore(fp);
     const current = await friendStore.get(command.friendId);
     if (!current) {
         return `friend not found: ${command.friendId}`;
@@ -457,6 +638,247 @@ 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 }, providerConfig: { ...provConfig } });
+            }
+            else if (provName === "openai-codex" && provConfig.oauthAccessToken) {
+                found.push({ agentName: entry.name, provider: "openai-codex", credentials: { oauthAccessToken: provConfig.oauthAccessToken }, providerConfig: { ...provConfig } });
+            }
+            else if (provName === "minimax" && provConfig.apiKey) {
+                found.push({ agentName: entry.name, provider: "minimax", credentials: { apiKey: provConfig.apiKey }, providerConfig: { ...provConfig } });
+            }
+            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 }, providerConfig: { ...provConfig } });
+            }
+        }
+    }
+    // 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 start -- integration: interactive terminal specialist session @preserve */
+async function defaultRunAdoptionSpecialist() {
+    const { runCliSession } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
+    const { patchRuntimeConfig } = await Promise.resolve().then(() => __importStar(require("../config")));
+    const { setAgentName, setAgentConfigOverride } = await Promise.resolve().then(() => __importStar(require("../identity")));
+    const readlinePromises = await Promise.resolve().then(() => __importStar(require("readline/promises")));
+    const crypto = await Promise.resolve().then(() => __importStar(require("crypto")));
+    // 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 = {};
+    let providerConfig = {};
+    const tempDir = path.join(os.tmpdir(), `ouro-hatch-${crypto.randomUUID()}`);
+    try {
+        const secretsRoot = path.join(os.homedir(), ".agentsecrets");
+        const discovered = discoverExistingCredentials(secretsRoot);
+        const existingBundleCount = (0, specialist_orchestrator_1.listExistingBundles)((0, identity_1.getAgentBundlesRoot)()).length;
+        const hatchVerb = existingBundleCount > 0 ? "let's hatch a new agent." : "let's hatch your first agent.";
+        // Default models per provider (used when entering new credentials)
+        const defaultModels = {
+            anthropic: "claude-opus-4-6",
+            minimax: "MiniMax-Text-01",
+            "openai-codex": "gpt-5.4",
+            azure: "",
+        };
+        if (discovered.length > 0) {
+            process.stdout.write(`\n\ud83d\udc0d welcome to ouroboros! ${hatchVerb}\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++) {
+                const model = unique[i].providerConfig.model || unique[i].providerConfig.deployment || "";
+                const modelLabel = model ? `, ${model}` : "";
+                process.stdout.write(`  ${i + 1}. ${unique[i].provider}${modelLabel} (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;
+                providerConfig = unique[idx].providerConfig;
+            }
+            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;
+                providerConfig = { model: defaultModels[providerRaw] };
+                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\ud83d\udc0d welcome to ouroboros! ${hatchVerb}\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;
+            providerConfig = { model: defaultModels[providerRaw] };
+            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: configure runtime for adoption specialist
+        const bundleSourceDir = path.resolve(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro");
+        const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+        const secretsRoot2 = path.join(os.homedir(), ".agentsecrets");
+        // Suppress non-critical log noise during adoption (no secrets.json, etc.)
+        const { setRuntimeLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves/runtime")));
+        const { createLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves")));
+        setRuntimeLogger(createLogger({ level: "error" }));
+        // Configure runtime: set agent identity + config override so runAgent
+        // doesn't try to read from ~/AgentBundles/AdoptionSpecialist.ouro/
+        setAgentName("AdoptionSpecialist");
+        // Build specialist system prompt
+        const soulText = (0, specialist_orchestrator_1.loadSoulText)(bundleSourceDir);
+        const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
+        const identity = (0, specialist_orchestrator_1.pickRandomIdentity)(identitiesDir);
+        // Load identity-specific spinner phrases (falls back to DEFAULT_AGENT_PHRASES)
+        const { loadIdentityPhrases } = await Promise.resolve().then(() => __importStar(require("./specialist-orchestrator")));
+        const phrases = loadIdentityPhrases(bundleSourceDir, identity.fileName);
+        setAgentConfigOverride({
+            version: 1,
+            enabled: true,
+            provider: providerRaw,
+            phrases,
+        });
+        patchRuntimeConfig({
+            providers: {
+                [providerRaw]: { ...providerConfig, ...credentials },
+            },
+        });
+        const existingBundles = (0, specialist_orchestrator_1.listExistingBundles)(bundlesRoot);
+        const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles, {
+            tempDir,
+            provider: providerRaw,
+        });
+        // Build specialist tools
+        const specialistTools = (0, specialist_tools_1.getSpecialistTools)();
+        const specialistExecTool = (0, specialist_tools_1.createSpecialistExecTool)({
+            tempDir,
+            credentials,
+            provider: providerRaw,
+            bundlesRoot,
+            secretsRoot: secretsRoot2,
+            animationWriter: (text) => process.stdout.write(text),
+        });
+        // Run the adoption specialist session via runCliSession
+        const result = await runCliSession({
+            agentName: "AdoptionSpecialist",
+            tools: specialistTools,
+            execTool: specialistExecTool,
+            exitOnToolCall: "complete_adoption",
+            autoFirstTurn: true,
+            banner: false,
+            disableCommands: true,
+            skipSystemPromptRefresh: true,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: "hi" },
+            ],
+        });
+        if (result.exitReason === "tool_exit" && result.toolResult) {
+            const parsed = typeof result.toolResult === "string" ? JSON.parse(result.toolResult) : result.toolResult;
+            if (parsed.success && parsed.agentName) {
+                return parsed.agentName;
+            }
+        }
+        return null;
+    }
+    catch (err) {
+        process.stderr.write(`\nouro adoption error: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+        coldRl.close();
+        return null;
+    }
+    finally {
+        // Clear specialist config/identity so the hatched agent gets its own
+        setAgentConfigOverride(null);
+        const { resetProviderRuntime } = await Promise.resolve().then(() => __importStar(require("../core")));
+        resetProviderRuntime();
+        const { resetConfigCache } = await Promise.resolve().then(() => __importStar(require("../config")));
+        resetConfigCache();
+        // Restore default logging
+        const { setRuntimeLogger: restoreLogger } = await Promise.resolve().then(() => __importStar(require("../../nerves/runtime")));
+        restoreLogger(null);
+        // Clean up temp dir if it still exists
+        try {
+            if (fs.existsSync(tempDir)) {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Best effort cleanup
+        }
+    }
+}
+/* v8 ignore stop */
 function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
     return {
         socketPath,
@@ -471,7 +893,9 @@ 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")));
@@ -533,12 +957,49 @@ 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();
         deps.writeStdout(text);
         return text;
     }
+    if (args.length === 1 && (args[0] === "-v" || args[0] === "--version")) {
+        const text = formatVersionOutput();
+        deps.writeStdout(text);
+        return text;
+    }
     let command;
     try {
         command = parseOuroCommand(args);
@@ -556,7 +1017,20 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
     }
     if (args.length === 0) {
         const discovered = await Promise.resolve(deps.listDiscoveredAgents ? deps.listDiscoveredAgents() : defaultListDiscoveredAgents());
-        if (discovered.length === 0) {
+        if (discovered.length === 0 && deps.runAdoptionSpecialist) {
+            // 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) {
@@ -596,19 +1070,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;
@@ -624,6 +1086,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" });
@@ -633,19 +1110,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 : String(error) },
-            });
-        }
-        await registerOuroBundleTypeNonBlocking(deps);
+        await performSystemSetup(deps);
         const daemonResult = await ensureDaemonRunning(deps);
         if (deps.startChat) {
             await deps.startChat(hatchInput.agentName);
@@ -667,9 +1132,22 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             deps.writeStdout(message);
             return message;
         }
+        if (command.kind === "daemon.status" && isDaemonUnavailableError(error)) {
+            const message = daemonUnavailableStatusOutput(deps.socketPath);
+            deps.writeStdout(message);
+            return message;
+        }
+        if (command.kind === "daemon.stop" && isDaemonUnavailableError(error)) {
+            const message = "daemon not running";
+            deps.writeStdout(message);
+            return message;
+        }
         throw error;
     }
-    const message = response.summary ?? response.message ?? (response.ok ? "ok" : `error: ${response.error ?? "unknown error"}`);
+    const fallbackMessage = response.summary ?? response.message ?? (response.ok ? "ok" : `error: ${response.error ?? "unknown error"}`);
+    const message = command.kind === "daemon.status"
+        ? formatDaemonStatusOutput(response, fallbackMessage)
+        : fallbackMessage;
     deps.writeStdout(message);
     return message;
 }

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

@@ -8,6 +8,7 @@ const message_router_1 = require("./message-router");
 const health_monitor_1 = require("./health-monitor");
 const task_scheduler_1 = require("./task-scheduler");
 const runtime_logging_1 = require("./runtime-logging");
+const sense_manager_1 = require("./sense-manager");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -25,16 +26,22 @@ const socketPath = parseSocketPath(process.argv);
     message: "starting daemon entrypoint",
     meta: { socketPath },
 });
+const managedAgents = ["ouroboros", "slugger"];
 const processManager = new process_manager_1.DaemonProcessManager({
-    agents: [
-        { name: "ouroboros", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
-        { name: "slugger", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
-    ],
+    agents: managedAgents.map((agent) => ({
+        name: agent,
+        entry: "heart/agent-entry.js",
+        channel: "inner-dialog",
+        autoStart: true,
+    })),
 });
 const scheduler = new task_scheduler_1.TaskDrivenScheduler({
-    agents: ["ouroboros", "slugger"],
+    agents: [...managedAgents],
 });
 const router = new message_router_1.FileMessageRouter();
+const senseManager = new sense_manager_1.DaemonSenseManager({
+    agents: [...managedAgents],
+});
 const healthMonitor = new health_monitor_1.HealthMonitor({
     processManager,
     scheduler,
@@ -51,6 +58,7 @@ const healthMonitor = new health_monitor_1.HealthMonitor({
 const daemon = new daemon_1.OuroDaemon({
     socketPath,
     processManager,
+    senseManager,
     scheduler,
     healthMonitor,
     router,