@tangle-network/agent-profile-materialize 1.1.6 → 1.1.8

package/dist/mcp.js

@@ -1,246 +0,0 @@
-export function materializeMcp(h, mcp, plan, add, unsupported) {
-    switch (h) {
-        case "claude-code":
-            materializeClaudeMcp(h, mcp, plan, add, unsupported);
-            break;
-        case "nanoclaw":
-            unsupported("mcp", "nanoclaw MCP must be injected through options.mcpServers by its SDK adapter");
-            break;
-        case "codex":
-            materializeCodexMcp(h, mcp, plan, unsupported);
-            break;
-        case "opencode":
-            // opencode.json "mcp" block (local|remote).
-            add(OPENCODE_CONFIG_FILE, serializeWorkspacePlanJson({
-                $schema: OPENCODE_CONFIG_SCHEMA,
-                mcp: openCodeMcpConfig(mcp, mcpToolTimeouts(mcp, h, unsupported)),
-            }));
-            break;
-        case "gemini":
-            materializeGeminiMcp(mcp, add);
-            break;
-        case "kimi-code": {
-            // kimi-code 2.x auto-discovers project MCP config from
-            // <cwd>/.kimi-code/mcp.json (2.3.0 dist/main.mjs:
-            // `project: join(input.cwd, ".kimi-code", "mcp.json")`; live-probed on
-            // 2.2.0). The previous lowering — .kimi/mcp.json plus a
-            // --mcp-config-file flag — targeted the legacy Python kimi-cli:
-            // kimi-code 2.x exits 1 with `error: unknown option '--mcp-config-file'`
-            // and never reads that file. Project MCP is gated behind workspace
-            // trust; an unattended executor exports KIMI_CODE_TRUST_WORKSPACE=1
-            // itself — the plan never forces trust, that posture is the launcher's.
-            const rel = ".kimi-code/mcp.json";
-            const servers = Object.fromEntries(Object.entries(mcp).map(([name, server]) => [
-                name,
-                kimiMcpServer(server),
-            ]));
-            add(rel, serializeWorkspacePlanJson({ mcpServers: servers }));
-            break;
-        }
-        case "pi":
-            materializePiMcp(mcp, plan, add);
-            break;
-        case "prime":
-            // The fork's MCP config surface (`mcpServers` in <agentDir>/settings.json,
-            // fork settings-manager.ts:98-120,219) IS read at startup, but a
-            // user-declared server never becomes model-visible: the host McpManager
-            // only registers OAuth providers and serves mcp.config/refresh
-            // host-requests (fork core/mcp/mcp-manager.ts:62-124,156-181), skips
-            // stdio servers entirely (mcp-manager.ts:73), and nothing generates a
-            // skill or prompt section for it — materializing profile.mcp would be a
-            // silently dropped control.
-            unsupported("mcp", "prime: settings.json mcpServers never becomes model-visible (fork mcp-manager.ts:62-124 " +
-                "registers OAuth providers only and skips stdio servers) — model-visible MCP is exactly " +
-                "the fork's built-in catalog skills");
-            break;
-        case "hermes":
-            unsupported("mcp", "hermes MCP is global config.yaml (mcp_servers), no cwd discovery — write to the hermes global config or pass a config flag");
-            break;
-        case "openclaw":
-            unsupported("mcp", "openclaw MCP is central ~/.openclaw/openclaw.json (mcp.servers), no cwd discovery");
-            break;
-    }
-}
-function materializeClaudeMcp(h, mcp, plan, add, unsupported) {
-    // Claude applies one MCP tool-call timeout to every server, so the
-    // longest declared one wins and is what each declaring server is told.
-    const timeouts = mcpToolTimeouts(mcp, h, unsupported);
-    const toolTimeoutMs = timeouts.size > 0 ? Math.max(...timeouts.values()) : undefined;
-    if (toolTimeoutMs !== undefined) {
-        setPlanEnvironment(plan, "MCP_TOOL_TIMEOUT", String(toolTimeoutMs));
-    }
-    const servers = {};
-    for (const [name, server] of Object.entries(mcp)) {
-        if (server.url) {
-            const headers = withAppliedToolTimeout(server.headers, timeouts.has(name) ? toolTimeoutMs : undefined);
-            servers[name] = {
-                type: server.transport ?? "http",
-                url: server.url,
-                ...(headers ? { headers } : {}),
-            };
-            continue;
-        }
-        if (server.cwd !== undefined) {
-            unsupported("mcp", `${h}: local MCP server "${name}" does not support a cwd field`);
-        }
-        servers[name] = {
-            type: "stdio",
-            command: server.command,
-            ...(server.args ? { args: server.args } : {}),
-            ...(server.env ? { env: server.env } : {}),
-        };
-    }
-    const relPath = ".tangle/claude-mcp.json";
-    add(relPath, serializeWorkspacePlanJson({ mcpServers: servers }));
-    plan.flags.push("--mcp-config", relPath, "--strict-mcp-config");
-}
-function materializeCodexMcp(h, mcp, plan, unsupported) {
-    const timeouts = mcpToolTimeouts(mcp, h, unsupported);
-    const servers = [];
-    for (const [name, server] of Object.entries(mcp).sort(([left], [right]) => compareStrings(left, right))) {
-        if (server.url && server.transport === "sse") {
-            unsupported("mcp", `codex: remote MCP server "${name}" uses unsupported SSE transport`);
-            continue;
-        }
-        servers.push(concatWorkspacePlanArguments(`${tomlStr(name)} = `, codexMcpServerToml(name, server, plan, timeouts.get(name))));
-    }
-    if (servers.length > 0) {
-        // Runtime overrides do not require persisted project trust. Header values
-        // ride environment variables so credentials never appear in argv.
-        plan.flags.push("-c", concatWorkspacePlanArguments("mcp_servers={ ", joinWorkspacePlanArguments(servers, ", "), " }"));
-    }
-}
-function materializeGeminiMcp(mcp, add) {
-    const servers = {};
-    for (const [name, server] of Object.entries(mcp)) {
-        if (server.url) {
-            servers[name] = {
-                [server.transport === "sse" ? "url" : "httpUrl"]: server.url,
-                ...(server.headers ? { headers: server.headers } : {}),
-            };
-            continue;
-        }
-        servers[name] = {
-            command: server.command,
-            ...(server.args ? { args: server.args } : {}),
-            ...(server.env ? { env: server.env } : {}),
-            ...(server.cwd ? { cwd: server.cwd } : {}),
-        };
-    }
-    add(".gemini/settings.json", serializeWorkspacePlanJson({ mcpServers: servers }));
-}
-function materializePiMcp(mcp, plan, add) {
-    // pi ships NO MCP. It arrives from the `pi-mcp-adapter` extension, which discovers
-    // `<cwd>/.pi/mcp.json` (adapter 2.17.0 config.ts:17) and also registers a `--mcp-config`
-    // flag (index.ts:252). The flag is registered BY the extension, so passing it when the
-    // extension is absent is not a fallback — it is an unknown flag.
-    //
-    // This was previously marked unsupported because a workspace file cannot install an
-    // extension. That reasoning was right about the constraint and wrong about the conclusion:
-    // the file half is perfectly materializable, and the half that is not becomes a declared
-    // requirement the executor enforces. Marking the whole dimension unsupported pushed both
-    // halves onto every consumer, and two of them independently rebuilt it.
-    const rel = ".pi/mcp.json";
-    const servers = Object.fromEntries(Object.entries(mcp).map(([name, server]) => [
-        name,
-        // `directTools` promotes this server's verbs to first-class pi tools. Without it the
-        // agent gets one generic `mcp` tool and must connect, then describe, then call — three
-        // round trips of discovery before it can do anything. Per-server, because the adapter
-        // lets a per-server value override the global `settings.directTools` (direct-tools.ts:135).
-        { ...piMcpServer(server), directTools: true },
-    ]));
-    // serializeWorkspacePlanJson, NOT JSON.stringify: it unwraps public config values to their
-    // bytes and lifts any secret-ref into a tracked slot the applier resolves. Stringifying
-    // straight would write `{"kind":"public","value":"..."}` into the file as an argv entry.
-    add(rel, serializeWorkspacePlanJson({ mcpServers: servers }));
-    plan.requires?.push({
-        kind: "harness-extension",
-        dimension: "mcp",
-        id: "npm:pi-mcp-adapter",
-        reason: "pi has no built-in MCP; without this extension the servers in .pi/mcp.json are never read and the agent starts with none of their tools",
-        remedy: "pi install npm:pi-mcp-adapter",
-    });
-}
-function tomlInlineStringTable(values) {
-    return `{ ${Object.entries(values)
-        .sort(([left], [right]) => compareStrings(left, right))
-        .map(([key, value]) => `${tomlStr(key)} = ${tomlStr(value)}`)
-        .join(", ")} }`;
-}
-function codexMcpServerToml(name, server, plan, toolTimeoutMs) {
-    const fields = [];
-    // Codex takes whole seconds per server; the server is told what was applied.
-    const appliedTimeoutMs = toolTimeoutMs === undefined
-        ? undefined
-        : Math.ceil(toolTimeoutMs / 1000) * 1000;
-    if (appliedTimeoutMs !== undefined) {
-        fields.push(`tool_timeout_sec = ${appliedTimeoutMs / 1000}`);
-    }
-    if (server.url) {
-        fields.push(`url = ${tomlStr(server.url)}`);
-        const headers = withAppliedToolTimeout(server.headers, appliedTimeoutMs);
-        if (headers && Object.keys(headers).length > 0) {
-            const envHeaders = {};
-            for (const [header, value] of Object.entries(headers).sort(([left], [right]) => compareStrings(left, right))) {
-                const envName = `TANGLE_MCP_HEADER_${sha256(`${name}\0${header}`)
-                    .slice(0, 24)
-                    .toUpperCase()}`;
-                setPlanEnvironment(plan, envName, value);
-                envHeaders[header] = envName;
-            }
-            fields.push(`env_http_headers = ${tomlInlineStringTable(envHeaders)}`);
-        }
-    }
-    else {
-        if (!server.command) {
-            throw new Error(`Codex MCP server "${name}" must define url or command`);
-        }
-        fields.push(`command = ${tomlStr(server.command)}`);
-        if (server.args?.length) {
-            fields.push(concatWorkspacePlanArguments("args = [", joinWorkspacePlanArguments(server.args.map(tomlProfileConfigValue), ", "), "]"));
-        }
-        if (server.cwd)
-            fields.push(`cwd = ${tomlStr(server.cwd)}`);
-        if (server.env && Object.keys(server.env).length > 0) {
-            const envNames = Object.keys(server.env).sort(compareStrings);
-            for (const envName of envNames) {
-                setPlanEnvironment(plan, envName, server.env[envName]);
-            }
-            fields.push(`env_vars = [${envNames.map(tomlStr).join(", ")}]`);
-        }
-    }
-    return concatWorkspacePlanArguments("{ ", joinWorkspacePlanArguments(fields, ", "), " }");
-}
-/**
- * Lower one canonical MCP server to the shape `pi-mcp-adapter` reads from `.pi/mcp.json`.
- *
- * The adapter consumes the same `{mcpServers: {...}}` document Claude and Kimi use, so this
- * mirrors {@link kimiMcpServer} rather than inventing a pi dialect. `directTools` is added by the
- * caller, not here, because it is a policy about tool surfacing rather than a property of the
- * server definition.
- */
-function piMcpServer(server) {
-    return kimiMcpServer(server);
-}
-function kimiMcpServer(server) {
-    if (server.url) {
-        return {
-            url: server.url,
-            transport: server.transport ?? "http",
-            ...(server.headers ? { headers: server.headers } : {}),
-        };
-    }
-    return {
-        command: server.command,
-        ...(server.args ? { args: server.args } : {}),
-        ...(server.env ? { env: server.env } : {}),
-        ...(server.cwd ? { cwd: server.cwd } : {}),
-    };
-}
-import { OPENCODE_CONFIG_FILE, OPENCODE_CONFIG_SCHEMA } from "./harness.js";
-import { openCodeMcpConfig } from "./mcp-opencode.js";
-import { mcpToolTimeouts, withAppliedToolTimeout, } from "./mcp-timeouts.js";
-import { sha256 } from "./plan-digest.js";
-import { concatWorkspacePlanArguments, joinWorkspacePlanArguments, serializeWorkspacePlanJson, tomlProfileConfigValue, tomlStr, } from "./plan-json.js";
-import { setPlanEnvironment } from "./profile-plan.js";
-import { compareStrings } from "./workspace-files.js";

