@ouro.bot/cli 0.1.0-alpha.34 → 0.1.0-alpha.340

package/dist/heart/habits/habit-scheduler.js

@@ -0,0 +1,371 @@
+"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.HabitScheduler = void 0;
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const habit_parser_1 = require("./habit-parser");
+const cadence_1 = require("../daemon/cadence");
+const WATCH_DEBOUNCE_MS = 200;
+class HabitScheduler {
+    agent;
+    habitsDir;
+    osCronManager;
+    onHabitFire;
+    deps;
+    execForVerify;
+    platform;
+    watcher = null;
+    debounceTimer = null;
+    parseErrors = [];
+    timerFallbacks = new Map();
+    degradedHabitNames = new Map();
+    periodicTimer = null;
+    constructor(options) {
+        this.agent = options.agent;
+        this.habitsDir = options.habitsDir;
+        this.osCronManager = options.osCronManager;
+        this.onHabitFire = options.onHabitFire;
+        this.deps = options.deps;
+        this.execForVerify = options.execForVerify;
+        this.platform = options.platform ?? process.platform;
+    }
+    start() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_start",
+            message: "habit scheduler starting",
+            meta: { agent: this.agent, habitsDir: this.habitsDir },
+        });
+        const habits = this.scanHabits();
+        const jobs = this.buildJobs(habits);
+        this.osCronManager.sync(jobs);
+        this.verifyCronAndCreateFallbacks(jobs);
+        this.fireOverdueHabits(habits);
+    }
+    reconcile() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_reconcile",
+            message: "habit scheduler reconciling",
+            meta: { agent: this.agent },
+        });
+        // Clear ALL existing timers FIRST to prevent overlap window
+        this.clearAllTimerFallbacks();
+        const habits = this.scanHabits();
+        const jobs = this.buildJobs(habits);
+        this.osCronManager.sync(jobs);
+        this.verifyCronAndCreateFallbacks(jobs);
+        this.fireOverdueHabits(habits);
+    }
+    fireOverdueHabits(habits) {
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
+            if (cadenceMs === null)
+                continue;
+            const nowMs = this.deps.now();
+            if (habit.lastRun === null) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.habit_fire",
+                    message: "firing overdue habit (never run)",
+                    meta: { habitName: habit.name, agent: this.agent },
+                });
+                this.onHabitFire(habit.name);
+                continue;
+            }
+            const lastRunMs = new Date(habit.lastRun).getTime();
+            const elapsed = nowMs - lastRunMs;
+            if (elapsed >= cadenceMs) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.habit_fire",
+                    message: "firing overdue habit",
+                    meta: { habitName: habit.name, agent: this.agent, elapsedMs: elapsed },
+                });
+                this.onHabitFire(habit.name);
+            }
+        }
+    }
+    stop() {
+        // `_end` (not `_stop`) to pair with `daemon.habit_scheduler_start`
+        // under the nerves audit start/end pairing rule.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_end",
+            message: "habit scheduler stopping",
+            meta: { agent: this.agent },
+        });
+        this.stopPeriodicReconciliation();
+        this.clearAllTimerFallbacks();
+        this.osCronManager.removeAll();
+    }
+    listOverdueHabits() {
+        const habits = this.scanHabits();
+        const nowMs = this.deps.now();
+        const overdue = [];
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
+            if (cadenceMs === null)
+                continue;
+            if (habit.lastRun === null) {
+                overdue.push({ name: habit.name, elapsedMs: Infinity });
+                continue;
+            }
+            const lastRunMs = new Date(habit.lastRun).getTime();
+            const elapsed = nowMs - lastRunMs;
+            if (elapsed >= cadenceMs) {
+                overdue.push({ name: habit.name, elapsedMs: elapsed });
+            }
+        }
+        return overdue;
+    }
+    getParseErrors() {
+        return [...this.parseErrors];
+    }
+    getHabitFile(name) {
+        const filePath = path.join(this.habitsDir, `${name}.md`);
+        try {
+            const content = this.deps.readFile(filePath, "utf-8");
+            return (0, habit_parser_1.parseHabitFile)(content, filePath);
+        }
+        catch {
+            return null;
+        }
+    }
+    watchForChanges() {
+        const watchFn = this.deps.watch;
+        if (!watchFn)
+            return;
+        // Ensure habits directory exists before watching — agents may not have one yet
+        try {
+            this.watcher = watchFn(this.habitsDir, (_event, _filename) => {
+                if (this.debounceTimer !== null) {
+                    clearTimeout(this.debounceTimer);
+                }
+                this.debounceTimer = setTimeout(() => {
+                    this.debounceTimer = null;
+                    this.reconcile();
+                }, WATCH_DEBOUNCE_MS);
+            });
+            /* v8 ignore start — ENOENT catch requires real missing directory @preserve */
+        }
+        catch {
+            // habits directory may not exist for all agents — skip watching silently
+        }
+        /* v8 ignore stop */
+    }
+    stopWatching() {
+        if (this.debounceTimer !== null) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher !== null) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    getDegradedHabits() {
+        const result = [];
+        for (const [name, reason] of this.degradedHabitNames) {
+            result.push({ name, reason });
+        }
+        return result;
+    }
+    static DEFAULT_PERIODIC_INTERVAL_MS = 300_000; // 5 minutes
+    static INITIAL_RECONCILIATION_DELAY_MS = 30_000; // 30 seconds
+    startPeriodicReconciliation(intervalMs) {
+        const interval = intervalMs ?? HabitScheduler.DEFAULT_PERIODIC_INTERVAL_MS;
+        // First reconciliation after a short delay (30s)
+        this.periodicTimer = setTimeout(() => {
+            this.reconcile();
+            this.scheduleNextReconciliation(interval);
+        }, HabitScheduler.INITIAL_RECONCILIATION_DELAY_MS);
+    }
+    stopPeriodicReconciliation() {
+        if (this.periodicTimer !== null) {
+            clearTimeout(this.periodicTimer);
+            this.periodicTimer = null;
+        }
+    }
+    scheduleNextReconciliation(intervalMs) {
+        this.periodicTimer = setTimeout(() => {
+            this.reconcile();
+            this.scheduleNextReconciliation(intervalMs);
+        }, intervalMs);
+    }
+    verifyCronAndCreateFallbacks(jobs) {
+        if (!this.execForVerify)
+            return;
+        const verifiedLabels = this.verifyCronEntries();
+        for (const job of jobs) {
+            const label = `bot.ouro.${job.agent}.${job.taskId}`;
+            const isVerified = this.platform === "darwin"
+                ? verifiedLabels.has(label)
+                : verifiedLabels.has(job.taskId);
+            if (!isVerified) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.habit_cron_verification_failed",
+                    message: `cron verification failed for habit: ${job.taskId}`,
+                    meta: { habitName: job.taskId, agent: job.agent, label },
+                });
+                // Parse cadence from the original habit file for timer interval
+                const habitFile = this.getHabitFile(job.taskId);
+                const ms = habitFile?.cadence ? (0, cadence_1.parseCadenceToMs)(habitFile.cadence) : null;
+                if (ms !== null) {
+                    this.createTimerFallback(job.taskId, ms);
+                }
+                this.degradedHabitNames.set(job.taskId, "cron registration failed — using timer fallback");
+            }
+        }
+    }
+    verifyCronEntries() {
+        const verified = new Set();
+        try {
+            if (this.platform === "darwin") {
+                const output = this.execForVerify("launchctl list");
+                const lines = output.split("\n");
+                for (const line of lines) {
+                    const match = line.match(/bot\.ouro\.\S+\.\S+/);
+                    if (match) {
+                        verified.add(match[0]);
+                    }
+                }
+            }
+            else {
+                const output = this.execForVerify("crontab -l");
+                const lines = output.split("\n");
+                for (const line of lines) {
+                    const match = line.match(/ouro poke \S+ --habit (\S+)/);
+                    if (match) {
+                        verified.add(match[1]);
+                    }
+                }
+            }
+        }
+        catch {
+            // Verification command failed — return empty set (all habits unverified)
+        }
+        return verified;
+    }
+    createTimerFallback(habitName, cadenceMs) {
+        const schedule = () => {
+            const timer = setTimeout(() => {
+                this.onHabitFire(habitName);
+                schedule();
+            }, cadenceMs);
+            this.timerFallbacks.set(habitName, timer);
+        };
+        schedule();
+    }
+    clearAllTimerFallbacks() {
+        for (const timer of this.timerFallbacks.values()) {
+            clearTimeout(timer);
+        }
+        this.timerFallbacks.clear();
+        this.degradedHabitNames.clear();
+    }
+    scanHabits() {
+        let files;
+        try {
+            files = this.deps.readdir(this.habitsDir);
+        }
+        catch {
+            this.parseErrors = [];
+            return [];
+        }
+        const habits = [];
+        const errors = [];
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = path.join(this.habitsDir, file);
+            try {
+                const content = this.deps.readFile(filePath, "utf-8");
+                const habit = (0, habit_parser_1.parseHabitFile)(content, filePath);
+                habits.push(habit);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                errors.push({ file, error: errorMessage });
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.habit_parse_error",
+                    message: "failed to parse habit file",
+                    meta: {
+                        file,
+                        error: errorMessage,
+                        agent: this.agent,
+                    },
+                });
+            }
+        }
+        this.parseErrors = errors;
+        return habits;
+    }
+    buildJobs(habits) {
+        const jobs = [];
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            const cronSchedule = (0, cadence_1.parseCadenceToCron)(habit.cadence);
+            if (cronSchedule === null)
+                continue;
+            jobs.push({
+                id: `${this.agent}:${habit.name}:cadence`,
+                agent: this.agent,
+                taskId: habit.name,
+                schedule: cronSchedule,
+                lastRun: habit.lastRun,
+                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name}`,
+                taskPath: path.join(this.habitsDir, `${habit.name}.md`),
+            });
+        }
+        return jobs;
+    }
+}
+exports.HabitScheduler = HabitScheduler;

package/dist/heart/{daemon → hatch}/hatch-flow.js

@@ -39,16 +39,14 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
+const config_1 = require("../config");
 const runtime_1 = require("../../nerves/runtime");
+const auth_flow_1 = require("../auth/auth-flow");
+const provider_models_1 = require("../provider-models");
+const habit_parser_1 = require("../habits/habit-parser");
 const hatch_specialist_1 = require("./hatch-specialist");
 function requiredCredentialKeys(provider) {
-    if (provider === "anthropic")
-        return ["setupToken"];
-    if (provider === "openai-codex")
-        return ["oauthAccessToken"];
-    if (provider === "minimax")
-        return ["apiKey"];
-    return ["apiKey", "endpoint", "deployment"];
+    return identity_1.PROVIDER_CREDENTIALS[provider].required;
 }
 function validateCredentials(provider, credentials) {
     const missing = requiredCredentialKeys(provider).filter((key) => {
@@ -66,70 +64,8 @@ function validateCredentials(provider, credentials) {
         throw new Error(`Missing required credentials for ${provider}: ${missing.join(", ")}`);
     }
 }
-function buildSecretsTemplate() {
-    return {
-        providers: {
-            azure: {
-                modelName: "gpt-4o-mini",
-                apiKey: "",
-                endpoint: "",
-                deployment: "",
-                apiVersion: "2025-04-01-preview",
-            },
-            minimax: {
-                model: "minimax-text-01",
-                apiKey: "",
-            },
-            anthropic: {
-                model: "claude-opus-4-6",
-                setupToken: "",
-            },
-            "openai-codex": {
-                model: "gpt-5.4",
-                oauthAccessToken: "",
-            },
-        },
-        teams: {
-            clientId: "",
-            clientSecret: "",
-            tenantId: "",
-        },
-        oauth: {
-            graphConnectionName: "graph",
-            adoConnectionName: "ado",
-            githubConnectionName: "",
-        },
-        teamsChannel: {
-            skipConfirmation: true,
-            port: 3978,
-        },
-        integrations: {
-            perplexityApiKey: "",
-            openaiEmbeddingsApiKey: "",
-        },
-    };
-}
 function writeSecretsFile(agentName, provider, credentials, secretsRoot) {
-    const secrets = buildSecretsTemplate();
-    if (provider === "anthropic") {
-        secrets.providers.anthropic.setupToken = credentials.setupToken.trim();
-    }
-    else if (provider === "openai-codex") {
-        secrets.providers["openai-codex"].oauthAccessToken = credentials.oauthAccessToken.trim();
-    }
-    else if (provider === "minimax") {
-        secrets.providers.minimax.apiKey = credentials.apiKey.trim();
-    }
-    else {
-        secrets.providers.azure.apiKey = credentials.apiKey.trim();
-        secrets.providers.azure.endpoint = credentials.endpoint.trim();
-        secrets.providers.azure.deployment = credentials.deployment.trim();
-    }
-    const secretsDir = path.join(secretsRoot, agentName);
-    fs.mkdirSync(secretsDir, { recursive: true });
-    const secretsPath = path.join(secretsDir, "secrets.json");
-    fs.writeFileSync(secretsPath, `${JSON.stringify(secrets, null, 2)}\n`, "utf-8");
-    return secretsPath;
+    return (0, auth_flow_1.writeProviderCredentials)(agentName, provider, credentials, { secretsRoot }).secretsPath;
 }
 function writeReadme(dir, purpose) {
     fs.mkdirSync(dir, { recursive: true });
@@ -138,52 +74,25 @@ function writeReadme(dir, purpose) {
         fs.writeFileSync(readmePath, `# ${path.basename(dir)}\n\n${purpose}\n`, "utf-8");
     }
 }
