@ouro.bot/cli 0.1.0-alpha.7 → 0.1.0-alpha.71

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

@@ -33,17 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runAdoptionSpecialist = runAdoptionSpecialist;
+exports.listExistingBundles = listExistingBundles;
+exports.loadIdentityPhrases = loadIdentityPhrases;
+exports.pickRandomIdentity = pickRandomIdentity;
+exports.loadSoulText = loadSoulText;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const identity_1 = require("../identity");
-const config_1 = require("../config");
-const core_1 = require("../core");
-const hatch_flow_1 = require("./hatch-flow");
-const specialist_prompt_1 = require("./specialist-prompt");
-const specialist_tools_1 = require("./specialist-tools");
-const specialist_session_1 = require("./specialist-session");
+/**
+ * List existing .ouro bundles in the given directory.
+ */
 function listExistingBundles(bundlesRoot) {
     let entries;
     try {
@@ -61,100 +61,69 @@ function listExistingBundles(bundlesRoot) {
     }
     return discovered.sort((a, b) => a.localeCompare(b));
 }
-function pickRandomIdentity(identitiesDir, random) {
-    const files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
-    if (files.length === 0) {
-        return { fileName: "default", content: "I am the adoption specialist." };
+/**
+ * Load identity-specific phrases from the specialist's agent.json.
+ * Falls back to DEFAULT_AGENT_PHRASES if not found.
+ */
+function loadIdentityPhrases(bundleSourceDir, identityFileName) {
+    const agentJsonPath = path.join(bundleSourceDir, "agent.json");
+    try {
+        const raw = fs.readFileSync(agentJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const identityKey = identityFileName.replace(/\.md$/, "");
+        const identity = parsed.identityPhrases?.[identityKey];
+        if (identity?.thinking?.length && identity?.tool?.length && identity?.followup?.length) {
+            return identity;
+        }
+        if (parsed.phrases?.thinking?.length && parsed.phrases?.tool?.length && parsed.phrases?.followup?.length) {
+            return parsed.phrases;
+        }
     }
-    const idx = Math.floor(random() * files.length);
-    const fileName = files[idx];
-    const content = fs.readFileSync(path.join(identitiesDir, fileName), "utf-8");
-    return { fileName, content };
+    catch {
+        // agent.json missing or malformed -- fall through
+    }
+    return { ...identity_1.DEFAULT_AGENT_PHRASES };
 }
 /**
- * Run the full adoption specialist flow:
- * 1. Pick a random identity from the bundled AdoptionSpecialist.ouro
- * 2. Read SOUL.md
- * 3. List existing bundles
- * 4. Build system prompt
- * 5. Set up provider (setAgentName, setAgentConfigOverride, writeSecretsFile, reset caches)
- * 6. Run the specialist session
- * 7. Clean up identity/config overrides
- * 8. Return hatchling name
+ * Pick a random identity from the specialist's identities directory.
  */
-async function runAdoptionSpecialist(deps) {
-    const { bundleSourceDir, bundlesRoot, secretsRoot, provider, credentials, humanName, callbacks, signal } = deps;
-    const random = deps.random ?? Math.random;
+function pickRandomIdentity(identitiesDir, random = Math.random) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
-        event: "daemon.specialist_orchestrator_start",
-        message: "starting adoption specialist orchestrator",
-        meta: { provider, bundleSourceDir },
+        event: "daemon.specialist_identity_pick",
+        message: "picking specialist identity",
+        meta: { identitiesDir },
     });
-    // 1. Read SOUL.md
-    const soulPath = path.join(bundleSourceDir, "psyche", "SOUL.md");
-    let soulText = "";
+    let files;
     try {
-        soulText = fs.readFileSync(soulPath, "utf-8");
+        files = fs.readdirSync(identitiesDir).filter((f) => f.endsWith(".md"));
     }
     catch {
-        // No SOUL.md -- proceed without it
+        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 a serpent guide who helps humans hatch their first agent." };
     }
-    // 2. Pick random identity
-    const identitiesDir = path.join(bundleSourceDir, "psyche", "identities");
-    const identity = pickRandomIdentity(identitiesDir, random);
+    const idx = Math.floor(random() * files.length);
+    const fileName = files[idx];
+    const content = fs.readFileSync(path.join(identitiesDir, fileName), "utf-8");
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.specialist_identity_picked",
         message: "picked specialist identity",
-        meta: { identity: identity.fileName },
-    });
-    // 3. List existing bundles
-    const existingBundles = listExistingBundles(bundlesRoot);
-    // 4. Build system prompt
-    const systemPrompt = (0, specialist_prompt_1.buildSpecialistSystemPrompt)(soulText, identity.content, existingBundles);
-    // 5. Set up provider
-    (0, identity_1.setAgentName)("AdoptionSpecialist");
-    (0, identity_1.setAgentConfigOverride)({
-        version: 1,
-        enabled: true,
-        provider,
-        phrases: { thinking: ["thinking"], tool: ["checking"], followup: ["processing"] },
+        meta: { identity: fileName },
     });
-    (0, hatch_flow_1.writeSecretsFile)("AdoptionSpecialist", provider, credentials, secretsRoot);
-    (0, config_1.resetConfigCache)();
-    (0, core_1.resetProviderRuntime)();
+    return { fileName, content };
+}
+/**
+ * Read SOUL.md from the specialist bundle.
+ */
+function loadSoulText(bundleSourceDir) {
+    const soulPath = path.join(bundleSourceDir, "psyche", "SOUL.md");
     try {
-        // Create provider runtime
-        const providerRuntime = (0, core_1.createProviderRegistry)().resolve();
-        if (!providerRuntime) {
-            throw new Error("Failed to create provider runtime for adoption specialist");
-        }
-        // 6. Run session
-        const tools = (0, specialist_tools_1.getSpecialistTools)();
-        const readline = deps.createReadline();
-        const result = await (0, specialist_session_1.runSpecialistSession)({
-            providerRuntime,
-            systemPrompt,
-            tools,
-            execTool: (name, args) => (0, specialist_tools_1.execSpecialistTool)(name, args, {
-                humanName,
-                provider,
-                credentials,
-                bundlesRoot,
-                secretsRoot,
-                specialistIdentitiesDir: identitiesDir,
-            }),
-            readline,
-            callbacks,
-            signal,
-        });
-        return result.hatchedAgentName;
+        return fs.readFileSync(soulPath, "utf-8");
     }
-    finally {
-        // 7. Cleanup: restore identity/config state
-        (0, identity_1.setAgentConfigOverride)(null);
-        (0, config_1.resetConfigCache)();
-        (0, core_1.resetProviderRuntime)();
+    catch {
+        return "";
     }
 }

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

@@ -6,12 +6,12 @@ const runtime_1 = require("../../nerves/runtime");
  * Build the adoption specialist's system prompt from its components.
  * The prompt is written in first person (the specialist's own voice).
  */
-function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
+function buildSpecialistSystemPrompt(soulText, identityText, existingBundles, context) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.specialist_prompt_build",
         message: "building specialist system prompt",
-        meta: { bundleCount: existingBundles.length },
+        meta: { bundleCount: existingBundles.length, provider: context.provider },
     });
     const sections = [];
     if (soulText) {
@@ -26,13 +26,72 @@ function buildSpecialistSystemPrompt(soulText, identityText, existingBundles) {
     else {
         sections.push("## Existing agents\nThe human has no agents yet. This will be their first hatchling.");
     }
+    sections.push([
+        "## Who I am",
+        "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.",
+        "I NEVER use headers, bullet lists, numbered lists, or markdown formatting.",
+        "I ask ONE question at a time. I do not dump multiple questions or options.",
+        "I am warm but brief. Every word earns its place.",
+    ].join("\n"));
+    sections.push([
+        "## System context",
+        `Provider: ${context.provider}`,
+        `Temp directory: ${context.tempDir}`,
+        "Final home: ~/AgentBundles/<Name>.ouro/",
+        "Secrets: ~/.agentsecrets/<name>/secrets.json",
+    ].join("\n"));
+    sections.push([
+        "## Bundle creation guidelines",
+        "A bundle has a psyche/ directory with 5 files that define the agent's personality:",
+        "",
+        "- **SOUL.md** — core values, personality traits, communication style",
+        "- **IDENTITY.md** — who the agent is, its name, relationship to the human",
+        "- **LORE.md** — backstory, origin, any seed narrative",
+        "- **TACIT.md** — implicit operating principles, habits to develop",
+        "- **ASPIRATIONS.md** — goals, what the agent aspires to become",
+        "",
+        "It also needs an **agent.json** with at minimum:",
+        '```json',
+        '{',
+        '  "name": "AgentName",',
+        `  "provider": "${context.provider}",`,
+        '  "enabled": true',
+        '}',
+        '```',
+        "",
+        "All psyche files should be written in first person (the agent's own voice).",
+        "Write these files to the temp directory using write_file before calling complete_adoption.",
+    ].join("\n"));
+    sections.push([
+        "## Conversation flow",
+        "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",
+    ].join("\n"));
     sections.push([
         "## Tools",
-        "I have these tools available:",
-        "- `hatch_agent`: Create a new agent bundle. I call this with a `name` parameter once I have enough information from the human.",
-        "- `final_answer`: End the conversation with a final message to the human. I call this when the adoption process is complete.",
+        "- `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.",
         "",
         "I must call `final_answer` when I am done to end the session cleanly.",
     ].join("\n"));

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

@@ -34,95 +34,250 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSpecialistTools = getSpecialistTools;
-exports.execSpecialistTool = execSpecialistTool;
+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");
 const hatch_flow_1 = require("./hatch-flow");
 const hatch_animation_1 = require("./hatch-animation");
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const runtime_1 = require("../../nerves/runtime");
-const hatchAgentTool = {
+const completeAdoptionTool = {
     type: "function",
     function: {
-        name: "hatch_agent",
-        description: "create a new agent bundle with the given name. call this when you have gathered enough information from the human to hatch their agent.",
+        name: "complete_adoption",
+        description: "finalize the agent bundle and hatch the new agent. call this only when you have written all 5 psyche files and agent.json to the temp directory, and the human has approved the bundle.",
         parameters: {
             type: "object",
             properties: {
                 name: {
                     type: "string",
-                    description: "the name for the new agent (PascalCase, e.g. 'Slugger')",
+                    description: "the PascalCase name for the new agent (e.g. 'Slugger')",
+                },
+                handoff_message: {
+                    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"],
+            required: ["name", "handoff_message"],
         },
     },
 };
 const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
-const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+const writeFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "write_file");
+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 [hatchAgentTool, tools_base_1.finalAnswerTool, readFileTool.tool, listDirTool.tool];
+    return [completeAdoptionTool, tools_base_1.finalAnswerTool, readFileTool.tool, writeFileTool.tool, listDirToolSchema];
+}
+const PSYCHE_FILES = ["SOUL.md", "IDENTITY.md", "LORE.md", "TACIT.md", "ASPIRATIONS.md"];
+function isPascalCase(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function writeReadme(dir, purpose) {
+    fs.mkdirSync(dir, { recursive: true });
+    const readmePath = path.join(dir, "README.md");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(readmePath)) {
+        fs.writeFileSync(readmePath, `# ${path.basename(dir)}\n\n${purpose}\n`, "utf-8");
+    }
+}
+function scaffoldBundle(bundleRoot) {
+    writeReadme(path.join(bundleRoot, "memory"), "Persistent memory store.");
+    writeReadme(path.join(bundleRoot, "memory", "daily"), "Daily memory entries.");
+    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, "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.");
+    // Memory scaffold files
+    const memoryRoot = path.join(bundleRoot, "memory");
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    const entitiesPath = path.join(memoryRoot, "entities.json");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(factsPath))
+        fs.writeFileSync(factsPath, "", "utf-8");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(entitiesPath))
+        fs.writeFileSync(entitiesPath, "{}\n", "utf-8");
+    // bundle-meta.json
+    const meta = (0, bundle_manifest_1.createBundleMeta)();
+    fs.writeFileSync(path.join(bundleRoot, "bundle-meta.json"), JSON.stringify(meta, null, 2) + "\n", "utf-8");
+}
+function moveDir(src, dest) {
+    try {
+        fs.renameSync(src, dest);
+    }
+    catch {
+        /* v8 ignore start -- cross-device fallback: only triggers on EXDEV (e.g. /tmp → different mount), untestable in CI @preserve */
+        fs.cpSync(src, dest, { recursive: true });
+        fs.rmSync(src, { recursive: true, force: true });
+        /* v8 ignore stop */
+    }
+}
+async function execCompleteAdoption(args, deps) {
+    const name = args.name;
+    const handoffMessage = args.handoff_message;
+    if (!name) {
+        return "error: missing required 'name' parameter";
+    }
+    if (!isPascalCase(name)) {
+        return `error: name '${name}' must be PascalCase (e.g. 'Slugger', 'MyAgent')`;
+    }
+    // Validate psyche files exist
+    const psycheDir = path.join(deps.tempDir, "psyche");
+    const missingPsyche = PSYCHE_FILES.filter((f) => !fs.existsSync(path.join(psycheDir, f)));
+    if (missingPsyche.length > 0) {
+        return `error: missing psyche files in temp directory: ${missingPsyche.join(", ")}. write them first using write_file.`;
+    }
+    // Validate agent.json exists
+    const agentJsonPath = path.join(deps.tempDir, "agent.json");
+    if (!fs.existsSync(agentJsonPath)) {
+        return "error: agent.json not found in temp directory. write it first using write_file.";
+    }
+    // Validate target doesn't exist
+    const targetBundle = path.join(deps.bundlesRoot, `${name}.ouro`);
+    if (fs.existsSync(targetBundle)) {
+        return `error: bundle '${name}.ouro' already exists at ${deps.bundlesRoot}. choose a different name.`;
+    }
+    // Scaffold structural dirs into tempDir
+    scaffoldBundle(deps.tempDir);
+    // Move tempDir -> final bundle location
+    moveDir(deps.tempDir, targetBundle);
+    // Write secrets
+    try {
+        (0, hatch_flow_1.writeSecretsFile)(name, deps.provider, deps.credentials, deps.secretsRoot);
+    }
+    catch (e) {
+        // Rollback: remove the moved bundle
+        try {
+            fs.rmSync(targetBundle, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort cleanup
+        }
+        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
+    /* v8 ignore next -- UI-only: handoff message display, covered by integration @preserve */
+    if (handoffMessage && deps.animationWriter) {
+        deps.animationWriter(`\n${handoffMessage}\n`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.adoption_complete",
+        message: "adoption completed successfully",
+        meta: { agentName: name, bundlePath: targetBundle },
+    });
+    return JSON.stringify({ success: true, agentName: name, bundlePath: targetBundle });
 }
 /**
- * Execute a specialist tool call.
- * Returns the tool result string.
+ * Create a specialist tool executor with the given dependencies captured in closure.
  */
-async function execSpecialistTool(name, args, deps) {
+function createSpecialistExecTool(deps) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
-        event: "daemon.specialist_tool_exec",
-        message: "executing specialist tool",
-        meta: { tool: name },
+        event: "daemon.specialist_exec_tool_created",
+        message: "specialist exec tool created",
+        meta: { tempDir: deps.tempDir },
     });
-    if (name === "hatch_agent") {
-        const agentName = args.name;
-        if (!agentName) {
-            return "error: missing required 'name' parameter for hatch_agent";
-        }
-        const input = {
-            agentName,
-            humanName: deps.humanName,
-            provider: deps.provider,
-            credentials: deps.credentials,
-        };
-        // Pass identity dirs to prevent hatch flow from syncing to ~/AgentBundles/AdoptionSpecialist.ouro/
-        // or cwd/AdoptionSpecialist.ouro/. The specialist already picked its identity; the hatch flow
-        // just needs a valid source dir to pick from for the hatchling's LORE.md seed.
-        const identitiesDir = deps.specialistIdentitiesDir;
-        const result = await (0, hatch_flow_1.runHatchFlow)(input, {
-            bundlesRoot: deps.bundlesRoot,
-            secretsRoot: deps.secretsRoot,
-            ...(identitiesDir ? { specialistIdentitySourceDir: identitiesDir, specialistIdentityTargetDir: identitiesDir } : {}),
+    return async (name, args) => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.specialist_tool_exec",
+            message: "executing specialist tool",
+            meta: { tool: name },
         });
-        await (0, hatch_animation_1.playHatchAnimation)(agentName, deps.animationWriter);
-        return [
-            `hatched ${agentName} successfully.`,
-            `bundle path: ${result.bundleRoot}`,
-            `identity seed: ${result.selectedIdentity}`,
-            `specialist secrets: ${result.specialistSecretsPath}`,
-            `hatchling secrets: ${result.hatchlingSecretsPath}`,
-        ].join("\n");
-    }
-    if (name === "read_file") {
-        try {
-            return fs.readFileSync(args.path, "utf-8");
+        if (name === "complete_adoption") {
+            return execCompleteAdoption(args, deps);
         }
-        catch (e) {
-            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        if (name === "read_file") {
+            try {
+                return fs.readFileSync(args.path, "utf-8");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
         }
-    }
-    if (name === "list_directory") {
-        try {
-            return fs
-                .readdirSync(args.path, { withFileTypes: true })
-                .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
-                .join("\n");
+        if (name === "write_file") {
+            try {
+                const dir = path.dirname(args.path);
+                fs.mkdirSync(dir, { recursive: true });
+                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) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
         }
-        catch (e) {
-            return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+        if (name === "list_directory") {
+            try {
+                return fs
+                    .readdirSync(args.path, { withFileTypes: true })
+                    .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
+                    .join("\n");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
         }
-    }
-    return `error: unknown tool '${name}'`;
+        return `error: unknown tool '${name}'`;
+    };
 }