package/dist/model-id.d.ts

@@ -1,55 +0,0 @@
-/**
- * The one canonicalization of a model id, shared by everything that writes a
- * model id into an {@link AgentProfile} and everything that later compares one
- * against it.
- *
- * A model id is qualified by prepending provider segments, and the same model
- * is legitimately spelled at more than one qualification level as it travels:
- * the caller sends `{ provider: "openai-compat", model: "deepseek/deepseek-v4-flash" }`,
- * the profile records the qualified `openai-compat/deepseek/deepseek-v4-flash`,
- * and the CLI is spawned with that qualified form. Two spellings, one model.
- *
- * Every writer and every reader must run both sides through here, so a
- * comparison cannot mistake two spellings of one model for a conflict. Two
- * independent copies of this rule are exactly how that bug arises.
- */
-/**
- * Qualify `modelId` with `provider` — the canonical form of a model id.
- *
- * The already-qualified check is prefix-SPECIFIC rather than "already contains
- * a slash": a router slug legitimately carries an upstream segment of its own
- * (`deepseek/deepseek-v4-flash`, `zai/glm-4.7`), so a generic slash test would
- * leave those unqualified, while an unconditional prefix would double-qualify
- * an id that has already been through here.
- *
- * Idempotent by construction:
- * `qualifyModelId(p, qualifyModelId(p, m)) === qualifyModelId(p, m)`.
- */
-export declare function qualifyModelId<T extends string | undefined>(provider: string | undefined, modelId: T): T;
-/**
- * Remove one exact `provider/` qualification from `modelId`.
- *
- * This is the inverse operation for a model id that was qualified by this
- * provider. It removes only the known outer prefix and preserves upstream
- * segments such as `zai/glm-4.7`.
- *
- * The helper removes one outer qualification per call. It leaves missing
- * providers and model ids unchanged.
- */
-export declare function unqualifyModelId(provider: string | undefined, modelId: string): string;
-export declare function unqualifyModelId(provider: string | undefined, modelId: undefined): undefined;
-export declare function unqualifyModelId(provider: string | undefined, modelId: string | undefined): string | undefined;
-/**
- * Do two model ids name the same model?
- *
- * Both operands are qualified by `provider` before comparison, so the
- * qualification level a caller happened to use is not a difference. Two
- * different model names are still different — this narrows a comparison to the
- * model's identity, it does not make the comparison permissive.
- *
- * `provider` is optional because a profile may carry a `model.default` that was
- * qualified by a writer which did not also record `model.provider`. With no
- * provider to qualify by, a bare id and its single-segment-qualified spelling
- * are still the same model, which is the only tolerance the undeclared case gets.
- */
-export declare function modelIdsMatch(a: string | undefined, b: string | undefined, provider?: string): boolean;