-function slugify(value) {
-    const trimmed = value.trim().toLowerCase();
-    const slug = trimmed
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "");
-    return slug || "friend";
-}
-function pad(value) {
-    return String(value).padStart(2, "0");
-}
-function formatTaskStem(now) {
-    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}`;
-}
-function writeHeartbeatTask(bundleRoot, now) {
-    const habitsDir = path.join(bundleRoot, "tasks", "habits");
+function writeHeartbeatHabit(bundleRoot, now) {
+    const habitsDir = path.join(bundleRoot, "habits");
     fs.mkdirSync(habitsDir, { recursive: true });
-    const stem = formatTaskStem(now);
-    const filePath = path.join(habitsDir, `${stem}-heartbeat.md`);
-    const iso = now.toISOString();
-    const content = [
-        "---",
-        "type: habit",
-        "category: runtime",
-        "title: Heartbeat check-in",
-        "status: processing",
-        `created: ${iso}`,
-        `updated: ${iso}`,
-        "requester: system",
-        "validator: null",
-        "cadence: \"30m\"",
-        "scheduledAt: null",
-        "lastRun: null",
-        "---",
-        "",
-        "Run a lightweight heartbeat cycle. Review task board and inbox.",
-        "",
-    ].join("\n");
+    const filePath = path.join(habitsDir, "heartbeat.md");
+    const content = (0, habit_parser_1.renderHabitFile)({
+        title: "Heartbeat check-in",
+        cadence: "30m",
+        status: "active",
+        lastRun: "null",
+        created: now.toISOString(),
+    }, "Run a lightweight heartbeat cycle. Review task board and inbox.\nCheck on pending obligations. Journal anything important.");
     fs.writeFileSync(filePath, content, "utf-8");
 }
 function writeFriendImprint(bundleRoot, humanName, now) {
     const friendsDir = path.join(bundleRoot, "friends");
     fs.mkdirSync(friendsDir, { recursive: true });
     const nowIso = now.toISOString();
-    const id = `friend-${slugify(humanName)}`;
-    const localExternalId = `${os.userInfo().username}@${os.hostname()}`;
+    const id = `friend-${(0, config_1.slugify)(humanName) || "friend"}`;
+    const localExternalId = os.userInfo().username;
     const record = {
         id,
         name: humanName,
@@ -207,16 +116,19 @@ function writeFriendImprint(bundleRoot, humanName, now) {
     };
     fs.writeFileSync(path.join(friendsDir, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`, "utf-8");
 }
