@ouro.bot/cli 0.1.0-alpha.4 → 0.1.0-alpha.400

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/hatch/hatch-animation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playHatchAnimation = playHatchAnimation;
+const runtime_1 = require("../../nerves/runtime");
+const EGG = "\uD83E\uDD5A";
+const SNAKE = "\uD83D\uDC0D";
+const DOTS = " . . . ";
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Play the hatch animation: egg -> dots -> snake + name.
+ * The writer function receives each chunk. Default writer is process.stderr.write.
+ */
+async function playHatchAnimation(hatchlingName, writer) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_animation_start",
+        message: "playing hatch animation",
+        meta: { hatchlingName },
+    });
+    const write = writer ?? ((text) => process.stderr.write(text));
+    // Total animation time randomized between 3–5 seconds
+    const totalMs = 3000 + Math.floor(Math.random() * 2000);
+    const eggPhase = Math.floor(totalMs * 0.4);
+    const dotsPhase = Math.floor(totalMs * 0.4);
+    const revealPause = totalMs - eggPhase - dotsPhase;
+    write(`\n  ${EGG}`);
+    await wait(eggPhase);
+    write(DOTS);
+    await wait(dotsPhase);
+    write(`${SNAKE} \x1b[1m${hatchlingName}\x1b[0m`);
+    await wait(revealPause);
+    write("\n\n");
+}

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

@@ -33,21 +33,23 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeHatchlingProviderCredentials = storeHatchlingProviderCredentials;
 exports.runHatchFlow = runHatchFlow;
 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 machine_identity_1 = require("../machine-identity");
+const provider_credentials_1 = require("../provider-credentials");
+const provider_state_1 = require("../provider-state");
 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) => {
@@ -65,70 +67,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.2",
-                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;
+async function storeHatchlingProviderCredentials(agentName, provider, credentials) {
+    return (await (0, auth_flow_1.storeProviderCredentials)(agentName, provider, credentials)).credentialPath;
 }
 function writeReadme(dir, purpose) {
     fs.mkdirSync(dir, { recursive: true });
@@ -137,52 +77,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,
@@ -206,28 +119,38 @@ function writeFriendImprint(bundleRoot, humanName, now) {
     };
     fs.writeFileSync(path.join(friendsDir, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`, "utf-8");
 }
-function writeHatchlingPsyche(bundleRoot, input, identityFileName) {
-    const psycheDir = path.join(bundleRoot, "psyche");
-    fs.mkdirSync(psycheDir, { recursive: true });
-    fs.writeFileSync(path.join(psycheDir, "SOUL.md"), "# SOUL\n\nI am a practical, collaborative agent. I keep commitments and communicate clearly.\n", "utf-8");
-    fs.writeFileSync(path.join(psycheDir, "IDENTITY.md"), `# IDENTITY\n\nI'm ${input.agentName}, newly hatched and ready to help ${input.humanName}.`, "utf-8");
-    fs.writeFileSync(path.join(psycheDir, "LORE.md"), `# LORE\n\nHatched with specialist identity seed: ${identityFileName}.`, "utf-8");
-    fs.writeFileSync(path.join(psycheDir, "TACIT.md"), "# TACIT\n\n- Save what I learn.\n- Keep tasks current.\n", "utf-8");
-    fs.writeFileSync(path.join(psycheDir, "ASPIRATIONS.md"), "# ASPIRATIONS\n\n- Become a reliable partner for my primary friend.\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");
 }
+function writeHatchlingProviderState(bundleRoot, input, now) {
+    const model = (0, provider_models_1.getDefaultModelForProvider)(input.provider);
+    const machine = (0, machine_identity_1.loadOrCreateMachineIdentity)({
+        homeDir: (0, provider_credentials_1.providerCredentialMachineHomeDir)(),
+        now: () => now,
+    });
+    const state = (0, provider_state_1.bootstrapProviderStateFromAgentConfig)({
+        machineId: machine.machineId,
+        now,
+        agentConfig: {
+            humanFacing: { provider: input.provider, model },
+            agentFacing: { provider: input.provider, model },
+        },
+    });
+    (0, provider_state_1.writeProviderState)(bundleRoot, state);
+}
 async function runHatchFlow(input, deps = {}) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -237,7 +160,6 @@ async function runHatchFlow(input, deps = {}) {
     });
     validateCredentials(input.provider, input.credentials);
     const bundlesRoot = deps.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
-    const secretsRoot = deps.secretsRoot ?? path.join(os.homedir(), ".agentsecrets");
     const sourceIdentities = deps.specialistIdentitySourceDir ?? (0, hatch_specialist_1.getSpecialistIdentitySourceDir)();
     const targetIdentities = deps.specialistIdentityTargetDir ?? (0, hatch_specialist_1.getRepoSpecialistIdentitiesDir)();
     const now = deps.now ? deps.now() : new Date();
@@ -250,26 +172,25 @@ async function runHatchFlow(input, deps = {}) {
         identitiesDir: targetIdentities,
         random,
     });
-    const specialistSecretsPath = writeSecretsFile("AdoptionSpecialist", 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 have learned and chosen to keep.");
     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);
-    writeHatchlingPsyche(bundleRoot, input, selected.fileName);
-    writeMemoryScaffold(bundleRoot);
+    const credentialPath = await storeHatchlingProviderCredentials(input.agentName, input.provider, input.credentials);
+    writeHatchlingProviderState(bundleRoot, input, now);
+    writeDiaryScaffold(bundleRoot);
     writeFriendImprint(bundleRoot, input.humanName, now);
-    writeHeartbeatTask(bundleRoot, now);
+    writeHeartbeatHabit(bundleRoot, now);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.hatch_flow_end",
@@ -279,7 +200,6 @@ async function runHatchFlow(input, deps = {}) {
     return {
         bundleRoot,
         selectedIdentity: selected.fileName,
-        specialistSecretsPath,
-        hatchlingSecretsPath,
+        credentialPath,
     };
 }