agentopology 0.9.1 → 0.10.0

package/dist/bindings/openclaw.js

@@ -1,1947 +0,0 @@
-/**
- * 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";
-import { shellStub } from "./lib/stub.js";
-import { byPhase } from "../resolve/phase.js";
-import { gateAnchors } from "../parser/ast.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 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 resolves the provider from the FIRST segment of the model ID
- * (everything before the first "/"). For proxy providers like OpenRouter,
- * the model ID must include both the proxy provider AND the upstream
- * model path: `openrouter/google/gemini-2.5-flash`.
- *
- * When the .at file specifies a model like `google/gemini-2.5-flash`
- * under an `openrouter` provider, the binding prepends the provider
- * name to produce the correct 3-segment ID.
- */
-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`,
-    };
-    // Alias lookup (short names like "opus", "sonnet", "haiku")
-    if (MODEL_MAP[model])
-        return MODEL_MAP[model];
-    // If model already starts with the provider prefix, return as-is
-    if (model.startsWith(`${provider}/`))
-        return model;
-    // If model has a slash (e.g. "google/gemini-2.5-flash") but doesn't
-    // start with the provider, prepend the provider so OpenClaw routes
-    // through the correct provider (e.g. "openrouter/google/gemini-2.5-flash")
-    if (model.includes("/"))
-        return `${provider}/${model}`;
-    // Bare model name — prepend provider
-    return `${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(byPhase);
-}
-/** 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: `~/.openclaw/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: `~/.openclaw/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;
-        // Note: OpenClaw does NOT support per-agent "timeout" in openclaw.json.
-        // Timeouts are documented in AGENTS.md instead.
-        // subagents.allowAgents — OpenClaw requires explicit delegation lists
-        // for agents to use sessions_spawn. We detect supervisors using:
-        // 1. The topology's interface entry point (if defined)
-        // 2. The first agent by phase order
-        // 3. Any agent that is the target of error edges (error handlers coordinate)
-        // Supervisors get allowAgents for ALL other agents in the topology,
-        // because OpenClaw delegation is about permission, not flow direction.
-        const isSupervisor = 
-        // Interface entry point
-        (ast.interfaceEndpoints?.entry === agent.id) ||
-            // First agent by phase (lowest phase = coordinator)
-            (agents.length > 0 && agents[0].id === agent.id) ||
-            // Error handler target (receives error edges from other agents)
-            ast.edges.some((e) => e.isError && e.to === agent.id) ||
-            // Topology declares "supervisor" pattern and this is the first agent
-            (ast.topology.patterns.includes("supervisor") && agents[0]?.id === agent.id);
-        if (isSupervisor) {
-            const otherAgentIds = agents
-                .filter((a) => a.id !== agent.id)
-                .map((a) => a.id);
-            if (otherAgentIds.length > 0) {
-                entry.subagents = { allowAgents: otherAgentIds };
-            }
-        }
-        // 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(", ")}`);
-            }
-            // Memory stores — rich details per store
-            if (agent.memory && agent.memory.length > 0) {
-                const storeMap = new Map((ast.stores ?? []).map(s => [s.id, s]));
-                sections.push("- **Memory stores:**");
-                for (const storeId of agent.memory) {
-                    const store = storeMap.get(storeId);
-                    if (!store) {
-                        sections.push(`  - ${storeId}`);
-                        continue;
-                    }
-                    const parts = [`**${storeId}**`, `type: ${store.type}`, `backend: ${store.backend}`];
-                    if (store.path)
-                        parts.push(`path: \`${store.path}\``);
-                    if (store.scope)
-                        parts.push(`scope: ${store.scope}`);
-                    if (store.embedding?.model)
-                        parts.push(`embedding: ${store.embedding.model} (${store.embedding.dimensions}d)`);
-                    if (store.search?.strategy)
-                        parts.push(`search: ${store.search.strategy}`);
-                    sections.push(`  - ${parts.join(" — ")}`);
-                }
-            }
-            // Retrieval strategy — rich details
-            if (agent.retrieval) {
-                const retrieval = (ast.retrievals ?? []).find(r => r.id === agent.retrieval);
-                if (retrieval) {
-                    const parts = [`**${retrieval.id}**`];
-                    if (retrieval.sources)
-                        parts.push(`sources: ${retrieval.sources.join(", ")}`);
-                    if (retrieval.budget)
-                        parts.push(`budget: ${retrieval.budget} tokens`);
-                    if (retrieval.rerank)
-                        parts.push(`reranked`);
-                    if (retrieval.scoring) {
-                        const weights = [];
-                        if (retrieval.scoring.semanticWeight != null)
-                            weights.push(`semantic: ${retrieval.scoring.semanticWeight}`);
-                        if (retrieval.scoring.recencyWeight != null)
-                            weights.push(`recency: ${retrieval.scoring.recencyWeight}`);
-                        if (retrieval.scoring.importanceWeight != null)
-                            weights.push(`importance: ${retrieval.scoring.importanceWeight}`);
-                        if (weights.length)
-                            parts.push(`scoring: ${weights.join(", ")}`);
-                    }
-                    sections.push(`- **Retrieval strategy:** ${parts.join(" — ")}`);
-                }
-                else {
-                    sections.push(`- **Retrieval strategy:** ${agent.retrieval}`);
-                }
-            }
-            // 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:** ${gateAnchors(gate, "after").join(", ")}`);
-            if (gate.before)
-                sections.push(`- **Before:** ${gateAnchors(gate, "before").join(", ")}`);
-            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("");
-    }
-    // Memory Stores — full details
-    const stores = ast.stores ?? [];
-    if (stores.length > 0) {
-        sections.push("## Memory Stores");
-        sections.push("");
-        for (const store of stores) {
-            sections.push(`### ${store.id}`);
-            if (store.description)
-                sections.push(store.description);
-            sections.push("");
-            sections.push(`- **Type**: ${store.type}`);
-            sections.push(`- **Backend**: ${store.backend}`);
-            if (store.path)
-                sections.push(`- **Path**: \`${store.path}\``);
-            if (store.connection)
-                sections.push(`- **Connection**: ${store.connection}`);
-            if (store.scope)
-                sections.push(`- **Scope**: ${store.scope}`);
-            if (store.isolation)
-                sections.push(`- **Isolation**: ${store.isolation}`);
-            if (store.extraction)
-                sections.push(`- **Extraction**: ${store.extraction}`);
-            // Embedding
-            if (store.embedding) {
-                const emb = store.embedding;
-                sections.push(`- **Embedding**: ${emb.model} (${emb.provider}, ${emb.dimensions}d)`);
-            }
-            // Index
-            if (store.index) {
-                const parts = [];
-                if (store.index.collection)
-                    parts.push(`collection: ${store.index.collection}`);
-                if (store.index.metric)
-                    parts.push(`metric: ${store.index.metric}`);
-                if (parts.length)
-                    sections.push(`- **Index**: ${parts.join(", ")}`);
-            }
-            // Search
-            if (store.search) {
-                const parts = [`strategy: ${store.search.strategy}`];
-                if (store.search.topK)
-                    parts.push(`top-k: ${store.search.topK}`);
-                if (store.search.rerank)
-                    parts.push(`rerank: yes`);
-                sections.push(`- **Search**: ${parts.join(", ")}`);
-            }
-            // Ingestion
-            if (store.ingestion) {
-                const parts = [];
-                if (store.ingestion.sources)
-                    parts.push(`sources: ${store.ingestion.sources.join(", ")}`);
-                if (store.ingestion.chunking)
-                    parts.push(`chunking: ${store.ingestion.chunking}`);
-                if (store.ingestion.chunkSize)
-                    parts.push(`size: ${store.ingestion.chunkSize}`);
-                if (store.ingestion.overlap)
-                    parts.push(`overlap: ${store.ingestion.overlap}`);
-                if (parts.length)
-                    sections.push(`- **Ingestion**: ${parts.join(", ")}`);
-            }
-            // Lifecycle
-            if (store.lifecycle) {
-                const lc = store.lifecycle;
-                if (lc.retention)
-                    sections.push(`- **Retention**: ${lc.retention}`);
-                if (lc.decayHalfLife)
-                    sections.push(`- **Decay half-life**: ${lc.decayHalfLife}`);
-                if (lc.consolidation != null)
-                    sections.push(`- **Consolidation threshold**: ${lc.consolidation}`);
-                if (lc.contradiction)
-                    sections.push(`- **Contradiction handling**: ${lc.contradiction}`);
-                if (lc.auditLog != null)
-                    sections.push(`- **Audit log**: ${lc.auditLog}`);
-            }
-            // Which agents use this store
-            const storeAgents = agents.filter(a => a.memory?.includes(store.id));
-            if (storeAgents.length > 0) {
-                sections.push(`- **Used by**: ${storeAgents.map(a => a.id).join(", ")}`);
-            }
-            sections.push("");
-        }
-    }
-    // Retrieval Strategies
-    const retrievals = ast.retrievals ?? [];
-    if (retrievals.length > 0) {
-        sections.push("## Retrieval Strategies");
-        sections.push("");
-        for (const ret of retrievals) {
-            sections.push(`### ${ret.id}`);
-            if (ret.sources)
-                sections.push(`- **Sources**: ${ret.sources.join(", ")}`);
-            if (ret.budget)
-                sections.push(`- **Token budget**: ${ret.budget}`);
-            if (ret.paths)
-                sections.push(`- **Search paths**: ${ret.paths.join(", ")}`);
-            if (ret.rerank)
-                sections.push(`- **Reranking**: enabled`);
-            if (ret.diversity)
-                sections.push(`- **Diversity**: enabled`);
-            if (ret.cacheHitThreshold != null) {
-                sections.push(`- **Cache hit**: threshold ${ret.cacheHitThreshold} → ${ret.cacheHitAction ?? "short-circuit"}`);
-            }
-            if (ret.scoring) {
-                const weights = [];
-                if (ret.scoring.recencyWeight != null)
-                    weights.push(`recency: ${ret.scoring.recencyWeight}`);
-                if (ret.scoring.semanticWeight != null)
-                    weights.push(`semantic: ${ret.scoring.semanticWeight}`);
-                if (ret.scoring.importanceWeight != null)
-                    weights.push(`importance: ${ret.scoring.importanceWeight}`);
-                if (weights.length)
-                    sections.push(`- **Scoring**: ${weights.join(", ")}`);
-            }
-            // Which agents use this retrieval
-            const retAgents = agents.filter(a => a.retrieval === ret.id);
-            if (retAgents.length > 0) {
-                sections.push(`- **Used by**: ${retAgents.map(a => a.id).join(", ")}`);
-            }
-            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 && gateAnchors(g, "before").includes(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, version, AND description.
-        // Missing any of the three = skill silently not registered.
-        sections.push("---");
-        sections.push(`name: ${skill.id}`);
-        sections.push(`version: "${ast.topology.version}"`);
-        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 name, version, AND description.
-        const sections = [];
-        sections.push("---");
-        sections.push(`name: ${tool.id}`);
-        sections.push(`version: "${ast.topology.version}"`);
-        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"));
-    // Store directory markers
-    const stores = ast.stores ?? [];
-    for (const store of stores) {
-        files.push(gitkeep(`stores/${store.id}`));
-    }
-    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;
-}
-/**
- * Generate per-agent identity directories.
- *
- * OpenClaw reads agent identity from `config/agents/<id>/agent/`.
- * Each agent gets its own IDENTITY.md, MEMORY.md (scoped to its stores),
- * and SOUL.md with role-specific instructions.
- */
-function generatePerAgentDirs(ast) {
-    const files = [];
-    const agents = getAgentsSorted(ast);
-    const orchestrator = getOrchestrator(ast);
-    const storeMap = new Map((ast.stores ?? []).map(s => [s.id, s]));
-    const defaultProvider = getDefaultProviderName(ast);
-    // Helper: build per-agent MEMORY.md with only stores this agent uses
-    function agentMemoryMd(agentId, storeIds, retrievalId) {
-        const lines = ["# Memory Stores", ""];
-        lines.push("You have access to the following memory stores. Use them to persist and retrieve knowledge.");
-        lines.push("");
-        for (const sid of storeIds) {
-            const store = storeMap.get(sid);
-            if (!store)
-                continue;
-            lines.push(`## ${store.id}`);
-            if (store.description)
-                lines.push(store.description);
-            lines.push("");
-            lines.push(`- **Type**: ${store.type}`);
-            lines.push(`- **Backend**: ${store.backend}`);
-            if (store.path)
-                lines.push(`- **Path**: \`${store.path}\``);
-            if (store.scope)
-                lines.push(`- **Scope**: ${store.scope}`);
-            if (store.embedding) {
-                lines.push(`- **Embedding**: ${store.embedding.model} (${store.embedding.provider}, ${store.embedding.dimensions}d)`);
-            }
-            if (store.search) {
-                const parts = [`strategy: ${store.search.strategy}`];
-                if (store.search.topK)
-                    parts.push(`top-k: ${store.search.topK}`);
-                if (store.search.rerank)
-                    parts.push(`rerank: yes`);
-                lines.push(`- **Search**: ${parts.join(", ")}`);
-            }
-            if (store.ingestion?.sources) {
-                lines.push(`- **Ingestion sources**: ${store.ingestion.sources.join(", ")}`);
-            }
-            if (store.lifecycle?.retention)
-                lines.push(`- **Retention**: ${store.lifecycle.retention}`);
-            lines.push("");
-        }
-        // Retrieval strategy
-        if (retrievalId) {
-            const retrieval = (ast.retrievals ?? []).find(r => r.id === retrievalId);
-            if (retrieval) {
-                lines.push("## Retrieval Strategy");
-                lines.push("");
-                lines.push(`**${retrieval.id}** — When you need to recall information:`);
-                lines.push("");
-                if (retrieval.sources)
-                    lines.push(`- **Sources**: ${retrieval.sources.join(", ")}`);
-                if (retrieval.budget)
-                    lines.push(`- **Token budget**: ${retrieval.budget}`);
-                if (retrieval.paths)
-                    lines.push(`- **Search paths**: ${retrieval.paths.join(", ")}`);
-                if (retrieval.rerank)
-                    lines.push(`- **Reranking**: enabled`);
-                if (retrieval.scoring) {
-                    const w = [];
-                    if (retrieval.scoring.semanticWeight != null)
-                        w.push(`semantic: ${retrieval.scoring.semanticWeight}`);
-                    if (retrieval.scoring.recencyWeight != null)
-                        w.push(`recency: ${retrieval.scoring.recencyWeight}`);
-                    if (retrieval.scoring.importanceWeight != null)
-                        w.push(`importance: ${retrieval.scoring.importanceWeight}`);
-                    if (w.length)
-                        lines.push(`- **Scoring**: ${w.join(", ")}`);
-                }
-                lines.push("");
-            }
-        }
-        return lines.join("\n");
-    }
-    // Generate per-agent dirs
-    const allAgents = orchestrator
-        ? [{ id: "orchestrator", description: `${toTitle(ast.topology.name)} orchestrator`, model: orchestrator.model, memory: undefined, retrieval: undefined, prompt: undefined }]
-        : [];
-    for (const a of agents) {
-        allAgents.push({ id: a.id, description: a.description ?? "", model: a.model ?? "sonnet", memory: a.memory, retrieval: a.retrieval, prompt: a.prompt });
-    }
-    for (const agent of allAgents) {
-        const base = `config/agents/${agent.id}/agent`;
-        // IDENTITY.md
-        files.push({
-            path: `${base}/IDENTITY.md`,
-            content: [
-                `# ${toTitle(agent.id)}`,
-                "",
-                agent.description || `Agent in the ${ast.topology.name} topology.`,
-                "",
-                `Model: ${mapModel(agent.model, defaultProvider)}`,
-                "",
-            ].join("\n"),
-            category: "machine",
-        });
-        // MEMORY.md — scoped to this agent's stores
-        if (agent.memory && agent.memory.length > 0) {
-            files.push({
-                path: `${base}/MEMORY.md`,
-                content: agentMemoryMd(agent.id, agent.memory, agent.retrieval) + "\n",
-                category: "machine",
-            });
-        }
-        // SOUL.md — agent-specific instructions
-        const soulLines = [
-            `# ${toTitle(agent.id)} — Soul`,
-            "",
-            `You are the **${toTitle(agent.id)}** agent in the **${toTitle(ast.topology.name)}** topology.`,
-            "",
-        ];
-        if (agent.description) {
-            soulLines.push(`## Role`, "", agent.description, "");
-        }
-        if (agent.prompt) {
-            soulLines.push("## Instructions", "", agent.prompt, "");
-        }
-        if (agent.memory && agent.memory.length > 0) {
-            soulLines.push(`## Memory`, "", `You have access to these stores: ${agent.memory.join(", ")}. See MEMORY.md for details.`, "");
-        }
-        files.push({
-            path: `${base}/SOUL.md`,
-            content: soulLines.join("\n"),
-            category: "machine",
-        });
-    }
-    // OpenClaw injects ALL files from agentDir into the agent's system prompt.
-    // The team-level AGENTS.md, TOOLS.md, USER.md, and BOOTSTRAP.md must be
-    // copied into each agent's dir so the gateway can find them.
-    // We re-generate the content here (same functions used for root-level files)
-    // to avoid cross-function dependencies.
-    const sharedContent = {
-        "AGENTS.md": generateAgentsMd(ast).content,
-        "TOOLS.md": generateToolsMd(ast).content,
-        "USER.md": generateUserMd().content,
-        "BOOTSTRAP.md": generateBootstrapMd(ast).content,
-    };
-    for (const agent of allAgents) {
-        const base = `config/agents/${agent.id}/agent`;
-        for (const [filename, content] of Object.entries(sharedContent)) {
-            files.push({
-                path: `${base}/${filename}`,
-                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. Per-agent identity directories (config/agents/<id>/agent/)
-        files.push(...generatePerAgentDirs(ast));
-        // 7. Workspace protocol
-        const protocol = generateWorkspaceProtocol(ast);
-        if (protocol)
-            files.push(protocol);
-        return deduplicateFiles(files);
-    },
-};
-//# sourceMappingURL=openclaw.js.map