@ouro.bot/cli 0.1.0-alpha.15 → 0.1.0-alpha.150

package/dist/heart/daemon/session-id-resolver.js

@@ -0,0 +1,131 @@
+"use strict";
+// Pluggable session ID resolver for MCP conversations.
+// Tries tool-specific methods first, falls back to UUID.
+//
+// Claude Code: walks parent PID chain -> reads ~/.claude/sessions/{pid}.json
+// Codex: reads thread_id from env (future)
+// Fallback: generates UUID
+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.resolveSessionId = resolveSessionId;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_CLAUDE_SESSIONS_DIR = path.join(os.homedir(), ".claude", "sessions");
+const MAX_PID_WALK_DEPTH = 10;
+/**
+ * Try to read a Claude Code session ID from a PID-keyed session file.
+ * Returns the sessionId if found, null otherwise.
+ */
+function tryReadClaudeSession(sessionsDir, pid) {
+    const sessionFile = path.join(sessionsDir, `${pid}.json`);
+    if (!fs.existsSync(sessionFile))
+        return null;
+    try {
+        const raw = fs.readFileSync(sessionFile, "utf-8");
+        const data = JSON.parse(raw);
+        if (typeof data.sessionId === "string" && data.sessionId.length > 0) {
+            return data.sessionId;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Walk the parent PID chain looking for a Claude Code session file.
+ * Starts at the current process PID, walks up to parent, grandparent, etc.
+ * Returns the session ID from the first matching file, or null.
+ */
+function walkPidChain(sessionsDir) {
+    let currentPid = process.pid;
+    for (let depth = 0; depth < MAX_PID_WALK_DEPTH; depth++) {
+        const sessionId = tryReadClaudeSession(sessionsDir, currentPid);
+        if (sessionId) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_id_pid_walk_hit",
+                message: "found Claude session via PID walk",
+                meta: { pid: currentPid, depth, sessionId },
+            });
+            return sessionId;
+        }
+        // Walk to parent PID
+        // On macOS/Linux, process.ppid gives the parent. For deeper ancestry,
+        // we'd need /proc/{pid}/stat or ps -o ppid=. For now, we check current + parent.
+        if (depth === 0) {
+            currentPid = process.ppid;
+        }
+        else {
+            // Cannot walk further without OS-specific process tree APIs
+            break;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a session ID for the current MCP connection.
+ * Returns a stable identifier that ties MCP tool calls to a conversation session.
+ *
+ * Resolution order:
+ * 1. Claude Code PID walk: check ~/.claude/sessions/{pid}.json for current + parent PID
+ * 2. UUID fallback: generate a random UUID
+ */
+function resolveSessionId(options) {
+    const sessionsDir = options?.claudeSessionsDir ?? DEFAULT_CLAUDE_SESSIONS_DIR;
+    // Try Claude Code PID walk
+    const claudeSessionId = walkPidChain(sessionsDir);
+    if (claudeSessionId) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.session_id_resolved",
+            message: "session ID resolved via Claude Code PID walk",
+            meta: { sessionId: claudeSessionId, method: "claude-pid-walk" },
+        });
+        return claudeSessionId;
+    }
+    // Fallback: UUID
+    const sessionId = (0, crypto_1.randomUUID)();
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_id_resolved",
+        message: "session ID resolved via UUID fallback",
+        meta: { sessionId, method: "uuid-fallback" },
+    });
+    return sessionId;
+}

package/dist/heart/daemon/skill-management-installer.js

@@ -0,0 +1,94 @@
+"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.ensureSkillManagement = ensureSkillManagement;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const SKILL_MANAGEMENT_URL = "https://raw.githubusercontent.com/ouroborosbot/ouroboros-skills/main/skills/skill-management/SKILL.md";
+async function ensureSkillManagement() {
+    const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+    if (!fs.existsSync(bundlesRoot))
+        return;
+    // Find all agent bundles
+    const entries = fs.readdirSync(bundlesRoot).filter(e => e.endsWith(".ouro"));
+    if (entries.length === 0)
+        return;
+    // Check if ANY bundle is missing the skill
+    const missing = entries.filter(e => {
+        const targetPath = path.join(bundlesRoot, e, "skills", "skill-management.md");
+        return !fs.existsSync(targetPath);
+    });
+    if (missing.length === 0)
+        return;
+    // eslint-disable-next-line no-console -- terminal UX: visible install status
+    console.log("installing skill-management from ouroboros-skills...");
+    try {
+        const response = await fetch(SKILL_MANAGEMENT_URL);
+        if (!response.ok) {
+            // eslint-disable-next-line no-console -- terminal UX: visible install status
+            console.error(`✗ failed to fetch skill-management (HTTP ${response.status})`);
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.skill_management_install_error",
+                message: "failed to fetch skill-management from GitHub",
+                meta: { status: response.status, url: SKILL_MANAGEMENT_URL },
+            });
+            return;
+        }
+        const content = await response.text();
+        for (const bundle of missing) {
+            const skillsDir = path.join(bundlesRoot, bundle, "skills");
+            const targetPath = path.join(skillsDir, "skill-management.md");
+            fs.mkdirSync(skillsDir, { recursive: true });
+            fs.writeFileSync(targetPath, content, "utf-8");
+        }
+        // eslint-disable-next-line no-console -- terminal UX: visible install status
+        console.log(`✓ installed skill-management (${missing.length} agent${missing.length > 1 ? "s" : ""})`);
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console -- terminal UX: visible install status
+        console.error(`✗ failed to install skill-management: ${error instanceof Error ? error.message : String(error)}`);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.skill_management_install_error",
+            message: "failed to install skill-management skill",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+}

