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

package/dist/heart/daemon/specialist-tools.js

@@ -0,0 +1,132 @@
+"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.getSpecialistTools = getSpecialistTools;
+exports.execSpecialistTool = execSpecialistTool;
+const fs = __importStar(require("fs"));
+const tools_base_1 = require("../../repertoire/tools-base");
+const hatch_flow_1 = require("./hatch-flow");
+const hatch_animation_1 = require("./hatch-animation");
+const runtime_1 = require("../../nerves/runtime");
+const hatchAgentTool = {
+    type: "function",
+    function: {
+        name: "hatch_agent",
+        description: "create a new agent bundle with the given name. call this when you have gathered enough information from the human to hatch their agent.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "the name for the new agent (PascalCase, e.g. 'Slugger')",
+                },
+                humanName: {
+                    type: "string",
+                    description: "the human's preferred name, as they told you during conversation",
+                },
+            },
+            required: ["name", "humanName"],
+        },
+    },
+};
+const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
+const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+/**
+ * Returns the specialist's tool schema array.
+ */
+function getSpecialistTools() {
+    return [hatchAgentTool, tools_base_1.finalAnswerTool, readFileTool.tool, listDirTool.tool];
+}
+/**
+ * Execute a specialist tool call.
+ * Returns the tool result string.
+ */
+async function execSpecialistTool(name, args, deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_tool_exec",
+        message: "executing specialist tool",
+        meta: { tool: name },
+    });
+    if (name === "hatch_agent") {
+        const agentName = args.name;
+        if (!agentName) {
+            return "error: missing required 'name' parameter for hatch_agent";
+        }
+        const input = {
+            agentName,
+            humanName: args.humanName || deps.humanName,
+            provider: deps.provider,
+            credentials: deps.credentials,
+        };
+        // Pass identity dirs to prevent hatch flow from syncing to ~/AgentBundles/AdoptionSpecialist.ouro/
+        // or cwd/AdoptionSpecialist.ouro/. The specialist already picked its identity; the hatch flow
+        // just needs a valid source dir to pick from for the hatchling's LORE.md seed.
+        const identitiesDir = deps.specialistIdentitiesDir;
+        const result = await (0, hatch_flow_1.runHatchFlow)(input, {
+            bundlesRoot: deps.bundlesRoot,
+            secretsRoot: deps.secretsRoot,
+            ...(identitiesDir ? { specialistIdentitySourceDir: identitiesDir, specialistIdentityTargetDir: identitiesDir } : {}),
+        });
+        await (0, hatch_animation_1.playHatchAnimation)(agentName, deps.animationWriter);
+        return [
+            `hatched ${agentName} successfully.`,
+            `bundle path: ${result.bundleRoot}`,
+            `identity seed: ${result.selectedIdentity}`,
+            `specialist secrets: ${result.specialistSecretsPath}`,
+            `hatchling secrets: ${result.hatchlingSecretsPath}`,
+        ].join("\n");
+    }
+    if (name === "read_file") {
+        try {
+            return fs.readFileSync(args.path, "utf-8");
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        }
+    }
+    if (name === "list_directory") {
+        try {
+            return fs
+                .readdirSync(args.path, { withFileTypes: true })
+                .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
+                .join("\n");
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        }
+    }
+    return `error: unknown tool '${name}'`;
+}

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

