@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/heart/daemon/subagent-installer.js

@@ -0,0 +1,125 @@
+"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.installSubagentsForAvailableCli = installSubagentsForAvailableCli;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const runtime_1 = require("../../nerves/runtime");
+function detectCliBinary(binary) {
+    const result = (0, child_process_1.spawnSync)("which", [binary], { encoding: "utf-8" });
+    if (result.status !== 0)
+        return null;
+    const resolved = result.stdout.trim();
+    return resolved.length > 0 ? resolved : null;
+}
+function listSubagentSources(subagentsDir) {
+    if (!fs.existsSync(subagentsDir))
+        return [];
+    return fs.readdirSync(subagentsDir)
+        .filter((name) => name.endsWith(".md"))
+        .filter((name) => name !== "README.md")
+        .map((name) => path.join(subagentsDir, name))
+        .sort((a, b) => a.localeCompare(b));
+}
+function ensureSymlink(source, target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (fs.existsSync(target)) {
+        const stats = fs.lstatSync(target);
+        if (stats.isSymbolicLink()) {
+            const linkedPath = fs.readlinkSync(target);
+            if (linkedPath === source)
+                return false;
+        }
+        fs.unlinkSync(target);
+    }
+    fs.symlinkSync(source, target);
+    return true;
+}
+async function installSubagentsForAvailableCli(options = {}) {
+    const repoRoot = options.repoRoot ?? path.resolve(__dirname, "..", "..", "..");
+    const homeDir = options.homeDir ?? os.homedir();
+    const which = options.which ?? detectCliBinary;
+    const subagentsDir = path.join(repoRoot, "subagents");
+    const sources = listSubagentSources(subagentsDir);
+    const notes = [];
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.subagent_install_start",
+        message: "starting subagent auto-install",
+        meta: { sources: sources.length },
+    });
+    if (sources.length === 0) {
+        notes.push(`no subagent files found at ${subagentsDir}`);
+        return { claudeInstalled: 0, codexInstalled: 0, notes };
+    }
+    let claudeInstalled = 0;
+    let codexInstalled = 0;
+    const claudePath = which("claude");
+    if (!claudePath) {
+        notes.push("claude CLI not found; skipping subagent install");
+    }
+    else {
+        const claudeAgentsDir = path.join(homeDir, ".claude", "agents");
+        for (const source of sources) {
+            const target = path.join(claudeAgentsDir, path.basename(source));
+            if (ensureSymlink(source, target)) {
+                claudeInstalled += 1;
+            }
+        }
+    }
+    const codexPath = which("codex");
+    if (!codexPath) {
+        notes.push("codex CLI not found; skipping subagent install");
+    }
+    else {
+        const codexSkillsDir = path.join(homeDir, ".codex", "skills");
+        for (const source of sources) {
+            const skillName = path.basename(source, ".md");
+            const target = path.join(codexSkillsDir, skillName, "SKILL.md");
+            if (ensureSymlink(source, target)) {
+                codexInstalled += 1;
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.subagent_install_end",
+        message: "completed subagent auto-install",
+        meta: { claudeInstalled, codexInstalled, notes: notes.length },
+    });
+    return { claudeInstalled, codexInstalled, notes };
+}

package/dist/heart/daemon/task-scheduler.js