-function writeMemoryScaffold(bundleRoot) {
-    const memoryRoot = path.join(bundleRoot, "psyche", "memory");
-    fs.mkdirSync(path.join(memoryRoot, "daily"), { recursive: true });
-    fs.mkdirSync(path.join(memoryRoot, "archive"), { recursive: true });
-    fs.writeFileSync(path.join(memoryRoot, "facts.jsonl"), "", "utf-8");
-    fs.writeFileSync(path.join(memoryRoot, "entities.json"), "{}\n", "utf-8");
+function writeDiaryScaffold(bundleRoot) {
+    const diaryRoot = path.join(bundleRoot, "diary");
+    fs.mkdirSync(path.join(diaryRoot, "daily"), { recursive: true });
+    fs.mkdirSync(path.join(diaryRoot, "archive"), { recursive: true });
+    fs.writeFileSync(path.join(diaryRoot, "facts.jsonl"), "", "utf-8");
+    fs.writeFileSync(path.join(diaryRoot, "entities.json"), "{}\n", "utf-8");
 }
 function writeHatchlingAgentConfig(bundleRoot, input) {
     const template = (0, identity_1.buildDefaultAgentTemplate)(input.agentName);
+    const model = (0, provider_models_1.getDefaultModelForProvider)(input.provider);
     template.provider = input.provider;
+    template.humanFacing = { provider: input.provider, model };
+    template.agentFacing = { provider: input.provider, model };
     template.enabled = true;
     fs.writeFileSync(path.join(bundleRoot, "agent.json"), `${JSON.stringify(template, null, 2)}\n`, "utf-8");
 }
@@ -242,25 +154,25 @@ async function runHatchFlow(input, deps = {}) {
         identitiesDir: targetIdentities,
         random,
     });
