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

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,9 +48,143 @@ 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");
+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",
+        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],
+        ["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) {
@@ -513,19 +647,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 +671,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 +734,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 +766,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 +828,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 +884,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 +936,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 +955,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 +976,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);
@@ -878,7 +1000,10 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         }
         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,