@@ -103,6 +103,7 @@ class TaskDrivenScheduler {
     readFileSync;
     writeFileSync;
     readdirSync;
+    osCronManager;
     jobs = new Map();
     taskPathByKey = new Map();
     constructor(options) {
@@ -113,12 +114,13 @@ class TaskDrivenScheduler {
         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() {
-        // no long-lived resources; reconciliation is stateless across ticks
+        this.osCronManager?.removeAll();
     }
     listJobs() {
         return [...this.jobs.values()]
@@ -197,6 +199,7 @@ class TaskDrivenScheduler {
             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}`;

package/dist/heart/identity.js

@@ -41,6 +41,8 @@ exports.getAgentBundlesRoot = getAgentBundlesRoot;
 exports.getAgentRoot = getAgentRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
+exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
 exports.resetIdentity = resetIdentity;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -70,6 +72,7 @@ function buildDefaultAgentTemplate(_agentName) {
 }
 let _cachedAgentName = null;
 let _cachedAgentConfig = null;
+let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
  * Caches the result after first parse.
@@ -100,11 +103,11 @@ function getAgentName() {
 }
 /**
  * Resolve repo root from __dirname.
- * In dev (tsx): __dirname is `<repo>/src`, so repo root is one level up.
- * In compiled (node dist/): __dirname is `<repo>/dist`, so repo root is one level up.
+ * 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, "..");
+    return path.resolve(__dirname, "../..");
 }
 /**
  * Returns the shared bundle root directory: `~/AgentBundles/`
@@ -130,6 +133,9 @@ function getAgentSecretsPath(agentName = getAgentName()) {
  * Throws descriptive error if file is missing or contains invalid JSON.
  */
 function loadAgentConfig() {
+    if (_agentConfigOverride) {
+        return _agentConfigOverride;
+    }
     if (_cachedAgentConfig) {
         (0, runtime_1.emitNervesEvent)({
             event: "identity.resolve",
@@ -250,6 +256,7 @@ function loadAgentConfig() {
         enabled,
         provider: rawProvider,
         context: parsed.context,
+        logging: parsed.logging,
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({
@@ -260,6 +267,23 @@ function loadAgentConfig() {
     });
     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;
+}
+/**
+ * Override the agent config returned by loadAgentConfig().
+ * When set to a non-null AgentConfig, loadAgentConfig() returns the override
+ * instead of reading from disk. When set to null, normal disk-based loading resumes.
+ */
+function setAgentConfigOverride(config) {
+    _agentConfigOverride = config;
+}
 /**
  * Clear all cached identity state.
  * Used in tests and when switching agent context.
@@ -267,4 +291,5 @@ function loadAgentConfig() {
 function resetIdentity() {
     _cachedAgentName = null;
     _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }

package/dist/heart/providers/anthropic.js

@@ -98,6 +98,9 @@ function toAnthropicMessages(messages) {
             }
             if (assistant.tool_calls) {
                 for (const toolCall of assistant.tool_calls) {
+                    /* v8 ignore next -- type narrowing: OpenAI SDK only emits function tool_calls @preserve */
+                    if (toolCall.type !== "function")
+                        continue;
                     blocks.push({
                         type: "tool_use",
                         id: toolCall.id,

package/dist/heart/streaming.js

@@ -106,6 +106,9 @@ function toResponsesInput(messages) {
             }
             if (a.tool_calls) {
                 for (const tc of a.tool_calls) {
+                    /* v8 ignore next -- type narrowing: OpenAI SDK only emits function tool_calls @preserve */
+                    if (tc.type !== "function")
+                        continue;
                     input.push({
                         type: "function_call",
                         call_id: tc.id,

package/dist/mind/associative-recall.js

@@ -144,8 +144,29 @@ async function injectAssociativeRecall(messages, options) {
         const facts = readFacts(memoryRoot);
         if (facts.length === 0)
             return;
-        const provider = options?.provider ?? createDefaultProvider();
-        const recalled = await recallFactsForQuery(query, facts, provider, options);
+        let recalled;
+        try {
+            const provider = options?.provider ?? createDefaultProvider();
+            recalled = await recallFactsForQuery(query, facts, provider, options);
+        }
+        catch {
+            // Embeddings unavailable — fall back to substring matching
+            const lowerQuery = query.toLowerCase();
+            const topK = options?.topK ?? DEFAULT_TOP_K;
+            recalled = facts
+                .filter((fact) => fact.text.toLowerCase().includes(lowerQuery))
+                .slice(0, topK)
+                .map((fact) => ({ ...fact, score: 1 }));
+            if (recalled.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "mind",
+                    event: "mind.associative_recall_fallback",
+                    message: "embeddings unavailable, used substring fallback",
+                    meta: { matchCount: recalled.length },
+                });
+            }
+        }
         if (recalled.length === 0)
             return;
         const recallSection = recalled

package/dist/mind/context.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trimMessages = trimMessages;
+exports.validateSessionMessages = validateSessionMessages;
+exports.repairSessionMessages = repairSessionMessages;
 exports.saveSession = saveSession;
 exports.loadSession = loadSession;
 exports.postTurn = postTurn;
@@ -166,7 +168,77 @@ function trimMessages(messages, maxTokens, contextMargin, actualTokenCount) {
     });
     return trimmed;
 }
+/**
+ * Checks session invariant: after system messages, sequence must be
+ * user → assistant (with optional tool calls/results) → user → assistant...
+ * Never assistant → assistant without a user in between.
+ */
+function validateSessionMessages(messages) {
+    const violations = [];
+    let prevNonToolRole = null;
+    let prevAssistantHadToolCalls = false;
+    let sawToolResultSincePrevAssistant = false;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === "system")
+            continue;
+        if (msg.role === "tool") {
+            sawToolResultSincePrevAssistant = true;
+            continue;
+        }
+        if (msg.role === "assistant" && prevNonToolRole === "assistant") {
+            // assistant → tool(s) → assistant is valid (tool call flow)
+            if (!(prevAssistantHadToolCalls && sawToolResultSincePrevAssistant)) {
+                violations.push(`back-to-back assistant at index ${i}`);
+            }
+        }
+        prevAssistantHadToolCalls = msg.role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+        sawToolResultSincePrevAssistant = false;
+        prevNonToolRole = msg.role;
+    }
+    return violations;
+}
+/**
+ * Repairs session invariant violations by merging consecutive assistant messages.
+ */
+function repairSessionMessages(messages) {
+    const violations = validateSessionMessages(messages);
+    if (violations.length === 0)
+        return messages;
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && result.length > 0) {
+            const prev = result[result.length - 1];
+            if (prev.role === "assistant" && !("tool_calls" in prev)) {
+                const prevContent = typeof prev.content === "string" ? prev.content : "";
+                const curContent = typeof msg.content === "string" ? msg.content : "";
+                prev.content = `${prevContent}\n\n${curContent}`;
+                continue;
+            }
+        }
+        result.push(msg);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        event: "mind.session_invariant_repair",
+        component: "mind",
+        message: "repaired session invariant violations",
+        meta: { violations },
+    });
+    return result;
+}
 function saveSession(filePath, messages, lastUsage) {
+    const violations = validateSessionMessages(messages);
+    if (violations.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mind.session_invariant_violation",
+            component: "mind",
+            message: "session invariant violated on save",
+            meta: { path: filePath, violations },
+        });
+        messages = repairSessionMessages(messages);
+    }
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const envelope = { version: 1, messages };
     if (lastUsage)
@@ -179,7 +251,19 @@ function loadSession(filePath) {
         const data = JSON.parse(raw);
         if (data.version !== 1)
             return null;
-        return { messages: data.messages, lastUsage: data.lastUsage };
+        let messages = data.messages;
+        const violations = validateSessionMessages(messages);
+        if (violations.length > 0) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mind.session_invariant_violation",
+                component: "mind",
+                message: "session invariant violated on load",
+                meta: { path: filePath, violations },
+            });
+            messages = repairSessionMessages(messages);
+        }
+        return { messages, lastUsage: data.lastUsage };
     }
     catch {
         return null;

package/dist/mind/friends/channel.js

@@ -21,6 +21,14 @@ const CHANNEL_CAPABILITIES = {
         supportsRichCards: true,
         maxMessageLength: Infinity,
     },
+    bluebubbles: {
+        channel: "bluebubbles",
+        availableIntegrations: [],
+        supportsMarkdown: false,
+        supportsStreaming: false,
+        supportsRichCards: false,
+        maxMessageLength: Infinity,
+    },
 };
 const DEFAULT_CAPABILITIES = {
     channel: "cli",

package/dist/mind/friends/types.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIdentityProvider = isIdentityProvider;
 exports.isIntegration = isIntegration;
 const runtime_1 = require("../../nerves/runtime");
-const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation"]);
+const IDENTITY_PROVIDERS = new Set(["aad", "local", "teams-conversation", "imessage-handle"]);
 function isIdentityProvider(value) {
     (0, runtime_1.emitNervesEvent)({
         component: "friends",

package/dist/mind/memory.js

@@ -38,6 +38,7 @@ exports.ensureMemoryStorePaths = ensureMemoryStorePaths;
 exports.appendFactsWithDedup = appendFactsWithDedup;
 exports.readMemoryFacts = readMemoryFacts;
 exports.saveMemoryFact = saveMemoryFact;
+exports.backfillEmbeddings = backfillEmbeddings;
 exports.searchMemoryFacts = searchMemoryFacts;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -265,6 +266,67 @@ async function saveMemoryFact(options) {
     };
     return appendFactsWithDedup(stores, [fact]);
 }
+async function backfillEmbeddings(options) {
+    const memoryRoot = options?.memoryRoot ?? path.join((0, identity_1.getAgentRoot)(), "psyche", "memory");
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    if (!fs.existsSync(factsPath))
+        return { total: 0, backfilled: 0, failed: 0 };
+    const facts = readExistingFacts(factsPath);
+    const needsEmbedding = facts.filter((f) => !Array.isArray(f.embedding) || f.embedding.length === 0);
+    if (needsEmbedding.length === 0)
+        return { total: facts.length, backfilled: 0, failed: 0 };
+    const provider = options?.embeddingProvider ?? createDefaultEmbeddingProvider();
+    if (!provider) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "mind",
+            event: "mind.memory_backfill_skipped",
+            message: "embedding provider unavailable for backfill",
+            meta: { needsEmbedding: needsEmbedding.length },
+        });
+        return { total: facts.length, backfilled: 0, failed: needsEmbedding.length };
+    }
+    const batchSize = options?.batchSize ?? 50;
+    let backfilled = 0;
+    let failed = 0;
+    for (let i = 0; i < needsEmbedding.length; i += batchSize) {
+        const batch = needsEmbedding.slice(i, i + batchSize);
+        try {
+            const vectors = await provider.embed(batch.map((f) => f.text));
+            for (let j = 0; j < batch.length; j++) {
+                batch[j].embedding = vectors[j] ?? [];
+                if (batch[j].embedding.length > 0)
+                    backfilled++;
+                else
+                    failed++;
+            }
+        }
+        catch (error) {
+            failed += batch.length;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "mind",
+                event: "mind.memory_backfill_batch_error",
+                message: "embedding backfill batch failed",
+                meta: {
+                    batchStart: i,
+                    batchSize: batch.length,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    // Rewrite facts file with updated embeddings
+    const lines = facts.map((f) => JSON.stringify(f)).join("\n") + "\n";
+    fs.writeFileSync(factsPath, lines, "utf8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.memory_backfill_complete",
+        message: "embedding backfill completed",
+        meta: { total: facts.length, backfilled, failed },
+    });
+    return { total: facts.length, backfilled, failed };
+}
 function substringMatches(queryLower, facts) {
     return facts.filter((fact) => fact.text.toLowerCase().includes(queryLower));
 }

package/dist/mind/pending.js

@@ -0,0 +1,93 @@
+"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.getPendingDir = getPendingDir;
+exports.drainPending = drainPending;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const runtime_1 = require("../nerves/runtime");
+function getPendingDir(agentName, friendId, channel, key) {
+    return path.join(os.homedir(), ".agentstate", agentName, "pending", friendId, channel, key);
+}
+function drainPending(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(pendingDir);
+    }
+    catch {
+        return [];
+    }
+    // Collect both .json (new) and .processing (crash recovery)
+    const jsonFiles = entries.filter(f => f.endsWith(".json") && !f.endsWith(".processing"));
+    const processingFiles = entries.filter(f => f.endsWith(".json.processing"));
+    // Sort by filename (timestamp prefix gives chronological order)
+    const allFiles = [
+        ...processingFiles.map(f => ({ file: f, needsRename: false })),
+        ...jsonFiles.map(f => ({ file: f, needsRename: true })),
+    ].sort((a, b) => a.file.localeCompare(b.file));
+    const messages = [];
+    for (const { file, needsRename } of allFiles) {
+        const srcPath = path.join(pendingDir, file);
+        const processingPath = needsRename
+            ? path.join(pendingDir, file + ".processing")
+            : srcPath;
+        try {
+            if (needsRename) {
+                fs.renameSync(srcPath, processingPath);
+            }
+            const raw = fs.readFileSync(processingPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            messages.push(parsed);
+            fs.unlinkSync(processingPath);
+        }
+        catch {
+            // Skip unparseable files — still try to clean up
+            try {
+                fs.unlinkSync(processingPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.pending_drained",
+        component: "mind",
+        message: "pending queue drained",
+        meta: { pendingDir, count: messages.length, recovered: processingFiles.length },
+    });
+    return messages;
+}

package/dist/mind/prompt-refresh.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshSystemPrompt = refreshSystemPrompt;
+const prompt_1 = require("./prompt");
+const runtime_1 = require("../nerves/runtime");
+async function refreshSystemPrompt(messages, channel, options, context) {
+    const newSystem = await (0, prompt_1.buildSystem)(channel, options, context);
+    if (messages.length > 0 && messages[0].role === "system") {
+        messages[0] = { role: "system", content: newSystem };
+    }
+    else {
+        messages.unshift({ role: "system", content: newSystem });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.system_prompt_refreshed",
+        component: "mind",
+        message: "system prompt refreshed",
+        meta: { channel },
+    });
+}