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

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_manager_1 = require("./process-manager");
+const daemon_1 = require("./daemon");
+const runtime_1 = require("../../nerves/runtime");
+const message_router_1 = require("./message-router");
+const health_monitor_1 = require("./health-monitor");
+const task_scheduler_1 = require("./task-scheduler");
+const runtime_logging_1 = require("./runtime-logging");
+function parseSocketPath(argv) {
+    const socketIndex = argv.indexOf("--socket");
+    if (socketIndex >= 0) {
+        const value = argv[socketIndex + 1];
+        if (value && value.trim().length > 0)
+            return value;
+    }
+    return "/tmp/ouroboros-daemon.sock";
+}
+const socketPath = parseSocketPath(process.argv);
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("daemon");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.entry_start",
+    message: "starting daemon entrypoint",
+    meta: { socketPath },
+});
+const processManager = new process_manager_1.DaemonProcessManager({
+    agents: [
+        { name: "ouroboros", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
+        { name: "slugger", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
+    ],
+});
+const scheduler = new task_scheduler_1.TaskDrivenScheduler({
+    agents: ["ouroboros", "slugger"],
+});
+const router = new message_router_1.FileMessageRouter();
+const healthMonitor = new health_monitor_1.HealthMonitor({
+    processManager,
+    scheduler,
+    alertSink: (message) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.health_alert",
+            message: "health monitor produced critical alert",
+            meta: { message },
+        });
+    },
+});
+const daemon = new daemon_1.OuroDaemon({
+    socketPath,
+    processManager,
+    scheduler,
+    healthMonitor,
+    router,
+});
+void daemon.start().catch(async () => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.entry_error",
+        message: "daemon entrypoint failed",
+        meta: {},
+    });
+    await daemon.stop();
+    process.exit(1);
+});
+process.on("SIGINT", () => {
+    void daemon.stop().then(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    void daemon.stop().then(() => process.exit(0));
+});

package/dist/heart/daemon/daemon.js

@@ -0,0 +1,313 @@
+"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.OuroDaemon = void 0;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function formatStatusSummary(snapshots) {
+    if (snapshots.length === 0)
+        return "no managed agents";
+    return snapshots
+        .map((snapshot) => {
+        return `${snapshot.name}\t${snapshot.channel}\t${snapshot.status}\tpid=${snapshot.pid ?? "none"}\trestarts=${snapshot.restartCount}`;
+    })
+        .join("\n");
+}
+function parseIncomingCommand(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Invalid daemon command payload: expected JSON object.");
+    }
+    if (!parsed || typeof parsed !== "object" || !("kind" in parsed)) {
+        throw new Error("Invalid daemon command payload: missing kind.");
+    }
+    const kind = parsed.kind;
+    if (typeof kind !== "string") {
+        throw new Error("Invalid daemon command payload: kind must be a string.");
+    }
+    return parsed;
+}
+class OuroDaemon {
+    socketPath;
+    processManager;
+    scheduler;
+    healthMonitor;
+    router;
+    bundlesRoot;
+    server = null;
+    constructor(options) {
+        this.socketPath = options.socketPath;
+        this.processManager = options.processManager;
+        this.scheduler = options.scheduler;
+        this.healthMonitor = options.healthMonitor;
+        this.router = options.router;
+        this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    }
+    async start() {
+        if (this.server)
+            return;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.server_start",
+            message: "starting daemon server",
+            meta: { socketPath: this.socketPath },
+        });
+        await this.processManager.startAutoStartAgents();
+        this.scheduler.start?.();
+        await this.scheduler.reconcile?.();
+        await this.drainPendingBundleMessages();
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+        this.server = net.createServer((connection) => {
+            let raw = "";
+            let responded = false;
+            const flushResponse = async () => {
+                if (responded)
+                    return;
+                responded = true;
+                const response = await this.handleRawPayload(raw);
+                connection.end(response);
+            };
+            connection.on("data", (chunk) => {
+                raw += chunk.toString("utf-8");
+                void flushResponse();
+            });
+            connection.on("end", () => {
+                void flushResponse();
+            });
+        });
+        const server = this.server;
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(this.socketPath, () => resolve());
+        });
+    }
+    async drainPendingBundleMessages() {
+        if (!fs.existsSync(this.bundlesRoot))
+            return;
+        let bundleDirs;
+        try {
+            bundleDirs = fs.readdirSync(this.bundlesRoot, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const bundleDir of bundleDirs) {
+            if (!bundleDir.isDirectory() || !bundleDir.name.endsWith(".ouro"))
+                continue;
+            const pendingPath = path.join(this.bundlesRoot, bundleDir.name, "inbox", "pending.jsonl");
+            if (!fs.existsSync(pendingPath))
+                continue;
+            const raw = fs.readFileSync(pendingPath, "utf-8");
+            const lines = raw
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            const retained = [];
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (typeof parsed.from !== "string" ||
+                        typeof parsed.to !== "string" ||
+                        typeof parsed.content !== "string") {
+                        retained.push(line);
+                        continue;
+                    }
+                    await this.router.send({
+                        from: parsed.from,
+                        to: parsed.to,
+                        content: parsed.content,
+                        priority: typeof parsed.priority === "string" ? parsed.priority : undefined,
+                        sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : undefined,
+                        taskRef: typeof parsed.taskRef === "string" ? parsed.taskRef : undefined,
+                    });
+                }
+                catch {
+                    retained.push(line);
+                }
+            }
+            const next = retained.length > 0 ? `${retained.join("\n")}\n` : "";
+            fs.writeFileSync(pendingPath, next, "utf-8");
+        }
+    }
+    async stop() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.server_stop",
+            message: "stopping daemon server",
+            meta: { socketPath: this.socketPath },
+        });
+        this.scheduler.stop?.();
+        await this.processManager.stopAll();
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server?.close(() => resolve());
+            });
+            this.server = null;
+        }
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+    }
+    async handleRawPayload(raw) {
+        try {
+            const command = parseIncomingCommand(raw);
+            const response = await this.handleCommand(command);
+            return JSON.stringify(response);
+        }
+        catch (error) {
+            return JSON.stringify({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleCommand(command) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.command_received",
+            message: "handling daemon command",
+            meta: { kind: command.kind },
+        });
+        switch (command.kind) {
+            case "daemon.start":
+                await this.start();
+                return { ok: true, message: "daemon started" };
+            case "daemon.stop":
+                await this.stop();
+                return { ok: true, message: "daemon stopped" };
+            case "daemon.status": {
+                const snapshots = this.processManager.listAgentSnapshots();
+                return {
+                    ok: true,
+                    summary: formatStatusSummary(snapshots),
+                    data: snapshots,
+                };
+            }
+            case "daemon.health": {
+                const checks = await this.healthMonitor.runChecks();
+                const summary = checks.map((check) => `${check.name}:${check.status}:${check.message}`).join("\n");
+                return { ok: true, summary, data: checks };
+            }
+            case "daemon.logs":
+                return {
+                    ok: true,
+                    summary: "logs: use `ouro logs` to tail daemon and agent output",
+                    message: "log streaming available via ouro logs",
+                    data: { logDir: "~/.agentstate/daemon/logs" },
+                };
+            case "agent.start":
+                await this.processManager.startAgent(command.agent);
+                return { ok: true, message: `started ${command.agent}` };
+            case "agent.stop":
+                await this.processManager.stopAgent?.(command.agent);
+                return { ok: true, message: `stopped ${command.agent}` };
+            case "agent.restart":
+                await this.processManager.restartAgent?.(command.agent);
+                return { ok: true, message: `restarted ${command.agent}` };
+            case "cron.list": {
+                const jobs = this.scheduler.listJobs();
+                const summary = jobs.length === 0
+                    ? "no cron jobs"
+                    : jobs.map((job) => `${job.id}\t${job.schedule}\tlast=${job.lastRun ?? "never"}`).join("\n");
+                return { ok: true, summary, data: jobs };
+            }
+            case "cron.trigger": {
+                const result = await this.scheduler.triggerJob(command.jobId);
+                return { ok: result.ok, message: result.message };
+            }
+            case "message.send": {
+                const receipt = await this.router.send({
+                    from: command.from,
+                    to: command.to,
+                    content: command.content,
+                    priority: command.priority,
+                    sessionId: command.sessionId,
+                    taskRef: command.taskRef,
+                });
+                this.processManager.sendToAgent?.(command.to, { type: "message" });
+                return { ok: true, message: `queued message ${receipt.id}`, data: receipt };
+            }
+            case "message.poll": {
+                const messages = this.router.pollInbox(command.agent);
+                return {
+                    ok: true,
+                    summary: `${messages.length} messages`,
+                    data: messages,
+                };
+            }
+            case "chat.connect":
+                await this.processManager.startAgent(command.agent);
+                return {
+                    ok: true,
+                    message: `connected to ${command.agent}`,
+                };
+            case "task.poke": {
+                const receipt = await this.router.send({
+                    from: "ouro-poke",
+                    to: command.agent,
+                    content: `poke ${command.taskId}`,
+                    priority: "high",
+                    taskRef: command.taskId,
+                });
+                await this.scheduler.recordTaskRun?.(command.agent, command.taskId);
+                this.processManager.sendToAgent?.(command.agent, { type: "poke", taskId: command.taskId });
+                return {
+                    ok: true,
+                    message: `queued poke ${receipt.id}`,
+                    data: receipt,
+                };
+            }
+            case "hatch.start":
+                return {
+                    ok: true,
+                    message: "hatch flow is stubbed in Gate 3 and completed in Gate 6",
+                };
+            default:
+                return {
+                    ok: false,
+                    error: `Unknown daemon command kind '${command.kind}'.`,
+                };
+        }
+    }
+}
+exports.OuroDaemon = OuroDaemon;