package/dist/model-id.js

@@ -1,67 +0,0 @@
-/**
- * The one canonicalization of a model id, shared by everything that writes a
- * model id into an {@link AgentProfile} and everything that later compares one
- * against it.
- *
- * A model id is qualified by prepending provider segments, and the same model
- * is legitimately spelled at more than one qualification level as it travels:
- * the caller sends `{ provider: "openai-compat", model: "deepseek/deepseek-v4-flash" }`,
- * the profile records the qualified `openai-compat/deepseek/deepseek-v4-flash`,
- * and the CLI is spawned with that qualified form. Two spellings, one model.
- *
- * Every writer and every reader must run both sides through here, so a
- * comparison cannot mistake two spellings of one model for a conflict. Two
- * independent copies of this rule are exactly how that bug arises.
- */
-/**
- * Qualify `modelId` with `provider` — the canonical form of a model id.
- *
- * The already-qualified check is prefix-SPECIFIC rather than "already contains
- * a slash": a router slug legitimately carries an upstream segment of its own
- * (`deepseek/deepseek-v4-flash`, `zai/glm-4.7`), so a generic slash test would
- * leave those unqualified, while an unconditional prefix would double-qualify
- * an id that has already been through here.
- *
- * Idempotent by construction:
- * `qualifyModelId(p, qualifyModelId(p, m)) === qualifyModelId(p, m)`.
- */
-export function qualifyModelId(provider, modelId) {
-    if (!provider || !modelId)
-        return modelId;
-    if (modelId === provider || modelId.startsWith(`${provider}/`))
-        return modelId;
-    return `${provider}/${modelId}`;
-}
-export function unqualifyModelId(provider, modelId) {
-    if (!provider || !modelId)
-        return modelId;
-    const providerPrefix = `${provider}/`;
-    return modelId.startsWith(providerPrefix)
-        ? modelId.slice(providerPrefix.length)
-        : modelId;
-}
-/**
- * Do two model ids name the same model?
- *
- * Both operands are qualified by `provider` before comparison, so the
- * qualification level a caller happened to use is not a difference. Two
- * different model names are still different — this narrows a comparison to the
- * model's identity, it does not make the comparison permissive.
- *
- * `provider` is optional because a profile may carry a `model.default` that was
- * qualified by a writer which did not also record `model.provider`. With no
- * provider to qualify by, a bare id and its single-segment-qualified spelling
- * are still the same model, which is the only tolerance the undeclared case gets.
- */
-export function modelIdsMatch(a, b, provider) {
-    if (a === b)
-        return true;
-    if (a === undefined || b === undefined)
-        return false;
-    if (qualifyModelId(provider, a) === qualifyModelId(provider, b))
-        return true;
-    if (provider)
-        return false;
-    return ((!a.includes("/") && b.endsWith(`/${a}`)) ||
-        (!b.includes("/") && a.endsWith(`/${b}`)));
-}

