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

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

@@ -52,6 +52,139 @@ 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) {
@@ -867,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,

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

@@ -39,7 +39,7 @@ 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 "$@"
+exec npx --yes @ouro.bot/cli@latest "$@"
 `;
 function detectShellProfile(homeDir, shell) {
     if (!shell)

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/subagent-installer.js

@@ -55,9 +55,18 @@ function listSubagentSources(subagentsDir) {
         .map((name) => path.join(subagentsDir, name))
         .sort((a, b) => a.localeCompare(b));
 }
+function pathExists(target) {
+    try {
+        fs.lstatSync(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function ensureSymlink(source, target) {
     fs.mkdirSync(path.dirname(target), { recursive: true });
-    if (fs.existsSync(target)) {
+    if (pathExists(target)) {
         const stats = fs.lstatSync(target);
         if (stats.isSymbolicLink()) {
             const linkedPath = fs.readlinkSync(target);

package/dist/heart/identity.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
@@ -57,12 +57,73 @@ exports.DEFAULT_AGENT_PHRASES = {
     tool: ["running tool"],
     followup: ["processing"],
 };
+exports.DEFAULT_AGENT_SENSES = {
+    cli: { enabled: true },
+    teams: { enabled: false },
+    bluebubbles: { enabled: false },
+};
+function normalizeSenses(value, configFile) {
+    const defaults = {
+        cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+    if (value === undefined) {
+        return defaults;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid senses block",
+            meta: { path: configFile },
+        });
+        throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
+    }
+    const raw = value;
+    const senseNames = ["cli", "teams", "bluebubbles"];
+    for (const senseName of senseNames) {
+        const rawSense = raw[senseName];
+        if (rawSense === undefined) {
+            continue;
+        }
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense config",
+                meta: { path: configFile, sense: senseName },
+            });
+            throw new Error(`agent.json at ${configFile} has invalid senses.${senseName} config.`);
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled !== "boolean") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense enabled flag",
+                meta: { path: configFile, sense: senseName, enabled: enabled ?? null },
+            });
+            throw new Error(`agent.json at ${configFile} must include senses.${senseName}.enabled as boolean.`);
+        }
+        defaults[senseName] = { enabled };
+    }
+    return defaults;
+}
 function buildDefaultAgentTemplate(_agentName) {
     return {
         version: 1,
         enabled: true,
         provider: "anthropic",
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        senses: {
+            cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+            teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+            bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+        },
         phrases: {
             thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
             tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
@@ -257,6 +318,7 @@ function loadAgentConfig() {
         provider: rawProvider,
         context: parsed.context,
         logging: parsed.logging,
+        senses: normalizeSenses(parsed.senses, configFile),
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({

package/dist/heart/sense-truth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSenseInventory = getSenseInventory;
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const SENSES = [
+    { sense: "cli", label: "CLI", daemonManaged: false },
+    { sense: "teams", label: "Teams", daemonManaged: true },
+    { sense: "bluebubbles", label: "BlueBubbles", daemonManaged: true },
+];
+function configuredSenses(senses) {
+    return senses ?? {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function resolveStatus(enabled, daemonManaged, runtimeInfo) {
+    if (!enabled) {
+        return "disabled";
+    }
+    if (!daemonManaged) {
+        return "interactive";
+    }
+    if (runtimeInfo?.runtime === "error") {
+        return "error";
+    }
+    if (runtimeInfo?.runtime === "running") {
+        return "running";
+    }
+    if (runtimeInfo?.configured === false) {
+        return "needs_config";
+    }
+    return "ready";
+}
+function getSenseInventory(agent, runtime = {}) {
+    const senses = configuredSenses(agent.senses);
+    const inventory = SENSES.map(({ sense, label, daemonManaged }) => {
+        const enabled = senses[sense].enabled;
+        return {
+            sense,
+            label,
+            enabled,
+            daemonManaged,
+            status: resolveStatus(enabled, daemonManaged, runtime[sense]),
+        };
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.sense_inventory_built",
+        message: "built sense inventory",
+        meta: {
+            senses: inventory.map((entry) => ({
+                sense: entry.sense,
+                enabled: entry.enabled,
+                status: entry.status,
+            })),
+        },
+    });
+    return inventory;
+}

package/dist/mind/prompt.js

@@ -51,6 +51,7 @@ const first_impressions_1 = require("./first-impressions");
 const tasks_1 = require("../repertoire/tasks");
 // Lazy-loaded psyche text cache
 let _psycheCache = null;
+let _senseStatusLinesCache = null;
 function loadPsycheFile(name) {
     try {
         const psycheDir = path.join((0, identity_1.getAgentRoot)(), "psyche");
@@ -74,6 +75,7 @@ function loadPsyche() {
 }
 function resetPsycheCache() {
     _psycheCache = null;
+    _senseStatusLinesCache = null;
 }
 const DEFAULT_ACTIVE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
 function resolveFriendName(friendId, friendsDir, agentName) {
@@ -194,6 +196,7 @@ function runtimeInfoSection(channel) {
     lines.push(`agent: ${agentName}`);
     lines.push(`cwd: ${process.cwd()}`);
     lines.push(`channel: ${channel}`);
+    lines.push(`current sense: ${channel}`);
     lines.push(`i can read and modify my own source code.`);
     if (channel === "cli") {
         lines.push("i introduce myself on boot with a fun random greeting.");
@@ -204,8 +207,73 @@ function runtimeInfoSection(channel) {
     else {
         lines.push("i am responding in Microsoft Teams. i keep responses concise. i use markdown formatting. i do not introduce myself on boot.");
     }
+    lines.push("");
+    lines.push(...senseRuntimeGuidance(channel));
     return lines.join("\n");
 }
+function hasTextField(record, key) {
+    return typeof record?.[key] === "string" && record[key].trim().length > 0;
+}
+function localSenseStatusLines() {
+    if (_senseStatusLinesCache) {
+        return [..._senseStatusLinesCache];
+    }
+    const config = (0, identity_1.loadAgentConfig)();
+    const senses = config.senses ?? {
+        cli: { enabled: true },
+        teams: { enabled: false },
+        bluebubbles: { enabled: false },
+    };
+    let payload = {};
+    try {
+        const raw = fs.readFileSync((0, identity_1.getAgentSecretsPath)(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            payload = parsed;
+        }
+    }
+    catch {
+        payload = {};
+    }
+    const teams = payload.teams;
+    const bluebubbles = payload.bluebubbles;
+    const configured = {
+        cli: true,
+        teams: hasTextField(teams, "clientId") && hasTextField(teams, "clientSecret") && hasTextField(teams, "tenantId"),
+        bluebubbles: hasTextField(bluebubbles, "serverUrl") && hasTextField(bluebubbles, "password"),
+    };
+    const rows = [
+        { label: "CLI", status: "interactive" },
+        {
+            label: "Teams",
+            status: !senses.teams.enabled ? "disabled" : configured.teams ? "ready" : "needs_config",
+        },
+        {
+            label: "BlueBubbles",
+            status: !senses.bluebubbles.enabled ? "disabled" : configured.bluebubbles ? "ready" : "needs_config",
+        },
+    ];
+    _senseStatusLinesCache = rows.map((row) => `- ${row.label}: ${row.status}`);
+    return [..._senseStatusLinesCache];
+}
+function senseRuntimeGuidance(channel) {
+    const lines = ["available senses:"];
+    lines.push(...localSenseStatusLines());
+    lines.push("sense states:");
+    lines.push("- interactive = available when opened by the user instead of kept running by the daemon");
+    lines.push("- disabled = turned off in agent.json");
+    lines.push("- needs_config = enabled but missing required secrets.json values");
+    lines.push("- ready = enabled and configured; `ouro up` should bring it online");
+    lines.push("- running = enabled and currently active");
+    lines.push("- error = enabled but unhealthy");
+    lines.push("If asked how to enable another sense, I explain the relevant agent.json senses entry and required secrets.json fields instead of guessing.");
+    lines.push("teams setup truth: enable `senses.teams.enabled`, then provide `teams.clientId`, `teams.clientSecret`, and `teams.tenantId` in secrets.json.");
+    lines.push("bluebubbles setup truth: enable `senses.bluebubbles.enabled`, then provide `bluebubbles.serverUrl` and `bluebubbles.password` in secrets.json.");
+    if (channel === "cli") {
+        lines.push("cli is interactive: it is available when the user opens it, not something `ouro up` daemonizes.");
+    }
+    return lines;
+}
 function providerSection() {
     return `## my provider\n${(0, core_1.getProviderDisplayLabel)()}`;
 }

package/package.json

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