@@ -0,0 +1,240 @@
+"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.TaskDrivenScheduler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const parser_1 = require("../../repertoire/tasks/parser");
+function walkMarkdownFiles(root, readdirSync, existsSync, files) {
+    if (!existsSync(root))
+        return;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            walkMarkdownFiles(fullPath, readdirSync, existsSync, files);
+            continue;
+        }
+        if (entry.name.endsWith(".md")) {
+            files.push(fullPath);
+        }
+    }
+}
+function parseCadence(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    // Cron format (minute hour day month weekday)
+    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
+        return value;
+    }
+    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
+    if (!cadenceMatch)
+        return null;
+    const interval = Number.parseInt(cadenceMatch[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    const unit = cadenceMatch[2];
+    if (unit === "m")
+        return `*/${interval} * * * *`;
+    if (unit === "h")
+        return `0 */${interval} * * *`;
+    return `0 0 */${interval} * *`;
+}
+function parseScheduledAt(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    const minute = date.getUTCMinutes();
+    const hour = date.getUTCHours();
+    const day = date.getUTCDate();
+    const month = date.getUTCMonth() + 1;
+    return `${minute} ${hour} ${day} ${month} *`;
+}
+function removeRuntimeFrontmatter(frontmatter) {
+    const { _isCanonicalFilename, ...clean } = frontmatter;
+    return clean;
+}
+class TaskDrivenScheduler {
+    agents;
+    bundlesRoot;
+    nowIso;
+    existsSync;
+    readFileSync;
+    writeFileSync;
+    readdirSync;
+    osCronManager;
+    jobs = new Map();
+    taskPathByKey = new Map();
+    constructor(options) {
+        this.agents = [...options.agents];
+        this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        this.nowIso = options.nowIso ?? (() => new Date().toISOString());
+        this.existsSync = options.existsSync ?? fs.existsSync;
+        this.readFileSync = options.readFileSync ?? fs.readFileSync;
+        this.writeFileSync = options.writeFileSync ?? fs.writeFileSync;
+        this.readdirSync = options.readdirSync ?? fs.readdirSync;
+        this.osCronManager = options.osCronManager;
+    }
+    start() {
+        void this.reconcile();
+    }
+    stop() {
+        this.osCronManager?.removeAll();
+    }
+    listJobs() {
+        return [...this.jobs.values()]
+            .map((job) => ({ id: job.id, schedule: job.schedule, lastRun: job.lastRun }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    async triggerJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job) {
+            return { ok: false, message: `unknown scheduled job: ${jobId}` };
+        }
+        await this.recordTaskRun(job.agent, job.taskId);
+        return { ok: true, message: `triggered ${jobId}` };
+    }
+    async reconcile() {
+        const nextJobs = new Map();
+        const nextTaskPaths = new Map();
+        for (const agent of this.agents) {
+            const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
+            const collections = ["one-shots", "ongoing", "habits"];
+            const files = [];
+            for (const collection of collections) {
+                walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
+            }
+            for (const filePath of files) {
+                let task;
+                try {
+                    task = (0, parser_1.parseTaskFile)(this.readFileSync(filePath, "utf-8"), filePath);
+                }
+                catch {
+                    continue;
+                }
+                const taskId = task.stem;
+                nextTaskPaths.set(`${agent}:${taskId}`, filePath);
+                if (task.status === "done")
+                    continue;
+                const cadence = parseCadence(task.frontmatter.cadence);
+                if (cadence) {
+                    const id = `${agent}:${taskId}:cadence`;
+                    nextJobs.set(id, {
+                        id,
+                        agent,
+                        taskId,
+                        schedule: cadence,
+                        lastRun: typeof task.frontmatter.lastRun === "string" ? task.frontmatter.lastRun : null,
+                        command: `ouro poke ${agent} --task ${taskId}`,
+                        taskPath: filePath,
+                    });
+                }
+                const scheduledAt = parseScheduledAt(task.frontmatter.scheduledAt);
+                if (scheduledAt) {
+                    const id = `${agent}:${taskId}:scheduledAt`;
+                    nextJobs.set(id, {
+                        id,
+                        agent,
+                        taskId,
+                        schedule: scheduledAt,
+                        lastRun: typeof task.frontmatter.lastRun === "string" ? task.frontmatter.lastRun : null,
+                        command: `ouro poke ${agent} --task ${taskId}`,
+                        taskPath: filePath,
+                    });
+                }
+            }
+        }
+        this.jobs.clear();
+        for (const [id, job] of nextJobs.entries()) {
+            this.jobs.set(id, job);
+        }
+        this.taskPathByKey.clear();
+        for (const [key, filePath] of nextTaskPaths.entries()) {
+            this.taskPathByKey.set(key, filePath);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.scheduler_reconciled",
+            message: "reconciled task-driven schedule jobs",
+            meta: { jobCount: this.jobs.size, agents: this.agents.length },
+        });
+        this.osCronManager?.sync([...this.jobs.values()]);
+    }
+    async recordTaskRun(agent, taskId) {
+        const key = `${agent}:${taskId}`;
+        let taskPath = this.taskPathByKey.get(key);
+        if (!taskPath) {
+            await this.reconcile();
+            taskPath = this.taskPathByKey.get(key);
+            if (!taskPath)
+                return;
+        }
+        let parsed;
+        try {
+            parsed = (0, parser_1.parseTaskFile)(this.readFileSync(taskPath, "utf-8"), taskPath);
+        }
+        catch {
+            return;
+        }
+        const now = this.nowIso();
+        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        frontmatter.lastRun = now;
+        if (typeof frontmatter.updated === "string") {
+            frontmatter.updated = now.slice(0, 10);
+        }
+        this.writeFileSync(taskPath, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        for (const job of this.jobs.values()) {
+            if (job.agent === agent && job.taskId === taskId) {
+                job.lastRun = now;
+            }
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.scheduler_task_run_recorded",
+            message: "recorded scheduled task run",
+            meta: { agent, taskId, at: now },
+        });
+    }
+}
+exports.TaskDrivenScheduler = TaskDrivenScheduler;

package/dist/heart/harness.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARNESS_PRIMITIVES_ENTRYPOINT = void 0;
+const runtime_1 = require("../nerves/runtime");
+__exportStar(require("./primitives"), exports);
+exports.HARNESS_PRIMITIVES_ENTRYPOINT = "harness/primitives";
+(0, runtime_1.emitNervesEvent)({
+    component: "harness",
+    event: "harness.module_entry_loaded",
+    message: "harness primitives entrypoint loaded",
+    meta: {},
+});

package/dist/heart/identity.js

@@ -0,0 +1,281 @@
+"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.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
+exports.getAgentName = getAgentName;
+exports.getRepoRoot = getRepoRoot;
+exports.getAgentBundlesRoot = getAgentBundlesRoot;
+exports.getAgentRoot = getAgentRoot;
+exports.getAgentSecretsPath = getAgentSecretsPath;
+exports.loadAgentConfig = loadAgentConfig;
+exports.setAgentName = setAgentName;
+exports.resetIdentity = resetIdentity;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+exports.DEFAULT_AGENT_CONTEXT = {
+    maxTokens: 80000,
+    contextMargin: 20,
+};
+exports.DEFAULT_AGENT_PHRASES = {
+    thinking: ["working"],
+    tool: ["running tool"],
+    followup: ["processing"],
+};
+function buildDefaultAgentTemplate(_agentName) {
+    return {
+        version: 1,
+        enabled: true,
+        provider: "anthropic",
+        context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        phrases: {
+            thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
+            tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
+            followup: [...exports.DEFAULT_AGENT_PHRASES.followup],
+        },
+    };
+}
+let _cachedAgentName = null;
+let _cachedAgentConfig = null;
+/**
+ * Parse `--agent <name>` from process.argv.
+ * Caches the result after first parse.
+ * Throws if --agent is missing or has no value.
+ */
+function getAgentName() {
+    if (_cachedAgentName) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "identity.resolve",
+            component: "config/identity",
+            message: "resolved agent name from cache",
+            meta: { source: "cache" },
+        });
+        return _cachedAgentName;
+    }
+    const idx = process.argv.indexOf("--agent");
+    if (idx === -1 || idx + 1 >= process.argv.length) {
+        throw new Error("Missing required --agent <name> argument. Usage: node cli-entry.js --agent ouroboros");
+    }
+    _cachedAgentName = process.argv[idx + 1];
+    (0, runtime_1.emitNervesEvent)({
+        event: "identity.resolve",
+        component: "config/identity",
+        message: "resolved agent name from argv",
+        meta: { source: "argv" },
+    });
+    return _cachedAgentName;
+}
+/**
+ * Resolve repo root from __dirname.
+ * In dev (tsx): __dirname is `<repo>/src/heart`, so repo root is two levels up.
+ * In compiled (node dist/): __dirname is `<repo>/dist/heart`, so repo root is two levels up.
+ */
+function getRepoRoot() {
+    return path.resolve(__dirname, "../..");
+}
+/**
+ * Returns the shared bundle root directory: `~/AgentBundles/`
+ */
+function getAgentBundlesRoot() {
+    return path.join(os.homedir(), "AgentBundles");
+}
+/**
+ * Returns the agent-specific bundle directory: `~/AgentBundles/<agentName>.ouro/`
+ */
+function getAgentRoot() {
+    return path.join(getAgentBundlesRoot(), `${getAgentName()}.ouro`);
+}
+/**
+ * Returns the conventional secrets path: `~/.agentsecrets/<agentName>/secrets.json`
+ */
+function getAgentSecretsPath(agentName = getAgentName()) {
+    return path.join(os.homedir(), ".agentsecrets", agentName, "secrets.json");
+}
+/**
+ * Load and parse `<agentRoot>/agent.json`.
+ * Caches the result after first load.
+ * Throws descriptive error if file is missing or contains invalid JSON.
+ */
+function loadAgentConfig() {
+    if (_cachedAgentConfig) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "identity.resolve",
+            component: "config/identity",
+            message: "loaded agent config from cache",
+            meta: { source: "cache" },
+        });
+        return _cachedAgentConfig;
+    }
+    const agentRoot = getAgentRoot();
+    const configFile = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configFile, "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "failed reading agent.json",
+            meta: {
+                path: configFile,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw new Error(`Cannot read agent.json at ${configFile}. Does the agent directory exist?`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "invalid agent.json syntax",
+            meta: {
+                path: configFile,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw new Error(`Invalid JSON in agent.json at ${configFile}. Check syntax.`);
+    }
+    const existingPhrases = parsed.phrases;
+    const needsFill = !existingPhrases ||
+        !existingPhrases.thinking ||
+        !existingPhrases.tool ||
+        !existingPhrases.followup;
+    if (needsFill) {
+        const filled = {
+            thinking: existingPhrases?.thinking ?? exports.DEFAULT_AGENT_PHRASES.thinking,
+            tool: existingPhrases?.tool ?? exports.DEFAULT_AGENT_PHRASES.tool,
+            followup: existingPhrases?.followup ?? exports.DEFAULT_AGENT_PHRASES.followup,
+        };
+        parsed.phrases = filled;
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config missing phrase pools; placeholders applied",
+            meta: { path: configFile },
+        });
+        fs.writeFileSync(configFile, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+    }
+    const rawProvider = parsed.provider;
+    if (rawProvider !== "azure" &&
+        rawProvider !== "minimax" &&
+        rawProvider !== "anthropic" &&
+        rawProvider !== "openai-codex") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config missing or invalid provider",
+            meta: {
+                path: configFile,
+                provider: rawProvider,
+            },
+        });
+        throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", or "openai-codex".`);
+    }
+    const rawVersion = parsed.version;
+    const version = rawVersion === undefined ? 1 : rawVersion;
+    if (typeof version !== "number" ||
+        !Number.isInteger(version) ||
+        version < 1) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config missing or invalid version",
+            meta: {
+                path: configFile,
+                version: rawVersion,
+            },
+        });
+        throw new Error(`agent.json at ${configFile} must include version as integer >= 1.`);
+    }
+    const rawEnabled = parsed.enabled;
+    const enabled = rawEnabled === undefined ? true : rawEnabled;
+    if (typeof enabled !== "boolean") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid enabled flag",
+            meta: {
+                path: configFile,
+                enabled: rawEnabled,
+            },
+        });
+        throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
+    }
+    _cachedAgentConfig = {
+        version,
+        enabled,
+        provider: rawProvider,
+        context: parsed.context,
+        logging: parsed.logging,
+        phrases: parsed.phrases,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        event: "identity.resolve",
+        component: "config/identity",
+        message: "loaded agent config from disk",
+        meta: { source: "disk" },
+    });
+    return _cachedAgentConfig;
+}
+/**
+ * Prime the agent name cache explicitly.
+ * Used when agent name is known via parameter (e.g., `ouro` CLI routing)
+ * rather than `--agent` argv. All downstream calls to `getAgentName()`
+ * will return this value until `resetIdentity()` is called.
+ */
+function setAgentName(name) {
+    _cachedAgentName = name;
+}
+/**
+ * Clear all cached identity state.
+ * Used in tests and when switching agent context.
+ */
+function resetIdentity() {
+    _cachedAgentName = null;
+    _cachedAgentConfig = null;
+}