package/dist/pi-models-config.d.ts

@@ -1,32 +0,0 @@
-export interface PiModelsConfigInput {
-    /** Provider key in models.json and the matching `--provider` value. */
-    providerName: string;
-    /** Model id in models.json and the matching `--model` value. */
-    modelId: string;
-    /** Provider endpoint. OpenAI-compatible endpoints include `/v1`. */
-    baseUrl: string;
-    /** Literal in-box credential or an environment reference. */
-    apiKey: string;
-    /** Pi wire protocol. */
-    api?: "anthropic-messages" | "google-generative-ai" | "openai-completions" | "openai-responses";
-    contextWindow?: number;
-    maxTokens?: number;
-    reasoning?: boolean;
-    /** OpenAI-compatible completions may reject the optional store field. */
-    supportsStore?: boolean;
-}
-export interface PiModelsConfigFile {
-    path: string;
-    content: string;
-    mode: number;
-}
-export declare const PI_MODELS_CONFIG_PATH = ".pi/agent/models.json";
-export interface PiRuntimePaths {
-    agentDir: string;
-    sessionDir: string;
-}
-/** Resolve Pi's private roots from the one runtime HOME supplied to Pi. */
-export declare function resolvePiRuntimePaths(runtimeHome: string): PiRuntimePaths;
-export declare function buildPiModelsConfig(input: PiModelsConfigInput): Record<string, unknown>;
-/** Build the owner-only Pi file used by headless and interactive processes. */
-export declare function buildPiModelsConfigFile(input: PiModelsConfigInput): PiModelsConfigFile;

