agentopology 0.1.0

package/dist/bindings/openclaw.js

@@ -0,0 +1,1578 @@
+/**
+ * OpenClaw binding.
+ *
+ * Generates a complete OpenClaw workspace from a parsed {@link TopologyAST}:
+ * openclaw.json, SOUL.md, AGENTS.md, TOOLS.md, MEMORY.md, BOOTSTRAP.md,
+ * USER.md, IDENTITY.md, skill directories, gate/hook scripts, and workspace structure.
+ *
+ * OpenClaw is a multi-channel AI agent framework with gateway, channels,
+ * and markdown-based agent identity. This binding adds security hardening
+ * (auth required by default), quality gates, bounded loops, structured
+ * metrics, and workspace access control that OpenClaw lacks natively.
+ *
+ * @module
+ */
+import { deduplicateFiles } from "./types.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Convert a kebab-case id to Title Case. */
+function toTitle(id) {
+    return id
+        .split(/[-_]/)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+}
+/**
+ * Generate a human-readable model alias from a fully-qualified model string.
+ * E.g. "openrouter/google/gemini-2.5-flash" → "Gemini 2.5 Flash"
+ *      "openrouter/anthropic/claude-sonnet-4-6" → "Claude Sonnet 4.6"
+ */
+function modelAlias(model) {
+    // Extract last segment after the last "/"
+    const lastSlash = model.lastIndexOf("/");
+    const baseName = lastSlash >= 0 ? model.slice(lastSlash + 1) : model;
+    // Title-case each hyphen-separated word
+    const words = baseName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1));
+    // Join and convert version-like patterns: "4 6" → "4.6", "2 5" → "2.5"
+    return words.join(" ").replace(/(\d+)\s+(\d+)/g, "$1.$2");
+}
+/** Generate a shell script stub with a header comment. */
+function shellStub(description) {
+    return [
+        "#!/usr/bin/env bash",
+        `# ${description}`,
+        "# Auto-generated by agentopology scaffold — edit as needed.",
+        "set -euo pipefail",
+        "",
+        'echo "TODO: implement this script"',
+        "",
+    ].join("\n");
+}
+/** Generate an empty directory marker (a .gitkeep file). */
+function gitkeep(dirPath) {
+    return { path: `${dirPath}/.gitkeep`, content: "", category: "machine" };
+}
+/**
+ * Map topology model strings to OpenClaw model identifiers.
+ * OpenClaw uses `provider/model-id` format with hyphens.
+ */
+function mapModel(model, defaultProvider) {
+    const provider = defaultProvider ?? "anthropic";
+    const MODEL_MAP = {
+        opus: `${provider}/claude-opus-4-6`,
+        sonnet: `${provider}/claude-sonnet-4-6`,
+        haiku: `${provider}/claude-haiku-4-5`,
+    };
+    // If model already has provider prefix, return as-is
+    if (model.includes("/"))
+        return model;
+    return MODEL_MAP[model] ?? `${provider}/${model}`;
+}
+/**
+ * Map topology permission strings to OpenClaw permission labels.
+ */
+function mapPermissions(perm) {
+    switch (perm) {
+        case "auto":
+            return "autonomous";
+        case "plan":
+            return "supervised";
+        case "confirm":
+            return "interactive";
+        case "bypass":
+        case "bypassPermissions":
+            return "unrestricted";
+        case "supervised":
+        case "autonomous":
+        case "interactive":
+        case "unrestricted":
+            return perm;
+        default:
+            return "autonomous";
+    }
+}
+/**
+ * Extract openclaw-specific extension fields from the topology.
+ * Top-level `extensions { openclaw { ... } }` lives on `ast.extensions`.
+ */
+function getOpenClawExtensions(ast) {
+    // Top-level extensions block (ast.extensions.openclaw)
+    const topExt = ast.extensions;
+    if (topExt?.openclaw)
+        return topExt.openclaw;
+    // Legacy fallback: settings.extensions
+    const settingsExt = ast.settings?.extensions;
+    if (settingsExt?.openclaw)
+        return settingsExt.openclaw;
+    return null;
+}
+/** Get the orchestrator node from AST nodes. */
+function getOrchestrator(ast) {
+    return ast.nodes.find((n) => n.type === "orchestrator");
+}
+/** Get all agent nodes from AST, sorted by phase. */
+function getAgentsSorted(ast) {
+    const agents = ast.nodes.filter((n) => n.type === "agent");
+    return agents.sort((a, b) => (a.phase ?? 0) - (b.phase ?? 0));
+}
+/** Get all gate nodes from AST. */
+function getGates(ast) {
+    return ast.nodes.filter((n) => n.type === "gate");
+}
+/** Get all human nodes from AST. */
+function getHumanNodes(ast) {
+    return ast.nodes.filter((n) => n.type === "human");
+}
+/** Get all group nodes from AST. */
+function getGroupNodes(ast) {
+    return ast.nodes.filter((n) => n.type === "group");
+}
+/** Format a schema field for documentation. */
+function formatSchemaField(field) {
+    const opt = field.optional ? "?" : "";
+    const typeStr = formatSchemaType(field.type);
+    return `${field.name}${opt}: ${typeStr}`;
+}
+/** Format a schema type expression to a string. */
+function formatSchemaType(t) {
+    switch (t.kind) {
+        case "primitive":
+            return t.value;
+        case "array":
+            return `${formatSchemaType(t.itemType)}[]`;
+        case "enum":
+            return t.values.join(" | ");
+        case "ref":
+            return t.name;
+    }
+}
+/** Format retry config for documentation. */
+function formatRetry(retry) {
+    if (typeof retry === "number")
+        return `max ${retry} attempts`;
+    const parts = [`max ${retry.max} attempts`];
+    if (retry.backoff)
+        parts.push(`backoff: ${retry.backoff}`);
+    if (retry.interval)
+        parts.push(`interval: ${retry.interval}`);
+    if (retry.maxInterval)
+        parts.push(`max interval: ${retry.maxInterval}`);
+    if (retry.jitter)
+        parts.push("jitter: on");
+    if (retry.nonRetryable && retry.nonRetryable.length > 0) {
+        parts.push(`non-retryable: ${retry.nonRetryable.join(", ")}`);
+    }
+    return parts.join(", ");
+}
+// ---------------------------------------------------------------------------
+// File generators
+// ---------------------------------------------------------------------------
+/** Get the default provider name from the AST providers list. */
+function getDefaultProviderName(ast) {
+    if (ast.providers && ast.providers.length > 0) {
+        const defaultProv = ast.providers.find((p) => p.default);
+        if (defaultProv)
+            return defaultProv.name;
+        return ast.providers[0].name;
+    }
+    return "anthropic";
+}
+/** Generate openclaw.json — central system config. */
+function generateOpenClawJson(ast) {
+    const ext = getOpenClawExtensions(ast);
+    const orchestrator = getOrchestrator(ast);
+    const agents = getAgentsSorted(ast);
+    const defaultProvider = getDefaultProviderName(ast);
+    // Build agent list for config
+    const agentList = [];
+    // Determine default model for agents.defaults
+    // If the orchestrator/first-agent model already has a provider prefix, use it
+    // as-is (mapModel already passes through slash-containing strings).
+    const defaultModel = orchestrator
+        ? mapModel(orchestrator.model, defaultProvider)
+        : agents.length > 0
+            ? mapModel(agents[0].model ?? "sonnet", defaultProvider)
+            : mapModel("sonnet", defaultProvider);
+    // Orchestrator as primary agent
+    if (orchestrator) {
+        const agentIds = agents.map((a) => a.id);
+        const orchModel = {
+            primary: mapModel(orchestrator.model, defaultProvider),
+        };
+        agentList.push({
+            id: "orchestrator",
+            name: toTitle(ast.topology.name) + " Coordinator",
+            model: orchModel,
+            workspace: `~/.openclaw/workspace-${ast.topology.name}`,
+            agentDir: `./config/agents/orchestrator/agent`,
+            subagents: {
+                allowAgents: agentIds,
+            },
+        });
+    }
+    // Each agent node
+    for (const agent of agents) {
+        const agentModel = {
+            primary: mapModel(agent.model ?? "sonnet", defaultProvider),
+        };
+        // Per-agent fallback chain goes into model.fallbacks
+        if (agent.fallbackChain && agent.fallbackChain.length > 0) {
+            agentModel.fallbacks = agent.fallbackChain.map((m) => mapModel(m, defaultProvider));
+        }
+        const entry = {
+            id: agent.id,
+            name: toTitle(agent.id),
+            model: agentModel,
+            workspace: `~/.openclaw/workspace-${agent.id}`,
+            agentDir: `./config/agents/${agent.id}/agent`,
+        };
+        // No per-agent tools in openclaw.json — tool restrictions go in AGENTS.md
+        // Sampling params
+        if (agent.temperature != null)
+            entry.temperature = agent.temperature;
+        if (agent.maxTokens != null)
+            entry.maxTokens = agent.maxTokens;
+        // Timeout
+        if (agent.timeout)
+            entry.timeout = agent.timeout;
+        // Merge agent-level openclaw extensions
+        if (agent.extensions?.openclaw) {
+            for (const [k, v] of Object.entries(agent.extensions.openclaw)) {
+                entry[k] = v;
+            }
+        }
+        agentList.push(entry);
+    }
+    // Build fallback chain for agents.defaults.model
+    let defaultFallbacks;
+    const settingsFallback = ast.settings?.fallbackChain;
+    if (settingsFallback && settingsFallback.length > 0) {
+        defaultFallbacks = settingsFallback.map((m) => mapModel(m, defaultProvider));
+    }
+    else if (ext?.["model-fallback-chain"]) {
+        const chain = ext["model-fallback-chain"];
+        defaultFallbacks = chain.map((m) => mapModel(m, defaultProvider));
+    }
+    // Build agents section with defaults
+    const agentsDefaults = {
+        workspace: "~/.openclaw/workspace",
+        model: defaultFallbacks
+            ? { primary: defaultModel, fallbacks: defaultFallbacks }
+            : { primary: defaultModel },
+    };
+    // Build config object
+    // Note: OpenClaw does NOT accept "name" or "version" at root level
+    const config = {
+        agents: {
+            defaults: agentsDefaults,
+            list: agentList,
+        },
+        gateway: {
+            port: ext?.["gateway-port"] ?? 18789,
+            auth: {
+                mode: "token",
+                token: (ext?.["auth-tokens"] ?? ["${OPENCLAW_AUTH_TOKEN}"])[0],
+            },
+        },
+    };
+    // First-class interfaces support — channels as named keys
+    if (ast.interfaces.length > 0) {
+        const channelConfig = {};
+        for (const iface of ast.interfaces) {
+            channelConfig[iface.id] = {
+                enabled: true,
+                type: iface.type,
+                ...iface.config,
+            };
+        }
+        config.channels = channelConfig;
+    }
+    else if (ext?.channels) {
+        // Extension fallback — channels as named keys
+        // ext.channels can be a real array or a parser-produced string like "[telegram]"
+        let channelNames;
+        if (Array.isArray(ext.channels)) {
+            channelNames = ext.channels;
+        }
+        else if (typeof ext.channels === "string") {
+            // Parse "[telegram, slack]" or "[telegram]" string format
+            const raw = ext.channels.replace(/^\[|\]$/g, "").trim();
+            channelNames = raw ? raw.split(/\s*,\s*/) : [];
+        }
+        else {
+            channelNames = [];
+        }
+        if (channelNames.length > 0) {
+            const channelConfig = {};
+            for (const ch of channelNames) {
+                const chConfig = { enabled: true };
+                // Channel config may be a nested object or flattened into ext
+                const chData = ext[ch];
+                if (chData && typeof chData === "object" && chData !== null && String(chData) !== "{") {
+                    const chExt = chData;
+                    // Map known channel fields
+                    if (ch === "telegram") {
+                        if (chExt["bot-token"])
+                            chConfig.botToken = chExt["bot-token"];
+                        if (chExt["dm-policy"])
+                            chConfig.dmPolicy = chExt["dm-policy"];
+                    }
+                    else if (ch === "slack") {
+                        if (chExt["app-token"])
+                            chConfig.appToken = chExt["app-token"];
+                        if (chExt["bot-token"])
+                            chConfig.botToken = chExt["bot-token"];
+                    }
+                    // Copy any remaining fields
+                    for (const [k, v] of Object.entries(chExt)) {
+                        const camelKey = k.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+                        if (!(camelKey in chConfig)) {
+                            chConfig[camelKey] = v;
+                        }
+                    }
+                }
+                else {
+                    // Parser flattened the channel config into ext — look for known fields
+                    if (ch === "telegram") {
+                        if (ext["bot-token"])
+                            chConfig.botToken = ext["bot-token"];
+                        if (ext["dm-policy"])
+                            chConfig.dmPolicy = ext["dm-policy"];
+                    }
+                    else if (ch === "slack") {
+                        if (ext["app-token"])
+                            chConfig.appToken = ext["app-token"];
+                        if (ext["bot-token"])
+                            chConfig.botToken = ext["bot-token"];
+                    }
+                }
+                channelConfig[ch] = chConfig;
+            }
+            config.channels = channelConfig;
+        }
+    }
+    // Cron — just enable the system; job definitions go in cron/jobs.json
+    if (ast.schedules.length > 0 || ext?.["cron-jobs"]) {
+        config.cron = { enabled: true };
+    }
+    // Plugins
+    if (ext?.plugins) {
+        config.plugins = ext.plugins;
+    }
+    // Providers — models.providers object (not top-level array)
+    const modelsProviders = {};
+    if (ast.providers && ast.providers.length > 0) {
+        for (const p of ast.providers) {
+            const provEntry = {};
+            if (p.apiKey)
+                provEntry.apiKey = p.apiKey;
+            if (p.baseUrl)
+                provEntry.baseUrl = p.baseUrl;
+            // OpenClaw expects models as an array of objects with at minimum { id, name }
+            if (p.models.length > 0) {
+                provEntry.models = p.models.map((m) => {
+                    const mapped = mapModel(m, p.name);
+                    return { id: mapped, name: modelAlias(m) };
+                });
+            }
+            // Note: OpenClaw does NOT accept "default" on providers
+            // Provider auth
+            if (p.auth) {
+                const authConfig = { type: p.auth.type };
+                if (p.auth.issuer)
+                    authConfig.issuer = p.auth.issuer;
+                if (p.auth.audience)
+                    authConfig.audience = p.auth.audience;
+                if (p.auth.tokenUrl)
+                    authConfig.tokenUrl = p.auth.tokenUrl;
+                if (p.auth.clientId)
+                    authConfig.clientId = p.auth.clientId;
+                if (p.auth.scopes && p.auth.scopes.length > 0)
+                    authConfig.scopes = p.auth.scopes;
+                provEntry.auth = authConfig;
+            }
+            // Merge extra fields
+            for (const [k, v] of Object.entries(p.extra)) {
+                provEntry[k] = v;
+            }
+            modelsProviders[p.name] = provEntry;
+        }
+    }
+    else {
+        // Default anthropic provider if none specified
+        modelsProviders.anthropic = {
+            apiKey: "${ANTHROPIC_API_KEY}",
+        };
+    }
+    config.models = { providers: modelsProviders };
+    // Note: OpenClaw does NOT support MCP servers. MCP tools should be
+    // implemented as OpenClaw skills instead. ast.mcpServers is intentionally
+    // not emitted into openclaw.json.
+    // Tools settings — flat allow/deny, no "defaults" nesting
+    const settings = ast.settings;
+    config.tools = {
+        allow: settings?.allow ?? [],
+        deny: settings?.deny ?? [],
+        agentToAgent: { enabled: true },
+    };
+    // Environment variables
+    if (Object.keys(ast.env).length > 0) {
+        const envBlock = {};
+        for (const [k, v] of Object.entries(ast.env)) {
+            envBlock[k] = typeof v === "string" ? v : v.value;
+        }
+        config.env = envBlock;
+    }
+    // Channel bindings — route channel messages to the default/first agent
+    if (config.channels) {
+        const channelNames = Object.keys(config.channels);
+        const defaultAgentId = orchestrator
+            ? "orchestrator"
+            : agents.length > 0
+                ? agents[0].id
+                : "default";
+        config.bindings = channelNames.map((ch) => ({
+            agentId: defaultAgentId,
+            match: { channel: ch },
+        }));
+    }
+    return {
+        path: "openclaw.json",
+        content: JSON.stringify(config, null, 2) + "\n",
+        category: "machine",
+    };
+}
+/** Generate cron/jobs.json — scheduled job definitions for OpenClaw. */
+function generateCronJobsJson(ast) {
+    const ext = getOpenClawExtensions(ast);
+    const jobs = [];
+    if (ast.schedules.length > 0) {
+        for (const job of ast.schedules) {
+            const expr = job.cron ?? job.every ?? "";
+            jobs.push({
+                id: job.id,
+                name: toTitle(job.id),
+                agentId: job.agent ?? "default",
+                enabled: job.enabled !== false,
+                schedule: { kind: "cron", expr },
+                payload: { kind: "agentTurn", message: `Run ${job.id.replace(/-/g, " ")}` },
+                sessionTarget: "isolated",
+            });
+        }
+    }
+    else if (ext?.["cron-jobs"]) {
+        // Legacy extension fallback — pass through
+        return {
+            path: "cron/jobs.json",
+            content: JSON.stringify({ jobs: ext["cron-jobs"] }, null, 2) + "\n",
+            category: "machine",
+        };
+    }
+    if (jobs.length === 0)
+        return null;
+    return {
+        path: "cron/jobs.json",
+        content: JSON.stringify({ jobs }, null, 2) + "\n",
+        category: "machine",
+    };
+}
+/** Generate SOUL.md — primary agent identity. */
+function generateSoulMd(ast) {
+    const orchestrator = getOrchestrator(ast);
+    const sections = [];
+    // Quote block with description
+    if (ast.topology.description) {
+        sections.push(`> ${ast.topology.description}`);
+        sections.push("");
+    }
+    // Identity
+    sections.push("## Identity");
+    sections.push(`- Name: ${toTitle(ast.topology.name)}`);
+    sections.push(`- Version: ${ast.topology.version}`);
+    if (orchestrator) {
+        sections.push(`- Model: ${mapModel(orchestrator.model)}`);
+    }
+    if (ast.topology.patterns.length > 0) {
+        sections.push(`- Patterns: ${ast.topology.patterns.join(", ")}`);
+    }
+    sections.push("");
+    // Mission
+    sections.push("## Mission");
+    const mission = ast.topology.description ?? "Coordinate agent topology.";
+    sections.push(mission);
+    sections.push("");
+    // Roles
+    if (Object.keys(ast.roles).length > 0) {
+        sections.push("## Roles");
+        for (const [roleName, roleDesc] of Object.entries(ast.roles)) {
+            sections.push(`### ${toTitle(roleName)}`);
+            sections.push(roleDesc);
+            sections.push("");
+        }
+    }
+    // Ethical guardrails
+    sections.push("## Ethical Guardrails");
+    if (orchestrator) {
+        sections.push(`- Permission model: ${mapPermissions(orchestrator.permissions ?? "auto")}`);
+    }
+    const deny = ast.settings?.deny;
+    sections.push(`- Tool restrictions: ${deny && deny.length > 0 ? deny.join(", ") : "none"}`);
+    sections.push("");
+    // Observability
+    if (ast.observability) {
+        const obs = ast.observability;
+        sections.push("## Observability");
+        sections.push(`- Enabled: ${obs.enabled}`);
+        sections.push(`- Level: ${obs.level}`);
+        sections.push(`- Exporter: ${obs.exporter}`);
+        if (obs.endpoint)
+            sections.push(`- Endpoint: ${obs.endpoint}`);
+        if (obs.service)
+            sections.push(`- Service: ${obs.service}`);
+        sections.push(`- Sample rate: ${obs.sampleRate}`);
+        sections.push(`- Capture: prompts=${obs.capture.prompts}, completions=${obs.capture.completions}, toolArgs=${obs.capture.toolArgs}, toolResults=${obs.capture.toolResults}`);
+        sections.push(`- Spans: agents=${obs.spans.agents}, tools=${obs.spans.tools}, gates=${obs.spans.gates}, memory=${obs.spans.memory}`);
+        sections.push("");
+    }
+    // Checkpoint
+    if (ast.checkpoint) {
+        const cp = ast.checkpoint;
+        sections.push("## Checkpoint / Durable Execution");
+        sections.push(`- Backend: ${cp.backend}`);
+        if (cp.connection)
+            sections.push(`- Connection: ${cp.connection}`);
+        sections.push(`- Strategy: ${cp.strategy}`);
+        if (cp.ttl)
+            sections.push(`- TTL: ${cp.ttl}`);
+        if (cp.replay) {
+            sections.push(`- Replay: enabled=${cp.replay.enabled}`);
+            if (cp.replay.maxHistory != null)
+                sections.push(`  - Max history: ${cp.replay.maxHistory}`);
+            if (cp.replay.branch != null)
+                sections.push(`  - Branch: ${cp.replay.branch}`);
+        }
+        sections.push("");
+    }
+    // Artifacts registry
+    if (ast.artifacts.length > 0) {
+        sections.push("## Artifacts");
+        for (const art of ast.artifacts) {
+            let line = `- **${art.id}** (${art.type})`;
+            if (art.path)
+                line += ` — path: ${art.path}`;
+            if (art.retention)
+                line += ` — retention: ${art.retention}`;
+            sections.push(line);
+            if (art.dependsOn && art.dependsOn.length > 0) {
+                sections.push(`  - Depends on: ${art.dependsOn.join(", ")}`);
+            }
+        }
+        sections.push("");
+    }
+    // Depth levels
+    if (ast.depth && ast.depth.levels && ast.depth.levels.length > 0) {
+        sections.push("## Depth Levels");
+        sections.push("");
+        if (ast.depth.factors.length > 0) {
+            sections.push(`Factors: ${ast.depth.factors.join(", ")}`);
+        }
+        for (const level of ast.depth.levels) {
+            let line = `- **Level ${level.level}**: ${level.label}`;
+            if (level.omit.length > 0)
+                line += ` (omit: ${level.omit.join(", ")})`;
+            sections.push(line);
+        }
+        sections.push("");
+    }
+    // Composition: params
+    if (ast.params && ast.params.length > 0) {
+        sections.push("## Parameters");
+        sections.push("");
+        for (const p of ast.params) {
+            const req = p.required ? " (required)" : "";
+            const def = p.default != null ? ` = ${p.default}` : "";
+            sections.push(`- **${p.name}**: ${p.type}${req}${def}`);
+        }
+        sections.push("");
+    }
+    // Composition: interface endpoints
+    if (ast.interfaceEndpoints) {
+        sections.push("## Interface");
+        sections.push("");
+        sections.push(`- Entry: ${ast.interfaceEndpoints.entry}`);
+        sections.push(`- Exit: ${ast.interfaceEndpoints.exit}`);
+        sections.push("");
+    }
+    // Composition: imports
+    if (ast.imports && ast.imports.length > 0) {
+        sections.push("## Imports");
+        sections.push("");
+        for (const imp of ast.imports) {
+            let line = `- **${imp.alias}** from \`${imp.source}\``;
+            if (imp.sha256)
+                line += ` (sha256: ${imp.sha256})`;
+            if (imp.registry)
+                line += ` [registry: ${imp.registryPackage}@${imp.registryVersion}]`;
+            sections.push(line);
+            if (Object.keys(imp.params).length > 0) {
+                for (const [k, v] of Object.entries(imp.params)) {
+                    sections.push(`  - ${k}: ${v}`);
+                }
+            }
+        }
+        sections.push("");
+    }
+    // Composition: includes
+    if (ast.includes && ast.includes.length > 0) {
+        sections.push("## Includes");
+        sections.push("");
+        for (const inc of ast.includes) {
+            sections.push(`- ${inc.source}`);
+        }
+        sections.push("");
+    }
+    // Triggers
+    if (ast.triggers.length > 0) {
+        sections.push("## Triggers");
+        sections.push("");
+        for (const trigger of ast.triggers) {
+            sections.push(`### ${trigger.name}`);
+            sections.push(`Pattern: \`${trigger.pattern}\``);
+            if (trigger.argument)
+                sections.push(`Argument: ${trigger.argument}`);
+            sections.push("");
+        }
+    }
+    // Environment variables
+    if (Object.keys(ast.env).length > 0) {
+        sections.push("## Environment");
+        sections.push("");
+        for (const [key, val] of Object.entries(ast.env)) {
+            const value = typeof val === "string" ? val : val.value;
+            sections.push(`- \`${key}\`: ${value}`);
+        }
+        sections.push("");
+    }
+    return {
+        path: "SOUL.md",
+        content: sections.join("\n") + "\n",
+        category: "agent",
+    };
+}
+/** Generate AGENTS.md — sub-agent definitions + flow orchestration logic. */
+function generateAgentsMd(ast) {
+    const agents = getAgentsSorted(ast);
+    const gates = getGates(ast);
+    const sections = [];
+    // Header
+    sections.push("# Sub-Agent Definitions");
+    sections.push("");
+    // Pipeline overview
+    sections.push("## Pipeline Overview");
+    sections.push(`${toTitle(ast.topology.name)} uses a ${ast.topology.patterns.join(" + ")} topology.`);
+    sections.push("");
+    // Agents
+    if (agents.length > 0) {
+        sections.push("## Agents");
+        sections.push("");
+        for (const agent of agents) {
+            sections.push(`### ${toTitle(agent.id)}`);
+            sections.push(`- **Model:** ${mapModel(agent.model ?? "sonnet")}`);
+            if (agent.phase != null) {
+                sections.push(`- **Phase:** ${agent.phase}`);
+            }
+            // Role
+            const roleText = ast.roles[agent.role ?? ""] ?? ast.roles[agent.id] ?? agent.role;
+            if (roleText) {
+                sections.push(`- **Role:** ${roleText}`);
+            }
+            // Tools (allowed/denied — enforced via AGENTS.md since openclaw.json doesn't support per-agent tools)
+            if (agent.tools && agent.tools.length > 0) {
+                sections.push(`- **Tools allowed:** ${agent.tools.join(", ")}`);
+            }
+            if (agent.disallowedTools && agent.disallowedTools.length > 0) {
+                sections.push(`- **Tools denied:** ${agent.disallowedTools.join(", ")}`);
+            }
+            else if (agent.tools && agent.tools.length > 0) {
+                sections.push(`- **Tools denied:** none`);
+            }
+            // Memory access
+            if (agent.reads && agent.reads.length > 0) {
+                sections.push(`- **Reads:** ${agent.reads.join(", ")}`);
+            }
+            if (agent.writes && agent.writes.length > 0) {
+                sections.push(`- **Writes:** ${agent.writes.join(", ")}`);
+            }
+            // Outputs
+            if (agent.outputs) {
+                sections.push("- **Outputs:**");
+                for (const [field, values] of Object.entries(agent.outputs)) {
+                    sections.push(`  - ${field}: ${values.join(" | ")}`);
+                }
+            }
+            // Scale
+            if (agent.scale) {
+                sections.push(`- **Scale:** ${agent.scale.min}-${agent.scale.max} instances by ${agent.scale.by}`);
+            }
+            // Permissions
+            if (agent.permissions) {
+                sections.push(`- **Permissions:** ${agent.permissions}`);
+            }
+            // Max turns
+            if (agent.maxTurns != null) {
+                sections.push(`- **Max turns:** ${agent.maxTurns}`);
+            }
+            // Skills
+            if (agent.skills && agent.skills.length > 0) {
+                sections.push(`- **Skills:** ${agent.skills.join(", ")}`);
+            }
+            // Description
+            if (agent.description) {
+                sections.push("");
+                sections.push(agent.description);
+            }
+            if (agent.prompt) {
+                sections.push("");
+                sections.push("#### Instructions");
+                sections.push("");
+                sections.push(agent.prompt);
+            }
+            // Timeout
+            if (agent.timeout) {
+                sections.push(`- **Maximum execution time:** ${agent.timeout}`);
+            }
+            // On-fail
+            if (agent.onFail) {
+                sections.push(`- **On failure:** ${agent.onFail}`);
+            }
+            // Retry
+            if (agent.retry != null) {
+                sections.push(`- **Retry:** ${formatRetry(agent.retry)}`);
+            }
+            // Thinking
+            if (agent.thinking) {
+                sections.push(`- **Reasoning level:** ${agent.thinking}`);
+            }
+            // Output format
+            if (agent.outputFormat) {
+                sections.push(`- **Output format:** ${agent.outputFormat}`);
+            }
+            // Log level
+            if (agent.logLevel) {
+                sections.push(`- **Log verbosity:** ${agent.logLevel}`);
+            }
+            // Join
+            if (agent.join) {
+                sections.push(`- **Wait for:** ${agent.join}`);
+            }
+            // Circuit breaker
+            if (agent.circuitBreaker) {
+                const cb = agent.circuitBreaker;
+                sections.push(`- **Circuit breaker:** threshold=${cb.threshold}, window=${cb.window}, cooldown=${cb.cooldown}`);
+            }
+            // Compensation
+            if (agent.compensates) {
+                sections.push(`- **Compensates:** ${agent.compensates} (saga rollback)`);
+            }
+            // Input/Output schemas
+            if (agent.inputSchema && agent.inputSchema.length > 0) {
+                sections.push("- **Input schema:**");
+                for (const field of agent.inputSchema) {
+                    sections.push(`  - ${formatSchemaField(field)}`);
+                }
+            }
+            if (agent.outputSchema && agent.outputSchema.length > 0) {
+                sections.push("- **Output schema:**");
+                for (const field of agent.outputSchema) {
+                    sections.push(`  - ${formatSchemaField(field)}`);
+                }
+            }
+            // Rate limit
+            if (agent.rateLimit) {
+                sections.push(`- **Rate limit:** ${agent.rateLimit}`);
+            }
+            // Produces / Consumes artifacts
+            if (agent.produces && agent.produces.length > 0) {
+                sections.push(`- **Produces:** ${agent.produces.join(", ")}`);
+            }
+            if (agent.consumes && agent.consumes.length > 0) {
+                sections.push(`- **Consumes:** ${agent.consumes.join(", ")}`);
+            }
+            // Variants
+            if (agent.variants && agent.variants.length > 0) {
+                sections.push("- **Prompt variants:**");
+                for (const v of agent.variants) {
+                    let vLine = `  - ${v.id} (weight: ${v.weight})`;
+                    if (v.temperature != null)
+                        vLine += `, temp=${v.temperature}`;
+                    if (v.model)
+                        vLine += `, model=${v.model}`;
+                    sections.push(vLine);
+                }
+            }
+            // OpenClaw-specific extensions
+            if (agent.extensions?.openclaw) {
+                sections.push("- **OpenClaw config:**");
+                for (const [k, v] of Object.entries(agent.extensions.openclaw)) {
+                    sections.push(`  - ${k}: ${v}`);
+                }
+            }
+            sections.push("");
+        }
+    }
+    // Human nodes
+    const humanNodes = getHumanNodes(ast);
+    if (humanNodes.length > 0) {
+        sections.push("## Human Pause Points");
+        sections.push("");
+        for (const human of humanNodes) {
+            sections.push(`### ${toTitle(human.id)}`);
+            if (human.description) {
+                sections.push(`- **Action:** ${human.description}`);
+            }
+            if (human.timeout) {
+                sections.push(`- **Timeout:** ${human.timeout}`);
+            }
+            if (human.onTimeout) {
+                sections.push(`- **On timeout:** ${human.onTimeout}`);
+            }
+            sections.push("");
+        }
+    }
+    // Group nodes
+    const groupNodes = getGroupNodes(ast);
+    if (groupNodes.length > 0) {
+        sections.push("## Group Chat Coordination");
+        sections.push("");
+        for (const group of groupNodes) {
+            sections.push(`### ${toTitle(group.id)}`);
+            sections.push(`- **Members:** ${group.members.join(", ")}`);
+            if (group.speakerSelection) {
+                sections.push(`- **Speaker selection:** ${group.speakerSelection}`);
+            }
+            if (group.maxRounds != null) {
+                sections.push(`- **Max rounds:** ${group.maxRounds}`);
+            }
+            if (group.termination) {
+                sections.push(`- **Termination:** ${group.termination}`);
+            }
+            if (group.description) {
+                sections.push(`- **Description:** ${group.description}`);
+            }
+            if (group.timeout) {
+                sections.push(`- **Timeout:** ${group.timeout}`);
+            }
+            sections.push("");
+        }
+    }
+    // Flow
+    if (ast.edges.length > 0) {
+        sections.push("## Flow");
+        sections.push("");
+        // Execution order
+        sections.push("### Execution Order");
+        let idx = 1;
+        for (const edge of ast.edges) {
+            const arrow = edge.isError ? "-x->" : "->";
+            let line = `${idx}. ${edge.from} ${arrow} ${edge.to}`;
+            if (edge.condition)
+                line += ` when ${edge.condition}`;
+            if (edge.maxIterations)
+                line += ` (max ${edge.maxIterations} iterations)`;
+            if (edge.errorType)
+                line += ` [error: ${edge.errorType}]`;
+            if (edge.weight != null)
+                line += ` [weight: ${edge.weight}]`;
+            if (edge.race)
+                line += ` [race]`;
+            if (edge.tolerance != null)
+                line += ` [tolerance: ${edge.tolerance}]`;
+            if (edge.wait)
+                line += ` [wait: ${edge.wait}]`;
+            if (edge.reflection)
+                line += ` [reflection]`;
+            sections.push(line);
+            idx++;
+        }
+        sections.push("");
+        // Conditional routing
+        const conditionalEdges = ast.edges.filter((e) => e.condition);
+        if (conditionalEdges.length > 0) {
+            sections.push("### Conditional Routing");
+            for (const edge of conditionalEdges) {
+                sections.push(`- If ${edge.condition}: route to ${edge.to}`);
+            }
+            sections.push("");
+        }
+        // Fan-out points (nodes with multiple outgoing edges)
+        const fromCounts = {};
+        for (const edge of ast.edges) {
+            if (!fromCounts[edge.from])
+                fromCounts[edge.from] = [];
+            fromCounts[edge.from].push(edge.to);
+        }
+        const fanOutNodes = Object.entries(fromCounts).filter(([, targets]) => targets.length > 1);
+        if (fanOutNodes.length > 0) {
+            sections.push("### Fan-Out Points");
+            for (const [from, targets] of fanOutNodes) {
+                sections.push(`- After ${from}: spawn [${targets.join(", ")}] in parallel`);
+            }
+            sections.push("");
+        }
+        // Bounded loops
+        const boundedEdges = ast.edges.filter((e) => e.maxIterations);
+        if (boundedEdges.length > 0) {
+            sections.push("### Bounded Loops");
+            for (const edge of boundedEdges) {
+                sections.push(`- ${edge.from} <-> ${edge.to}: max ${edge.maxIterations} iterations (prevents infinite loops)`);
+            }
+            sections.push("");
+        }
+        // Error edges
+        const errorEdges = ast.edges.filter((e) => e.isError);
+        if (errorEdges.length > 0) {
+            sections.push("### Error Handling");
+            for (const edge of errorEdges) {
+                let line = `- On error in ${edge.from}: route to ${edge.to}`;
+                if (edge.errorType)
+                    line += ` (type: ${edge.errorType})`;
+                sections.push(line);
+            }
+            sections.push("");
+        }
+        // Weighted routing
+        const weightedEdges = ast.edges.filter((e) => e.weight != null);
+        if (weightedEdges.length > 0) {
+            sections.push("### Weighted Routing");
+            for (const edge of weightedEdges) {
+                sections.push(`- ${edge.from} -> ${edge.to}: weight ${edge.weight}`);
+            }
+            sections.push("");
+        }
+        // Reflection loops
+        const reflectionEdges = ast.edges.filter((e) => e.reflection);
+        if (reflectionEdges.length > 0) {
+            sections.push("### Reflection Loops");
+            for (const edge of reflectionEdges) {
+                sections.push(`- ${edge.from} -> ${edge.to}: evaluator/reflection loop`);
+            }
+            sections.push("");
+        }
+        // Race conditions
+        const raceEdges = ast.edges.filter((e) => e.race);
+        if (raceEdges.length > 0) {
+            sections.push("### Race (First-Wins)");
+            for (const edge of raceEdges) {
+                let line = `- ${edge.from} -> ${edge.to}: race mode`;
+                if (edge.tolerance != null)
+                    line += `, tolerance: ${edge.tolerance}`;
+                sections.push(line);
+            }
+            sections.push("");
+        }
+    }
+    // Gates
+    if (gates.length > 0) {
+        sections.push("## Gates");
+        sections.push("");
+        for (const gate of gates) {
+            sections.push(`### ${toTitle(gate.id)}`);
+            if (gate.after)
+                sections.push(`- **After:** ${gate.after}`);
+            if (gate.before)
+                sections.push(`- **Before:** ${gate.before}`);
+            if (gate.run)
+                sections.push(`- **Script:** ${gate.run}`);
+            if (gate.onFail)
+                sections.push(`- **On failure:** ${gate.onFail}`);
+            sections.push(`- **Behavior:** ${gate.behavior ?? "blocking"}`);
+            if (gate.checks && gate.checks.length > 0) {
+                sections.push(`- **Checks:** ${gate.checks.join(", ")}`);
+            }
+            sections.push(`- **Enforcement:** tools.deny is enforced in openclaw.json; gate scripts are advisory — run manually between agents`);
+            sections.push("");
+        }
+    }
+    // Schedule
+    if (ast.schedules.length > 0) {
+        sections.push("## Schedule");
+        sections.push("");
+        for (const job of ast.schedules) {
+            sections.push(`### ${toTitle(job.id)}`);
+            sections.push(`- **Agent:** ${job.agent}`);
+            if (job.cron)
+                sections.push(`- **Cron:** \`${job.cron}\``);
+            if (job.enabled != null)
+                sections.push(`- **Enabled:** ${job.enabled}`);
+            sections.push("");
+        }
+    }
+    // Hooks
+    if (ast.hooks.length > 0) {
+        sections.push("## Hooks");
+        sections.push("");
+        for (const hook of ast.hooks) {
+            sections.push(`### ${toTitle(hook.name)}`);
+            if (hook.on)
+                sections.push(`- **Event:** ${hook.on}`);
+            if (hook.run)
+                sections.push(`- **Run:** ${hook.run}`);
+            if (hook.type)
+                sections.push(`- **Type:** ${hook.type}`);
+            sections.push("");
+        }
+    }
+    // Topology overview (merged from TEAM.md)
+    sections.push("---");
+    sections.push("");
+    sections.push(`## ${toTitle(ast.topology.name)} -- Topology Overview`);
+    sections.push("");
+    sections.push("### Architecture");
+    sections.push(`- Patterns: ${ast.topology.patterns.join(", ")}`);
+    sections.push(`- Agents: ${agents.length}`);
+    sections.push(`- Gates: ${gates.length}`);
+    sections.push(`- Version: ${ast.topology.version}`);
+    sections.push("");
+    // Flow diagram
+    if (ast.edges.length > 0) {
+        sections.push("### Flow Diagram");
+        sections.push("");
+        sections.push("```mermaid");
+        sections.push("graph TD");
+        for (const edge of ast.edges) {
+            const labelParts = [];
+            if (edge.condition)
+                labelParts.push(edge.condition);
+            if (edge.maxIterations)
+                labelParts.push(`max ${edge.maxIterations}`);
+            if (edge.isError)
+                labelParts.push("error");
+            if (edge.errorType)
+                labelParts.push(`type: ${edge.errorType}`);
+            if (edge.weight != null)
+                labelParts.push(`weight: ${edge.weight}`);
+            if (edge.race)
+                labelParts.push("race");
+            if (edge.tolerance != null)
+                labelParts.push(`tolerance: ${edge.tolerance}`);
+            if (edge.wait)
+                labelParts.push(`wait: ${edge.wait}`);
+            if (edge.reflection)
+                labelParts.push("reflection");
+            const label = labelParts.join(", ");
+            if (label) {
+                if (edge.isError) {
+                    sections.push(`  ${edge.from} -.->|${label}| ${edge.to}`);
+                }
+                else {
+                    sections.push(`  ${edge.from} -->|${label}| ${edge.to}`);
+                }
+            }
+            else {
+                sections.push(`  ${edge.from} --> ${edge.to}`);
+            }
+        }
+        sections.push("```");
+        sections.push("");
+    }
+    // Roles table
+    if (Object.keys(ast.roles).length > 0) {
+        sections.push("### Roles");
+        sections.push("| Role | Description |");
+        sections.push("|------|-------------|");
+        for (const [role, desc] of Object.entries(ast.roles)) {
+            sections.push(`| ${role} | ${desc} |`);
+        }
+        sections.push("");
+    }
+    // Metering
+    if (ast.metering) {
+        sections.push("### Metering");
+        sections.push(`- Track: ${ast.metering.track.join(", ")}`);
+        sections.push(`- Per: ${ast.metering.per.join(", ")}`);
+        sections.push(`- Output: ${ast.metering.output} (${ast.metering.format})`);
+        sections.push(`- Pricing: ${ast.metering.pricing}`);
+        sections.push("");
+    }
+    return {
+        path: "AGENTS.md",
+        content: sections.join("\n") + "\n",
+        category: "agent",
+    };
+}
+/** Generate TOOLS.md — available tools + skill references. */
+function generateToolsMd(ast) {
+    const agents = getAgentsSorted(ast);
+    const sections = [];
+    sections.push("# Available Tools");
+    sections.push("");
+    // Core tools — unique tools across all agents + settings.allow
+    const allTools = new Set();
+    const settingsAllow = ast.settings?.allow;
+    if (Array.isArray(settingsAllow)) {
+        for (const t of settingsAllow)
+            allTools.add(String(t));
+    }
+    for (const agent of agents) {
+        if (agent.tools) {
+            for (const t of agent.tools)
+                allTools.add(t);
+        }
+    }
+    if (allTools.size > 0) {
+        sections.push("## Core Tools");
+        sections.push("");
+        for (const tool of allTools) {
+            sections.push(`- ${tool}`);
+        }
+        sections.push("");
+    }
+    // Custom tools from toolDefs
+    if (ast.toolDefs.length > 0) {
+        sections.push("## Custom Tools");
+        sections.push("");
+        for (const tool of ast.toolDefs) {
+            sections.push(`### ${tool.id}`);
+            sections.push(tool.description);
+            sections.push(`- Script: ${tool.script}`);
+            if (tool.args && tool.args.length > 0) {
+                sections.push(`- Args: ${tool.args.join(", ")}`);
+            }
+            if (tool.lang) {
+                sections.push(`- Language: ${tool.lang}`);
+            }
+            sections.push("");
+        }
+    }
+    // Skills
+    if (ast.skills.length > 0) {
+        sections.push("## Skills");
+        sections.push("");
+        for (const skill of ast.skills) {
+            sections.push(`### ${skill.id}`);
+            if (skill.description) {
+                sections.push(skill.description);
+            }
+            sections.push("");
+        }
+    }
+    return {
+        path: "TOOLS.md",
+        content: sections.join("\n") + "\n",
+        category: "machine",
+    };
+}
+/** Generate MEMORY.md — long-term memory structure. */
+function generateMemoryMd(ast) {
+    const agents = getAgentsSorted(ast);
+    const memory = ast.memory;
+    const sections = [];
+    sections.push("# Memory Structure");
+    sections.push("");
+    // Domains
+    const domains = memory.domains;
+    if (domains) {
+        sections.push("## Domains");
+        if (domains.path)
+            sections.push(`Path: ${domains.path}`);
+        if (domains.routing)
+            sections.push(`Routing: ${domains.routing}`);
+        sections.push("");
+    }
+    // Workspace
+    const workspace = memory.workspace;
+    if (workspace) {
+        sections.push("## Workspace");
+        if (workspace.path)
+            sections.push(`Path: ${workspace.path}`);
+        if (workspace.structure && Array.isArray(workspace.structure)) {
+            sections.push(`Structure: ${workspace.structure.join(", ")}`);
+        }
+        sections.push("");
+    }
+    // Metrics
+    const metrics = memory.metrics;
+    if (metrics) {
+        sections.push("## Metrics");
+        if (metrics.path)
+            sections.push(`Path: ${metrics.path}`);
+        if (metrics.mode)
+            sections.push(`Mode: ${metrics.mode}`);
+        sections.push("");
+    }
+    // Agent access rules
+    const agentsWithAccess = agents.filter((a) => (a.reads && a.reads.length > 0) || (a.writes && a.writes.length > 0));
+    if (agentsWithAccess.length > 0) {
+        sections.push("## Agent Access Rules");
+        sections.push("");
+        for (const agent of agentsWithAccess) {
+            sections.push(`### ${agent.id}`);
+            if (agent.reads && agent.reads.length > 0) {
+                sections.push(`- Reads: ${agent.reads.join(", ")}`);
+            }
+            if (agent.writes && agent.writes.length > 0) {
+                sections.push(`- Writes: ${agent.writes.join(", ")}`);
+            }
+            sections.push("");
+        }
+    }
+    return {
+        path: "MEMORY.md",
+        content: sections.join("\n") + "\n",
+        category: "machine",
+    };
+}
+/** Generate BOOTSTRAP.md — init instructions from hooks + gates. */
+function generateBootstrapMd(ast) {
+    const agents = getAgentsSorted(ast);
+    const gates = getGates(ast);
+    const sections = [];
+    sections.push("# Bootstrap Sequence");
+    sections.push("");
+    // Initialization hooks
+    const initHooks = ast.hooks.filter((h) => h.on === "SessionStart" || h.on === "InstructionsLoaded");
+    if (initHooks.length > 0) {
+        sections.push("## Initialization");
+        let idx = 1;
+        for (const hook of initHooks) {
+            sections.push(`${idx}. Run: ${hook.run}`);
+            idx++;
+        }
+        sections.push("");
+    }
+    // Pre-flight gates (gates before the first flow node)
+    const firstEdge = ast.edges.length > 0 ? ast.edges[0] : null;
+    const preFlightGates = gates.filter((g) => firstEdge && g.before === firstEdge.from);
+    if (preFlightGates.length > 0) {
+        sections.push("## Pre-Flight Gates");
+        sections.push("");
+        sections.push("> **Enforcement note:** Gate scripts are advisory — they must be run manually");
+        sections.push("> between agents. Tool deny lists (`tools.deny` in openclaw.json) ARE enforced");
+        sections.push("> by the runtime. Gate scripts provide quality checks but not hard enforcement.");
+        sections.push("");
+        let idx = 1;
+        for (const gate of preFlightGates) {
+            sections.push(`${idx}. Gate: ${gate.id} -- ${gate.run ?? "manual check"}`);
+            sections.push(`   On failure: ${gate.onFail ?? "halt"}`);
+            idx++;
+        }
+        sections.push("");
+    }
+    // Agent initialization order
+    if (agents.length > 0) {
+        sections.push("## Agent Initialization Order");
+        sections.push("");
+        for (const agent of agents) {
+            const phase = agent.phase != null ? agent.phase : 0;
+            sections.push(`Phase ${phase}: ${agent.id} (${mapModel(agent.model ?? "sonnet")})`);
+        }
+        sections.push("");
+    }
+    return {
+        path: "BOOTSTRAP.md",
+        content: sections.join("\n") + "\n",
+        category: "machine",
+    };
+}
+/** Generate USER.md — user profile for agent personalization. */
+function generateUserMd() {
+    const sections = [];
+    sections.push("# User Profile");
+    sections.push("");
+    sections.push("Describe who you are so the agent can personalize responses.");
+    sections.push("");
+    sections.push("<!-- Edit this file with your preferences, name, communication style, etc. -->");
+    sections.push("");
+    return {
+        path: "USER.md",
+        content: sections.join("\n"),
+        category: "agent",
+    };
+}
+/** Generate IDENTITY.md — agent identity from topology meta. */
+function generateIdentityMd(ast) {
+    const sections = [];
+    sections.push("# Identity");
+    sections.push("");
+    sections.push(`- **Name:** ${toTitle(ast.topology.name)}`);
+    sections.push(`- **Emoji:** \uD83E\uDD9E`);
+    const vibe = ast.topology.description ?? "Coordinate agent topology.";
+    sections.push(`- **Vibe:** ${vibe}`);
+    sections.push("");
+    return {
+        path: "IDENTITY.md",
+        content: sections.join("\n"),
+        category: "agent",
+    };
+}
+/** Generate workspace-protocol.md — access rules from agent reads/writes. */
+function generateWorkspaceProtocol(ast) {
+    const agents = getAgentsSorted(ast);
+    const agentsWithAccess = agents.filter((a) => (a.reads && a.reads.length > 0) || (a.writes && a.writes.length > 0));
+    if (agentsWithAccess.length === 0)
+        return null;
+    const sections = [];
+    sections.push("# Workspace Protocol");
+    sections.push("");
+    // Directory structure from workspace
+    const workspace = ast.memory.workspace;
+    if (workspace?.structure && Array.isArray(workspace.structure)) {
+        sections.push("## Directory Structure");
+        for (const item of workspace.structure) {
+            sections.push(`- ${item}/`);
+        }
+        sections.push("");
+    }
+    // Read/Write rules
+    sections.push("## Access Rules");
+    sections.push("");
+    for (const agent of agentsWithAccess) {
+        sections.push(`### ${toTitle(agent.id)}`);
+        if (agent.reads && agent.reads.length > 0) {
+            sections.push(`- **Reads:** ${agent.reads.join(", ")}`);
+        }
+        if (agent.writes && agent.writes.length > 0) {
+            sections.push(`- **Writes:** ${agent.writes.join(", ")}`);
+        }
+        sections.push("");
+    }
+    return {
+        path: "workspace-protocol.md",
+        content: sections.join("\n") + "\n",
+        category: "machine",
+    };
+}
+/** Generate skill files from ast.skills. */
+function generateSkillFiles(ast) {
+    const files = [];
+    for (const skill of ast.skills) {
+        const sections = [];
+        // OpenClaw requires YAML frontmatter with name and description
+        sections.push("---");
+        sections.push(`name: ${skill.id}`);
+        if (skill.description) {
+            sections.push(`description: ${JSON.stringify(skill.description)}`);
+        }
+        if (skill.userInvocable != null) {
+            sections.push(`user-invocable: ${skill.userInvocable}`);
+        }
+        sections.push("---");
+        sections.push("");
+        sections.push(`# ${toTitle(skill.id)} Skill`);
+        sections.push("");
+        if (skill.description) {
+            sections.push(skill.description);
+            sections.push("");
+        }
+        if (skill.scripts && skill.scripts.length > 0) {
+            sections.push("## Scripts");
+            for (const s of skill.scripts) {
+                sections.push(`- ${s}`);
+            }
+            sections.push("");
+        }
+        if (skill.domains && skill.domains.length > 0) {
+            sections.push("## Domains");
+            for (const d of skill.domains) {
+                sections.push(`- ${d}`);
+            }
+            sections.push("");
+        }
+        if (skill.references && skill.references.length > 0) {
+            sections.push("## References");
+            for (const r of skill.references) {
+                sections.push(`- ${r}`);
+            }
+            sections.push("");
+        }
+        files.push({
+            path: `skills/${skill.id}/SKILL.md`,
+            content: sections.join("\n") + "\n",
+            category: "agent",
+        });
+    }
+    return files;
+}
+/** Generate tool-as-skill wrappers from ast.toolDefs. */
+function generateToolSkills(ast) {
+    const files = [];
+    for (const tool of ast.toolDefs) {
+        // SKILL.md wrapper — OpenClaw requires YAML frontmatter
+        const sections = [];
+        sections.push("---");
+        sections.push(`name: ${tool.id}`);
+        sections.push(`description: ${JSON.stringify(tool.description)}`);
+        sections.push("---");
+        sections.push("");
+        sections.push(`# ${toTitle(tool.id)} Tool`);
+        sections.push("");
+        sections.push(tool.description);
+        sections.push("");
+        sections.push(`- Script: \`${tool.script}\``);
+        if (tool.args && tool.args.length > 0) {
+            sections.push(`- Args: ${tool.args.join(", ")}`);
+        }
+        if (tool.lang) {
+            sections.push(`- Language: ${tool.lang}`);
+        }
+        sections.push("");
+        files.push({
+            path: `skills/${tool.id}/SKILL.md`,
+            content: sections.join("\n") + "\n",
+            category: "agent",
+        });
+        // index.ts stub
+        const ext = tool.lang === "python" ? "py" : tool.lang === "node" ? "js" : "ts";
+        const stubLines = [
+            "// Auto-generated tool stub — edit as needed.",
+            `// Tool: ${tool.id}`,
+            `// ${tool.description}`,
+            "",
+        ];
+        if (tool.args && tool.args.length > 0) {
+            stubLines.push(`// Args: ${tool.args.join(", ")}`);
+            stubLines.push("");
+        }
+        stubLines.push('console.log("TODO: implement tool");');
+        stubLines.push("");
+        files.push({
+            path: `skills/${tool.id}/index.${ext}`,
+            content: stubLines.join("\n"),
+            category: "script",
+        });
+    }
+    return files;
+}
+/** Generate gate script stubs. */
+function generateGateScripts(ast) {
+    const files = [];
+    const gates = getGates(ast);
+    for (const gate of gates) {
+        if (gate.run) {
+            const scriptName = gate.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+            files.push({
+                path: `scripts/${scriptName}`,
+                content: shellStub(`Gate: ${gate.id} -- ${gate.run}`),
+                category: "script",
+            });
+        }
+    }
+    return files;
+}
+/** Generate hook script stubs. */
+function generateHookScripts(ast) {
+    const files = [];
+    for (const hook of ast.hooks) {
+        if (!hook.run)
+            continue;
+        const scriptName = hook.run.replace(/^.*\//, "").replace(/\s.*$/, "");
+        files.push({
+            path: `scripts/${scriptName}`,
+            content: [
+                "#!/usr/bin/env bash",
+                `# Hook: ${hook.name} -- fires on ${hook.on}`,
+                "# Auto-generated by agentopology scaffold — edit as needed.",
+                "set -euo pipefail",
+                "",
+                `echo "TODO: implement ${hook.name} hook"`,
+                "",
+            ].join("\n"),
+            category: "script",
+        });
+    }
+    return files;
+}
+/** Generate memory directories (workspace structure + domains). */
+function generateMemoryDirs(ast) {
+    const files = [];
+    // Workspace dirs
+    const workspace = ast.memory.workspace;
+    if (workspace) {
+        files.push(gitkeep("workspace"));
+        if (workspace.structure && Array.isArray(workspace.structure)) {
+            for (const dir of workspace.structure) {
+                files.push(gitkeep(`workspace/${dir}`));
+            }
+        }
+    }
+    // Domains dir
+    files.push(gitkeep("domains"));
+    return files;
+}
+/** Generate metering script + metrics file. */
+function generateMetering(ast) {
+    if (!ast.metering)
+        return [];
+    const m = ast.metering;
+    const files = [];
+    // collect-metrics.sh
+    const lines = [
+        "#!/usr/bin/env bash",
+        "# Metering / cost tracking script",
+        "# Auto-generated by agentopology scaffold — edit as needed.",
+        "set -euo pipefail",
+        "",
+        `# Track: ${m.track.join(", ")}`,
+        `# Per: ${m.per.join(", ")}`,
+        `# Output: ${m.output} (${m.format})`,
+        `# Pricing: ${m.pricing}`,
+        "",
+        'echo "TODO: implement metrics collection"',
+        "",
+    ];
+    files.push({
+        path: "scripts/collect-metrics.sh",
+        content: lines.join("\n"),
+        category: "script",
+    });
+    // Empty metrics file
+    files.push({
+        path: "metrics.jsonl",
+        content: "",
+        category: "machine",
+    });
+    return files;
+}
+// ---------------------------------------------------------------------------
+// Binding export
+// ---------------------------------------------------------------------------
+/** OpenClaw binding — multi-channel AI agent framework. */
+export const openClawBinding = {
+    name: "openclaw",
+    description: "OpenClaw workspace -- multi-channel AI agent framework with gateway, channels, and markdown-based agent identity",
+    scaffold(ast) {
+        const files = [];
+        // 1. Core workspace files
+        files.push(generateOpenClawJson(ast));
+        files.push(generateSoulMd(ast));
+        files.push(generateAgentsMd(ast));
+        files.push(generateToolsMd(ast));
+        files.push(generateMemoryMd(ast));
+        files.push(generateBootstrapMd(ast));
+        files.push(generateUserMd());
+        files.push(generateIdentityMd(ast));
+        // 1b. Cron jobs file (separate from openclaw.json)
+        const cronJobs = generateCronJobsJson(ast);
+        if (cronJobs)
+            files.push(cronJobs);
+        // 2. Skills (from ast.skills + ast.toolDefs)
+        files.push(...generateSkillFiles(ast));
+        files.push(...generateToolSkills(ast));
+        // 3. Scripts (gates + hooks + metering)
+        files.push(...generateGateScripts(ast));
+        files.push(...generateHookScripts(ast));
+        files.push(...generateMetering(ast));
+        // 4. Memory directories
+        files.push(...generateMemoryDirs(ast));
+        // 5. Memory and skills directory markers
+        files.push(gitkeep("memory"));
+        files.push(gitkeep("skills"));
+        // 6. Workspace protocol
+        const protocol = generateWorkspaceProtocol(ast);
+        if (protocol)
+            files.push(protocol);
+        return deduplicateFiles(files);
+    },
+};
+//# sourceMappingURL=openclaw.js.map