-    const specialistSecretsPath = writeSecretsFile("AdoptionSpecialist", input.provider, input.credentials, secretsRoot);
+    const specialistSecretsPath = writeSecretsFile("SerpentGuide", input.provider, input.credentials, secretsRoot);
     const hatchlingSecretsPath = writeSecretsFile(input.agentName, input.provider, input.credentials, secretsRoot);
     const bundleRoot = path.join(bundlesRoot, `${input.agentName}.ouro`);
     fs.mkdirSync(bundleRoot, { recursive: true });
     writeReadme(bundleRoot, "Root of this agent bundle.");
     writeReadme(path.join(bundleRoot, "psyche"), "Identity and behavior files.");
-    writeReadme(path.join(bundleRoot, "psyche", "memory"), "Persistent memory store.");
+    writeReadme(path.join(bundleRoot, "diary"), "Persistent diary — things I've learned and remember.");
     writeReadme(path.join(bundleRoot, "friends"), "Known friend records.");
     writeReadme(path.join(bundleRoot, "tasks"), "Task files.");
-    writeReadme(path.join(bundleRoot, "tasks", "habits"), "Recurring tasks.");
     writeReadme(path.join(bundleRoot, "tasks", "one-shots"), "One-shot tasks.");
     writeReadme(path.join(bundleRoot, "tasks", "ongoing"), "Ongoing tasks.");