package/dist/pi-models-config.js

@@ -1,65 +0,0 @@
-/**
- * One custom-model shape for upstream Pi and the Prime fork.
- *
- * Both agents read the same `models.json` provider schema.
- * Callers own the file lifecycle, but they must not build different payloads.
- */
-import path from "node:path";
-export const PI_MODELS_CONFIG_PATH = ".pi/agent/models.json";
-/** Resolve Pi's private roots from the one runtime HOME supplied to Pi. */
-export function resolvePiRuntimePaths(runtimeHome) {
-    const home = path.resolve(runtimeHome);
-    const agentDir = path.dirname(path.join(home, PI_MODELS_CONFIG_PATH));
-    return {
-        agentDir,
-        sessionDir: path.join(agentDir, "sessions"),
-    };
-}
-const DEFAULT_CONTEXT_WINDOW = 128_000;
-export function buildPiModelsConfig(input) {
-    for (const [field, value] of [
-        ["providerName", input.providerName],
-        ["modelId", input.modelId],
-        ["baseUrl", input.baseUrl],
-        ["apiKey", input.apiKey],
-    ]) {
-        if (typeof value !== "string" || value.trim().length === 0) {
-            throw new Error(`pi models.json requires a non-empty "${field}"; ` +
-                "the caller must supply provider, model, baseUrl, and apiKey");
-        }
-    }
-    return {
-        providers: {
-            [input.providerName]: {
-                name: input.providerName,
-                baseUrl: input.baseUrl,
-                api: input.api ?? "openai-completions",
-                apiKey: input.apiKey,
-                models: [
-                    {
-                        id: input.modelId,
-                        name: input.modelId,
-                        reasoning: input.reasoning ?? false,
-                        ...(input.supportsStore !== undefined
-                            ? { compat: { supportsStore: input.supportsStore } }
-                            : {}),
-                        input: ["text", "image"],
-                        contextWindow: input.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
-                        ...(input.maxTokens !== undefined
-                            ? { maxTokens: input.maxTokens }
-                            : {}),
-                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-                    },
-                ],
-            },
-        },
-    };
-}
-/** Build the owner-only Pi file used by headless and interactive processes. */
-export function buildPiModelsConfigFile(input) {
-    return {
-        path: PI_MODELS_CONFIG_PATH,
-        content: `${JSON.stringify(buildPiModelsConfig(input), null, 2)}\n`,
-        mode: 0o600,
-    };
-}