package/dist/heart/daemon/socket-client.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.sendDaemonCommand = sendDaemonCommand;
+exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
+exports.requestInnerWake = requestInnerWake;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+function sendDaemonCommand(socketPath, command) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_command_start",
+        message: "sending daemon command over socket",
+        meta: { socketPath, kind: command.kind },
+    });
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        client.on("connect", () => {
+            client.write(JSON.stringify(command));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.socket_command_error",
+                message: "daemon socket command failed",
+                meta: {
+                    socketPath,
+                    kind: command.kind,
+                    error: error.message,
+                },
+            });
+            reject(error);
+        });
+        client.on("end", () => {
+            const trimmed = raw.trim();
+            if (trimmed.length === 0 && command.kind === "daemon.stop") {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: { socketPath, kind: command.kind, ok: true },
+                });
+                resolve({ ok: true, message: "daemon stopped" });
+                return;
+            }
+            if (trimmed.length === 0) {
+                const error = new Error("Daemon returned empty response.");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned empty response",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error.message,
+                    },
+                });
+                reject(error);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.socket_command_end",
+                    message: "daemon socket command completed",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        ok: parsed.ok,
+                    },
+                });
+                resolve(parsed);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.socket_command_error",
+                    message: "daemon socket command returned invalid JSON",
+                    meta: {
+                        socketPath,
+                        kind: command.kind,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+                reject(error);
+            }
+        });
+    });
+}
+function checkDaemonSocketAlive(socketPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.socket_alive_check_start",
+        message: "checking daemon socket health",
+        meta: { socketPath },
+    });
+    return new Promise((resolve) => {
+        const client = net.createConnection(socketPath);
+        let raw = "";
+        let done = false;
+        const finalize = (alive) => {
+            if (done)
+                return;
+            done = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.socket_alive_check_end",
+                message: "daemon socket health check completed",
+                meta: { socketPath, alive },
+            });
+            resolve(alive);
+        };
+        if ("setTimeout" in client && typeof client.setTimeout === "function") {
+            client.setTimeout(800, () => {
+                client.destroy();
+                finalize(false);
+            });
+        }
+        client.on("connect", () => {
+            client.write(JSON.stringify({ kind: "daemon.status" }));
+            client.end();
+        });
+        client.on("data", (chunk) => {
+            raw += chunk.toString("utf-8");
+        });
+        client.on("error", () => finalize(false));
+        client.on("end", () => {
+            if (raw.trim().length === 0) {
+                finalize(false);
+                return;
+            }
+            try {
+                JSON.parse(raw);
+                finalize(true);
+            }
+            catch {
+                finalize(false);
+            }
+        });
+    });
+}
+async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    const socketAvailable = fs.existsSync(socketPath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.inner_wake_request",
+        message: "requesting daemon-managed inner wake",
+        meta: {
+            agent,
+            socketPath,
+            socketAvailable,
+        },
+    });
+    if (!socketAvailable) {
+        return null;
+    }
+    return sendDaemonCommand(socketPath, { kind: "inner.wake", agent });
+}

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

@@ -99,10 +99,10 @@ function pickRandomIdentity(identitiesDir, random = Math.random) {
         files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
     }
     catch {
-        return { fileName: "default", content: "I am the adoption specialist." };
+        return { fileName: "default", content: "I am a serpent guide who helps humans hatch their first agent." };
     }
     if (files.length === 0) {
-        return { fileName: "default", content: "I am the adoption specialist." };
+        return { fileName: "default", content: "I am a serpent guide who helps humans hatch their first agent." };
     }
     const idx = Math.floor(random() * files.length);
     const fileName = files[idx];

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