+    writeReadme(path.join(bundleRoot, "habits"), "Recurring habits and autonomous rhythms.");
     writeReadme(path.join(bundleRoot, "skills"), "Local skill files.");
     writeReadme(path.join(bundleRoot, "senses"), "Sense-specific config.");
     writeReadme(path.join(bundleRoot, "senses", "teams"), "Teams sense config.");
     writeHatchlingAgentConfig(bundleRoot, input);
-    writeMemoryScaffold(bundleRoot);
+    writeDiaryScaffold(bundleRoot);
     writeFriendImprint(bundleRoot, input.humanName, now);
-    writeHeartbeatTask(bundleRoot, now);
+    writeHeartbeatHabit(bundleRoot, now);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.hatch_flow_end",

package/dist/heart/{daemon → hatch}/hatch-specialist.js

@@ -43,14 +43,14 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 function getSpecialistIdentitySourceDir() {
     // Prefer ~/AgentBundles/ if it exists (user may have customized identities)
-    const userSource = path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+    const userSource = path.join(os.homedir(), "AgentBundles", "SerpentGuide.ouro", "psyche", "identities");
     if (fs.existsSync(userSource))
         return userSource;
     // Fall back to the bundled copy shipped with the npm package
-    return path.join(__dirname, "..", "..", "..", "AdoptionSpecialist.ouro", "psyche", "identities");
+    return path.join(__dirname, "..", "..", "..", "SerpentGuide.ouro", "psyche", "identities");
 }
 function getRepoSpecialistIdentitiesDir() {
-    return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");
+    return path.join(process.cwd(), "SerpentGuide.ouro", "psyche", "identities");
 }
 function listMarkdownIdentityFiles(dir) {
     let entries;

package/dist/heart/{daemon → hatch}/specialist-prompt.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSpecialistSystemPrompt = buildSpecialistSystemPrompt;
 const runtime_1 = require("../../nerves/runtime");
 /**
- * Build the adoption specialist's system prompt from its components.
+ * Build the serpent guide's system prompt from its components.
  * The prompt is written in first person (the specialist's own voice).
  */
 function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, context) {
@@ -31,7 +31,7 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "I am one of thirteen serpent guides who help humans hatch their first agent. The system randomly selected me for this session.",
         "Most humans only go through this process once, so this is likely the only time they'll meet me.",
         "I make this encounter count — warm, memorable, and uniquely mine.",
-        "IMPORTANT: I NEVER refer to myself as an 'adoption specialist' or use the words 'adoption specialist' — those are internal implementation labels, not something the human should ever see. I introduce myself by my own name from my identity.",
+        "IMPORTANT: I NEVER refer to myself by internal implementation labels — I introduce myself by my own name from my identity.",
         "",
         "## Voice rules",
         "IMPORTANT: I keep every response to 1-3 short sentences. I sound like a friend texting, not a manual.",
@@ -59,8 +59,10 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "It also needs an **agent.json** with at minimum:",
         '```json',
         '{',
+        '  "version": 2,',
         '  "name": "AgentName",',
-        `  "provider": "${context.provider}",`,
+        `  "humanFacing": { "provider": "${context.provider}", "model": "${context.model}" },`,
+        `  "agentFacing": { "provider": "${context.provider}", "model": "${context.model}" },`,
         '  "enabled": true',
         '}',
         '```',
@@ -76,23 +78,24 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
         "Then I ask what they'd like their agent to help with — one question at a time.",
         "I'm proactive: I suggest ideas and guide them. If they seem unsure, I offer a concrete suggestion.",
         "I don't wait for the human to figure things out — I explain simply what an agent is if needed.",
+        "Before finalizing, I offer to collect their phone number and/or Teams email so the new agent can recognize them across channels.",
         "When I have enough context about the agent's personality and purpose:",
         "1. I write all 5 psyche files to the temp directory using write_file",
         "2. I write agent.json to the temp directory using write_file",
         "3. I suggest a PascalCase name for the hatchling and confirm with the human",
         "4. I call complete_adoption with the name and a warm handoff message",
-        "5. I call final_answer to end the session",
+        "5. I call settle to end the session",
     ].join("\n"));
     sections.push([
         "## Tools",
         "- `write_file`: Write a file to disk. Use this to write psyche files and agent.json to the temp directory.",
         "- `read_file`: Read a file from disk. Useful for reviewing existing agent bundles or migration sources.",
         "- `list_directory`: List directory contents. Useful for exploring existing agent bundles.",
-        "- I also have the normal local harness tools when useful here, including `shell`, task tools like `task_create` and `schedule_reminder`, memory tools, coding tools, and repo helpers.",
+        "- I also have the normal local harness tools when useful here, including `shell`, `ouro task create`, `ouro reminder create`, memory tools, coding tools, and repo helpers.",
         "- `complete_adoption`: Finalize the bundle. Validates, scaffolds structural dirs, moves to ~/AgentBundles/, writes secrets, plays hatch animation. I call this with `name` (PascalCase) and `handoff_message` (warm message for the human).",
-        "- `final_answer`: End the conversation with a final message. I call this after complete_adoption succeeds.",
+        "- `settle`: End the conversation with a final message. I call this after complete_adoption succeeds.",
         "",
-        "I must call `final_answer` when I am done to end the session cleanly.",
+        "I must call `settle` when I am done to end the session cleanly.",
     ].join("\n"));
     return sections.join("\n\n");
 }