package/dist/plan-application.d.ts

@@ -1,10 +0,0 @@
-export declare function applyWorkspacePlan(plan: WorkspacePlan, workspaceDir: string, options?: ApplyWorkspacePlanOptions): WorkspacePlanReceipt;
-/**
- * Resolve opaque profile references through an executor-owned provider, then
- * apply the resulting private native files and launch inputs. Resolution
- * completes before any workspace write, and resolved values never enter the
- * public plan, digest, receipt, logs, or error messages.
- */
-export declare function applyWorkspacePlanWithSecretProvider(plan: WorkspacePlan, workspaceDir: string, secretProvider: AgentProfileSecretProvider, options?: ApplyWorkspacePlanOptions): Promise<WorkspacePlanApplication>;
-import type { AgentProfileSecretProvider } from "@tangle-network/agent-interface";
-import type { ApplyWorkspacePlanOptions, WorkspacePlan, WorkspacePlanApplication, WorkspacePlanReceipt } from "./plan-types.js";

package/dist/plan-application.js

@@ -1,190 +0,0 @@
-export function applyWorkspacePlan(plan, workspaceDir, options = {}) {
-    return applyResolvedWorkspacePlan(plan, resolvePublicWorkspacePlan(plan), workspaceDir, options).receipt;
-}
-/**
- * Resolve opaque profile references through an executor-owned provider, then
- * apply the resulting private native files and launch inputs. Resolution
- * completes before any workspace write, and resolved values never enter the
- * public plan, digest, receipt, logs, or error messages.
- */
-export async function applyWorkspacePlanWithSecretProvider(plan, workspaceDir, secretProvider, options = {}) {
-    const planDigest = hashWorkspacePlan(plan);
-    const resolved = await resolvePrivateWorkspacePlan(plan, secretProvider, options.secretFileSlotReferences);
-    return applyResolvedWorkspacePlan(plan, resolved, workspaceDir, options, planDigest);
-}
-function secretRefLabel(ref) {
-    return JSON.stringify(ref.key);
-}
-function requireResolvedSecretValue(ref, value) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        throw new Error(`AgentProfile secret provider returned no value for ${secretRefLabel(ref)}`);
-    }
-    return value;
-}
-function setValueAtJsonPath(root, path, value) {
-    let current = root;
-    for (const segment of path.slice(0, -1)) {
-        if (current === null ||
-            typeof current !== "object" ||
-            !Object.hasOwn(current, segment)) {
-            throw new Error("Generated profile JSON secret path no longer exists");
-        }
-        current = current[segment];
-    }
-    const finalSegment = path.at(-1);
-    if (finalSegment === undefined ||
-        current === null ||
-        typeof current !== "object" ||
-        !Object.hasOwn(current, finalSegment)) {
-        throw new Error("Generated profile JSON secret path no longer exists");
-    }
-    Object.defineProperty(current, finalSegment, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true,
-    });
-}
-function resolvePublicWorkspacePlan(plan) {
-    const files = normalizePlanFiles(plan.files);
-    for (const file of files) {
-        const ref = file.secretSlots[0]?.ref;
-        if (ref) {
-            throw new Error(`Workspace plan requires an AgentProfileSecretProvider for ${secretRefLabel(ref)}`);
-        }
-    }
-    const env = Object.fromEntries(Object.entries(plan.env).map(([name, value]) => {
-        if (typeof value !== "string") {
-            throw new Error(`Workspace plan requires an AgentProfileSecretProvider for ${secretRefLabel(value)}`);
-        }
-        return [name, value];
-    }));
-    const flags = plan.flags.map((argument) => {
-        const normalized = normalizeWorkspacePlanArgument(argument);
-        if (typeof normalized !== "string") {
-            const segment = normalized.segments.find((value) => typeof value !== "string");
-            if (!segment) {
-                throw new Error("Workspace plan argument template is malformed");
-            }
-            throw new Error(`Workspace plan requires an AgentProfileSecretProvider for ${secretRefLabel(segment.ref)}`);
-        }
-        return normalized;
-    });
-    return {
-        files,
-        env,
-        flags,
-        ...promptIntentFields(plan, samePromptIntentValue),
-        ...systemPromptBindingField(plan),
-    };
-}
-/**
- * OpenCode substitutes `{env:NAME}` textually into its config before parsing
- * it, so only a value that cannot break out of a JSON string or start another
- * substitution may stand behind a reference.
- */
-const SUBSTITUTABLE_SECRET_VALUE = /^[\x20-\x7e]+$/;
-const UNSUBSTITUTABLE_SECRET_CHARACTERS = /["\\{}]/;
-function secretSlotEnvironmentName(ref) {
-    const digest = createHash("sha256")
-        .update(ref.key, "utf8")
-        .digest("hex")
-        .slice(0, 24)
-        .toUpperCase();
-    return `TANGLE_PROFILE_SECRET_${digest}`;
-}
-async function resolvePrivateWorkspacePlan(plan, secretProvider, fileSlotReferences) {
-    if (!secretProvider || typeof secretProvider.get !== "function") {
-        throw new Error("AgentProfileSecretProvider.get is required");
-    }
-    const pending = new Map();
-    const resolveRawRef = (ref) => {
-        let raw = pending.get(ref.key);
-        if (!raw) {
-            raw = (async () => {
-                let value;
-                try {
-                    value = await secretProvider.get(ref.key);
-                }
-                catch (cause) {
-                    // The executor's refusal (a key it will not serve) rides along as
-                    // the cause; a provider error carries no resolved value.
-                    throw new Error(`AgentProfile secret provider failed for ${secretRefLabel(ref)}`, { cause });
-                }
-                return requireResolvedSecretValue(ref, value);
-            })();
-            pending.set(ref.key, raw);
-        }
-        return raw;
-    };
-    const resolveRef = async (input) => {
-        const ref = agentProfileSecretRefSchema.parse(input);
-        const value = await resolveRawRef(ref);
-        return ref.format === "bearer" ? `Bearer ${value}` : value;
-    };
-    const resolveFileSlot = async (input) => {
-        const ref = agentProfileSecretRefSchema.parse(input);
-        const value = await resolveRawRef(ref);
-        if (!fileSlotReferences) {
-            return ref.format === "bearer" ? `Bearer ${value}` : value;
-        }
-        // Never write the value in place: the file is readable by the process
-        // that loads it, and so by every tool that process runs.
-        if (!SUBSTITUTABLE_SECRET_VALUE.test(value) ||
-            UNSUBSTITUTABLE_SECRET_CHARACTERS.test(value)) {
-            throw new Error(`AgentProfile secret ${secretRefLabel(ref)} has a value that cannot be referenced from a secret OpenCode config: it may hold only printable ASCII without quotes, backslashes or braces`);
-        }
-        const name = secretSlotEnvironmentName(ref);
-        fileSlotReferences[name] = value;
-        return ref.format === "bearer" ? `Bearer {env:${name}}` : `{env:${name}}`;
-    };
-    const files = await Promise.all(normalizePlanFiles(plan.files).map(async (file) => {
-        if (file.secretSlots.length === 0)
-            return file;
-        // Generated native config files with secret slots are JSON objects.
-        const parsed = JSON.parse(file.content);
-        const values = await Promise.all(file.secretSlots.map(async (slot) => ({
-            path: slot.path,
-            value: await resolveFileSlot(slot.ref),
-        })));
-        for (const resolved of values) {
-            setValueAtJsonPath(parsed, resolved.path, resolved.value);
-        }
-        return {
-            ...file,
-            content: JSON.stringify(parsed, null, 2),
-            secretSlots: [],
-        };
-    }));
-    const env = Object.fromEntries(await Promise.all(Object.entries(plan.env).map(async ([name, value]) => [
-        name,
-        typeof value === "string" ? value : await resolveRef(value),
-    ])));
-    const flags = await Promise.all(plan.flags.map(async (argument) => {
-        const normalized = normalizeWorkspacePlanArgument(argument);
-        if (typeof normalized === "string")
-            return normalized;
-        const segments = await Promise.all(normalized.segments.map(async (segment) => {
-            if (typeof segment === "string")
-                return segment;
-            const value = await resolveRef(segment.ref);
-            return segment.encoding === "json-string"
-                ? JSON.stringify(value)
-                : value;
-        }));
-        return segments.join("");
-    }));
-    return {
-        files,
-        env,
-        flags,
-        ...promptIntentFields(plan, samePromptIntentValue),
-        ...systemPromptBindingField(plan),
-    };
-}
-import { createHash } from "node:crypto";
-import { agentProfileSecretRefSchema } from "@tangle-network/agent-interface";
-import { hashWorkspacePlan } from "./plan-digest.js";
-import { normalizePlanFiles, normalizeWorkspacePlanArgument, } from "./plan-normalize.js";
-import { promptIntentFields, samePromptIntentValue, systemPromptBindingField, } from "./plan-prompt.js";
-import { applyResolvedWorkspacePlan, } from "./workspace-apply.js";