@@ -28,9 +28,10 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
     }
     sections.push([
         "## Who I am",
-        "I am one of thirteen adoption specialists. The system randomly selected me for this session.",
-        "Most humans only go through adoption once, so this is likely the only time they'll meet me.",
+        "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.",
         "",
         "## Voice rules",
         "IMPORTANT: I keep every response to 1-3 short sentences. I sound like a friend texting, not a manual.",
@@ -69,28 +70,30 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, co
     ].join("\n"));
     sections.push([
         "## Conversation flow",
-        "The human just connected. I speak first — I greet them warmly and introduce myself in my own voice.",
-        "I briefly mention that I'm one of several adoption specialists and they got me today.",
+        "The human just connected. I speak first — I greet them warmly and introduce myself by name in my own voice.",
+        "I briefly mention that I'm one of several serpent guides and they got me today.",
         "I ask their name.",
         "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`, `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");
 }

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSpecialistTools = getSpecialistTools;
 exports.createSpecialistExecTool = createSpecialistExecTool;
+const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const tools_base_1 = require("../../repertoire/tools-base");
@@ -58,6 +59,14 @@ const completeAdoptionTool = {
                     type: "string",
                     description: "a warm handoff message to display to the human after the agent is hatched",
                 },
+                phone: {
+                    type: "string",
+                    description: "the human's phone number (optional, for iMessage contact recognition)",
+                },
+                teams_handle: {
+                    type: "string",
+                    description: "the human's Teams email/handle (optional, for Teams contact recognition)",
+                },
             },
             required: ["name", "handoff_message"],
         },
@@ -65,12 +74,23 @@ const completeAdoptionTool = {
 };
 const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
 const writeFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "write_file");
-const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+const listDirToolSchema = {
+    type: "function",
+    function: {
+        name: "list_directory",
+        description: "list directory contents",
+        parameters: {
+            type: "object",
+            properties: { path: { type: "string" } },
+            required: ["path"],
+        },
+    },
+};
 /**
  * Returns the specialist's tool schema array.
  */
 function getSpecialistTools() {
-    return [completeAdoptionTool, tools_base_1.finalAnswerTool, readFileTool.tool, writeFileTool.tool, listDirTool.tool];
+    return [completeAdoptionTool, tools_base_1.settleTool, readFileTool.tool, writeFileTool.tool, listDirToolSchema];
 }
 const PSYCHE_FILES = ["SOUL.md", "IDENTITY.md", "LORE.md", "TACIT.md", "ASPIRATIONS.md"];
 function isPascalCase(name) {
@@ -90,8 +110,8 @@ function scaffoldBundle(bundleRoot) {
     writeReadme(path.join(bundleRoot, "memory", "archive"), "Archived memory.");
     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, "habits"), "Recurring habits and autonomous rhythms.");
     writeReadme(path.join(bundleRoot, "tasks", "ongoing"), "Ongoing tasks.");
     writeReadme(path.join(bundleRoot, "skills"), "Local skill files.");
     writeReadme(path.join(bundleRoot, "senses"), "Sense-specific config.");
@@ -164,6 +184,32 @@ async function execCompleteAdoption(args, deps) {
         }
         return `error: failed to write secrets: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
     }
+    // Create initial friend record if contact info provided
+    const phone = args.phone;
+    const teamsHandle = args.teams_handle;
+    if (phone || teamsHandle) {
+        const friendId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const externalIds = [];
+        if (phone)
+            externalIds.push({ provider: "imessage-handle", externalId: phone, linkedAt: now });
+        if (teamsHandle)
+            externalIds.push({ provider: "aad", externalId: teamsHandle, linkedAt: now });
+        const friendRecord = {
+            id: friendId,
+            name: deps.humanName ?? "primary",
+            trustLevel: "family",
+            externalIds,
+            tenantMemberships: [],
+            toolPreferences: {},
+            notes: {},
+            createdAt: now,
+            updatedAt: now,
+            schemaVersion: 1,
+        };
+        const friendPath = path.join(targetBundle, "friends", `${friendId}.json`);
+        fs.writeFileSync(friendPath, JSON.stringify(friendRecord, null, 2), "utf-8");
+    }
     // Play hatch animation
     await (0, hatch_animation_1.playHatchAnimation)(name, deps.animationWriter);
     // Display handoff message
@@ -211,7 +257,10 @@ function createSpecialistExecTool(deps) {
             try {
                 const dir = path.dirname(args.path);
                 fs.mkdirSync(dir, { recursive: true });
-                fs.writeFileSync(args.path, args.content, "utf-8");
+                const content = typeof args.content === "string"
+                    ? args.content
+                    : JSON.stringify(args.content, null, 2);
+                fs.writeFileSync(args.path, content, "utf-8");
                 return `wrote ${args.path}`;
             }
             catch (e) {