package/dist/heart/daemon/hatch-flow.js

@@ -0,0 +1,285 @@
+"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.runHatchFlow = runHatchFlow;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+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"];
+}
+function validateCredentials(provider, credentials) {
+    const missing = requiredCredentialKeys(provider).filter((key) => {
+        const value = credentials[key];
+        return typeof value !== "string" || value.trim().length === 0;
+    });
+    if (missing.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.hatch_credentials_error",
+            message: "hatch flow credentials validation failed",
+            meta: { provider, missing },
+        });
+        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;
+}
+function writeReadme(dir, purpose) {
+    fs.mkdirSync(dir, { recursive: true });
+    const readmePath = path.join(dir, "README.md");
+    if (!fs.existsSync(readmePath)) {
+        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");
+    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");
+    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 record = {
+        id,
+        name: humanName,
+        role: "primary",
+        trustLevel: "family",
+        connections: [],
+        externalIds: [
+            {
+                provider: "local",
+                externalId: localExternalId,
+                linkedAt: nowIso,
+            },
+        ],
+        tenantMemberships: [],
+        toolPreferences: {},
+        notes: {},
+        totalTokens: 0,
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        schemaVersion: 1,
+    };
+    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 writeHatchlingAgentConfig(bundleRoot, input) {
+    const template = (0, identity_1.buildDefaultAgentTemplate)(input.agentName);
+    template.provider = input.provider;
+    template.enabled = true;
+    fs.writeFileSync(path.join(bundleRoot, "agent.json"), `${JSON.stringify(template, null, 2)}\n`, "utf-8");
+}
+async function runHatchFlow(input, deps = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_flow_start",
+        message: "starting hatch flow",
+        meta: { agentName: input.agentName, provider: input.provider },
+    });
+    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();
+    const random = deps.random ?? Math.random;
+    (0, hatch_specialist_1.syncSpecialistIdentities)({
+        sourceDir: sourceIdentities,
+        targetDir: targetIdentities,
+    });
+    const selected = (0, hatch_specialist_1.pickRandomSpecialistIdentity)({
+        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, "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, "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);
+    writeFriendImprint(bundleRoot, input.humanName, now);
+    writeHeartbeatTask(bundleRoot, now);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_flow_end",
+        message: "completed hatch flow",
+        meta: { bundleRoot, identity: selected.fileName },
+    });
+    return {
+        bundleRoot,
+        selectedIdentity: selected.fileName,
+        specialistSecretsPath,
+        hatchlingSecretsPath,
+    };
+}