@tangle-network/agent-profile-materialize 0.27.1 → 0.27.2

package/dist/execution-controls.js

@@ -2,121 +2,18 @@ export function materializeExecutionControls(h, tools, permissions, modes, plan,
     const toolEntries = Object.entries(tools ?? {}).sort(([left], [right]) => compareStrings(left, right));
     const permissionEntries = Object.entries(permissions ?? {}).sort(([left], [right]) => compareStrings(left, right));
     switch (h) {
-        case "claude-code": {
-            if (toolEntries.length > 0 || permissionEntries.length > 0) {
-                const nativeTools = mapSupportedBooleanEntries(toolEntries, claudeToolName, (name) => unsupported("tools", `claude-code: no verified native tool mapping for "${name}". Accepted: ${CLAUDE_CODE_NATIVE_TOOL_IDS.join(", ")}`));
-                const nativePermissions = mapSupportedPermissionEntries(permissionEntries, claudeToolName, (name) => unsupported("permissions", `claude-code: no verified native permission mapping for "${name}". Accepted: ${CLAUDE_CODE_NATIVE_PERMISSION_IDS.join(", ")}`), "claude-code permission");
-                const rules = claudePermissionRules(nativePermissions);
-                for (const [tool, enabled] of nativeTools) {
-                    rules[enabled ? "allow" : "deny"].push(tool);
-                }
-                add(CLAUDE_SETTINGS_PATH, serializeWorkspacePlanJson({
-                    permissions: sealClaudePermissionRules(rules),
-                }));
-                registerClaudeSettings(plan);
-            }
+        case "claude-code":
+            materializeClaudeControls(toolEntries, permissionEntries, plan, add, unsupported);
             break;
-        }
-        case "opencode": {
-            const enforceableTools = toolEntries.filter(([name, enabled]) => {
-                if (normalizedControlName(name) !== "lsp" || !enabled)
-                    return true;
-                unsupported("tools", "opencode: the LSP tool is disabled by the runtime and cannot be enabled exactly");
-                return false;
-            });
-            const enforceablePermissions = permissionEntries.filter(([name, policy]) => {
-                if (normalizedControlName(name) !== "read")
-                    return true;
-                if (!permissionAllowsEverything(policy)) {
-                    unsupported("permissions", "opencode: read access cannot be denied or approval-gated");
-                }
-                return false;
-            });
-            const nativeTools = mapSupportedBooleanEntries(enforceableTools, openCodeToolName, (name) => unsupported("tools", `opencode: no verified native tool mapping for "${name}". Accepted: ${OPENCODE_NATIVE_TOOL_IDS.join(", ")}`));
-            const nativePermissions = mapSupportedPermissionEntries(enforceablePermissions, (name) => openCodeDeclaredMcpPermissionName(name, mcpAliases) ??
-                openCodePermissionName(name), (name) => unsupported("permissions", `opencode: no verified native permission mapping for "${name}". Accepted: ${OPENCODE_NATIVE_PERMISSION_IDS.join(", ")}`), "opencode permission");
-            if (enforceableTools.length > 0 || permissionEntries.length > 0) {
-                add(OPENCODE_CONFIG_FILE, serializeWorkspacePlanJson({
-                    $schema: OPENCODE_CONFIG_SCHEMA,
-                    ...(nativeTools.length > 0
-                        ? { tools: Object.fromEntries(nativeTools) }
-                        : {}),
-                    ...(nativePermissions.length > 0
-                        ? { permission: Object.fromEntries(nativePermissions) }
-                        : {}),
-                }));
-            }
+        case "opencode":
+            materializeOpenCodeControls(toolEntries, permissionEntries, add, unsupported, mcpAliases);
             break;
-        }
-        case "codex": {
-            const searchEntries = [];
-            const fetchEntries = [];
-            for (const [name, enabled] of toolEntries) {
-                const posture = resolveNativeWebTools({ [name]: enabled });
-                if (posture.search === enabled && posture.fetch === undefined) {
-                    searchEntries.push([name, enabled]);
-                    continue;
-                }
-                if (posture.fetch === enabled && posture.search === undefined) {
-                    fetchEntries.push([name, enabled]);
-                    continue;
-                }
-                unsupported("tools", `codex: no verified primary-process tool mapping for "${name}"`);
-            }
-            // Codex has no native fetch: only a fetch that stays on after its
-            // spellings merge asks for something this harness cannot run.
-            const nativeFetch = mapSupportedBooleanEntries(fetchEntries, () => "web_fetch", () => undefined);
-            if (nativeFetch[0]?.[1]) {
-                for (const [name] of fetchEntries) {
-                    unsupported("tools", `codex: native web fetch is unavailable for "${name}"`);
-                }
-            }
-            const nativeSearch = mapSupportedBooleanEntries(searchEntries, () => "web_search", () => undefined);
-            if (nativeSearch[0]) {
-                plan.flags.push("-c", `tools.web_search=${nativeSearch[0][1]}`);
-            }
-            if (permissionEntries.length > 0) {
-                unsupported("permissions", "codex: no verified primary-process permission policy mapping");
-            }
+        case "codex":
+            materializeCodexControls(toolEntries, permissionEntries, plan, unsupported);
             break;
-        }
-        case "pi": {
-            const nativeTools = mapSupportedBooleanEntries(toolEntries, piToolId, (name) => unsupported("tools", `pi: tool name "${name}" is empty after trimming`));
-            const nativePermissions = mapSupportedPermissionEntries(permissionEntries, piToolId, (name) => unsupported("permissions", `pi: permission name "${name}" is empty after trimming`), "pi permission");
-            const enabled = new Set(nativeTools
-                .filter(([, value]) => value)
-                .map(([name]) => name)
-                .sort(compareStrings));
-            const excluded = new Set(nativeTools
-                .filter(([, value]) => !value)
-                .map(([name]) => name)
-                .sort(compareStrings));
-            for (const [name, policy] of nativePermissions) {
-                if (typeof policy !== "string") {
-                    unsupported("permissions", `pi: conditional permission policy for "${name}" has no verified headless mapping`);
-                    continue;
-                }
-                if (policy === "ask") {
-                    unsupported("permissions", `pi: permission policy "ask" for "${name}" requires an interactive decision surface`);
-                    continue;
-                }
-                // The stricter control holds, as across spellings of one tool: an
-                // allow keeps a disabled tool disabled, and a deny excludes an
-                // enabled one.
-                if (policy === "allow")
-                    continue;
-                enabled.delete(name);
-                excluded.add(name);
-            }
-            if (enabled.size > 0 || excluded.size > 0) {
-                add(PI_EXECUTION_CONTROL_EXTENSION_PATH, piExecutionControlExtensionSource([...enabled], [...excluded]));
-                plan.flags.push("--extension", PI_EXECUTION_CONTROL_EXTENSION_PATH);
-            }
-            if (excluded.size > 0) {
-                plan.flags.push("--exclude-tools", [...excluded].sort(compareStrings).join(","));
-            }
+        case "pi":
+            materializePiControls(toolEntries, permissionEntries, plan, add, unsupported);
             break;
-        }
         default:
             if (toolEntries.length > 0) {
                 unsupported("tools", `${h}: no verified primary-process tool availability mapping`);
@@ -129,6 +26,117 @@ export function materializeExecutionControls(h, tools, permissions, modes, plan,
         unsupported("modes", `${h}: resolve one named AgentProfile mode before materialization`);
     }
 }
+function materializeClaudeControls(toolEntries, permissionEntries, plan, add, unsupported) {
+    if (toolEntries.length > 0 || permissionEntries.length > 0) {
+        const nativeTools = mapSupportedBooleanEntries(toolEntries, claudeToolName, (name) => unsupported("tools", `claude-code: no verified native tool mapping for "${name}". Accepted: ${CLAUDE_CODE_NATIVE_TOOL_IDS.join(", ")}`));
+        const nativePermissions = mapSupportedPermissionEntries(permissionEntries, claudeToolName, (name) => unsupported("permissions", `claude-code: no verified native permission mapping for "${name}". Accepted: ${CLAUDE_CODE_NATIVE_PERMISSION_IDS.join(", ")}`), "claude-code permission");
+        const rules = claudePermissionRules(nativePermissions);
+        for (const [tool, enabled] of nativeTools) {
+            rules[enabled ? "allow" : "deny"].push(tool);
+        }
+        add(CLAUDE_SETTINGS_PATH, serializeWorkspacePlanJson({
+            permissions: sealClaudePermissionRules(rules),
+        }));
+        registerClaudeSettings(plan);
+    }
+}
+function materializeOpenCodeControls(toolEntries, permissionEntries, add, unsupported, mcpAliases) {
+    const enforceableTools = toolEntries.filter(([name, enabled]) => {
+        if (normalizedControlName(name) !== "lsp" || !enabled)
+            return true;
+        unsupported("tools", "opencode: the LSP tool is disabled by the runtime and cannot be enabled exactly");
+        return false;
+    });
+    const enforceablePermissions = permissionEntries.filter(([name, policy]) => {
+        if (normalizedControlName(name) !== "read")
+            return true;
+        if (!permissionAllowsEverything(policy)) {
+            unsupported("permissions", "opencode: read access cannot be denied or approval-gated");
+        }
+        return false;
+    });
+    const nativeTools = mapSupportedBooleanEntries(enforceableTools, openCodeToolName, (name) => unsupported("tools", `opencode: no verified native tool mapping for "${name}". Accepted: ${OPENCODE_NATIVE_TOOL_IDS.join(", ")}`));
+    const nativePermissions = mapSupportedPermissionEntries(enforceablePermissions, (name) => openCodeDeclaredMcpPermissionName(name, mcpAliases) ??
+        openCodePermissionName(name), (name) => unsupported("permissions", `opencode: no verified native permission mapping for "${name}". Accepted: ${OPENCODE_NATIVE_PERMISSION_IDS.join(", ")}`), "opencode permission");
+    if (enforceableTools.length > 0 || permissionEntries.length > 0) {
+        add(OPENCODE_CONFIG_FILE, serializeWorkspacePlanJson({
+            $schema: OPENCODE_CONFIG_SCHEMA,
+            ...(nativeTools.length > 0
+                ? { tools: Object.fromEntries(nativeTools) }
+                : {}),
+            ...(nativePermissions.length > 0
+                ? { permission: Object.fromEntries(nativePermissions) }
+                : {}),
+        }));
+    }
+}
+function materializeCodexControls(toolEntries, permissionEntries, plan, unsupported) {
+    const searchEntries = [];
+    const fetchEntries = [];
+    for (const [name, enabled] of toolEntries) {
+        const posture = resolveNativeWebTools({ [name]: enabled });
+        if (posture.search === enabled && posture.fetch === undefined) {
+            searchEntries.push([name, enabled]);
+            continue;
+        }
+        if (posture.fetch === enabled && posture.search === undefined) {
+            fetchEntries.push([name, enabled]);
+            continue;
+        }
+        unsupported("tools", `codex: no verified primary-process tool mapping for "${name}"`);
+    }
+    // Codex has no native fetch: only a fetch that stays on after its
+    // spellings merge asks for something this harness cannot run.
+    const nativeFetch = mapSupportedBooleanEntries(fetchEntries, () => "web_fetch", () => undefined);
+    if (nativeFetch[0]?.[1]) {
+        for (const [name] of fetchEntries) {
+            unsupported("tools", `codex: native web fetch is unavailable for "${name}"`);
+        }
+    }
+    const nativeSearch = mapSupportedBooleanEntries(searchEntries, () => "web_search", () => undefined);
+    if (nativeSearch[0]) {
+        plan.flags.push("-c", `tools.web_search=${nativeSearch[0][1]}`);
+    }
+    if (permissionEntries.length > 0) {
+        unsupported("permissions", "codex: no verified primary-process permission policy mapping");
+    }
+}
+function materializePiControls(toolEntries, permissionEntries, plan, add, unsupported) {
+    const nativeTools = mapSupportedBooleanEntries(toolEntries, piToolId, (name) => unsupported("tools", `pi: tool name "${name}" is empty after trimming`));
+    const nativePermissions = mapSupportedPermissionEntries(permissionEntries, piToolId, (name) => unsupported("permissions", `pi: permission name "${name}" is empty after trimming`), "pi permission");
+    const enabled = new Set(nativeTools
+        .filter(([, value]) => value)
+        .map(([name]) => name)
+        .sort(compareStrings));
+    const excluded = new Set(nativeTools
+        .filter(([, value]) => !value)
+        .map(([name]) => name)
+        .sort(compareStrings));
+    for (const [name, policy] of nativePermissions) {
+        if (typeof policy !== "string") {
+            unsupported("permissions", `pi: conditional permission policy for "${name}" has no verified headless mapping`);
+            continue;
+        }
+        if (policy === "ask") {
+            unsupported("permissions", `pi: permission policy "ask" for "${name}" requires an interactive decision surface`);
+            continue;
+        }
+        // The stricter control holds, as across spellings of one tool: an
+        // allow keeps a disabled tool disabled, and a deny excludes an
+        // enabled one.
+        if (policy === "allow")
+            continue;
+        enabled.delete(name);
+        excluded.add(name);
+    }
+    if (enabled.size > 0 || excluded.size > 0) {
+        add(PI_EXECUTION_CONTROL_EXTENSION_PATH, piExecutionControlExtensionSource([...enabled], [...excluded]));
+        plan.flags.push("--extension", PI_EXECUTION_CONTROL_EXTENSION_PATH);
+    }
+    if (excluded.size > 0) {
+        plan.flags.push("--exclude-tools", [...excluded].sort(compareStrings).join(","));
+    }
+}
 function piExecutionControlExtensionSource(enabledTools, excludedTools) {
     return [
         'import { writeSync } from "node:fs";',

package/dist/harness.d.ts

@@ -70,31 +70,6 @@ export declare const MATERIALIZER_RESERVED_PATHS: ReadonlySet<string>;
  * invented, already owned by the name alone.
  */
 export declare const MATERIALIZER_CONTEXT_PATHS: ReadonlySet<string>;
-/**
- * The paths whose generated content is wholly this package's output, per
- * {@link PlanFile.ownership}: the reserved names, the context files, and
- * `opencode.json`, which carries only the registrations this package generates
- * from the profile.
- *
- * `opencode.json` and every context file is a documented name a user repository
- * can carry, so the name alone proves nothing and a profile resource may still
- * mount one. An existing file there is replaced only when
- * {@link materializerReplacement} recognizes its bytes as this package's own
- * earlier output.
- *
- * Deliberately absent: `.gemini/system.md`, the file `prompt.systemPrompt`
- * lowers to. The line a marker would have to add is the reason. A REPLACEMENT
- * is the caller's exact bytes and this package may add none of its own, so that
- * path keeps refusing. A context file carries `prompt.instructions`, which this
- * package already composes — it joins the blocks and appends the final newline
- * — so one more composed line is inside the same authority.
- *
- * That line, not "which channel the harness reads it on", is what separates the
- * two. `GEMINI.md` is owned even though gemini lowers its context file into the
- * system-prompt position as an ADDITION ({@link appendSystemPromptRefusal}),
- * because the intent it carries is still instructions this package composed.
- */
-export declare const MATERIALIZER_OWNED_PATHS: ReadonlySet<string>;
 /** Mark one generated native agent file without changing its harness meaning. */
 export declare function markMaterializerSubagent(relPath: string, content: string): string;
 /**

package/dist/harness.js

@@ -168,7 +168,7 @@ export const MATERIALIZER_CONTEXT_PATHS = new Set([...CONTEXT_FILE_PATHS].filter
  * system-prompt position as an ADDITION ({@link appendSystemPromptRefusal}),
  * because the intent it carries is still instructions this package composed.
  */
-export const MATERIALIZER_OWNED_PATHS = new Set([
+const MATERIALIZER_OWNED_PATHS = new Set([
     ...MATERIALIZER_RESERVED_PATHS,
     ...MATERIALIZER_CONTEXT_PATHS,
     OPENCODE_CONFIG_FILE,
@@ -355,7 +355,7 @@ export function materializerReplacement(relPath, content, plannedContent) {
 function isMaterializerOutput(relPath, content, plannedContent) {
     if (MATERIALIZER_RESERVED_PATHS.has(relPath))
         return true;
-    if (relPath === ".pi/mcp.json" || relPath === ".kimi/mcp.json")
+    if (relPath === ".pi/mcp.json" || relPath === ".kimi-code/mcp.json")
         return isMaterializerMcpConfig(relPath, content);
     if (MATERIALIZER_SUBAGENT_PATH.test(relPath)) {
         const existing = content();

package/dist/index.d.ts

@@ -5,8 +5,8 @@ export type { HarnessId } from "./harness.js";
 export { HARNESS_SKILL_DIRS, harnessAutoLoadsAgentContextFile, harnessAutoLoadsContextFile, harnessContextFile, isMaterializerHarness, MATERIALIZER_CONTEXT_PATHS, MATERIALIZER_HARNESSES, markMaterializerContextFile, skillDirForHarness, } from "./harness.js";
 export * from "./harness-prompt.js";
 export { type ConcurrentProfileRevision, ensurePublicConcurrentProfileRoots, type ManagedWorkspaceFileDigest, type ManagedWorkspaceManifest, preparePublicConcurrentProfileRevision, } from "./managed-workspace.js";
-export { type OpenCodeMcpConfig, openCodeMcpConfig } from "./mcp.js";
 export { isMaterializerMcpConfig } from "./mcp-config-ownership.js";
+export { type OpenCodeMcpConfig, openCodeMcpConfig } from "./mcp-opencode.js";
 export * from "./model-id.js";
 export { buildPiModelsConfig, buildPiModelsConfigFile, PI_MODELS_CONFIG_PATH, type PiModelsConfigFile, type PiModelsConfigInput, type PiRuntimePaths, resolvePiRuntimePaths, } from "./pi-models-config.js";
 export { applyWorkspacePlan, applyWorkspacePlanWithSecretProvider, } from "./plan-application.js";

package/dist/index.js

@@ -3,8 +3,8 @@ export { OPENCODE_NATIVE_TOOL_IDS, openCodeNativeToolId, } from "./control-maps.
 export { HARNESS_SKILL_DIRS, harnessAutoLoadsAgentContextFile, harnessAutoLoadsContextFile, harnessContextFile, isMaterializerHarness, MATERIALIZER_CONTEXT_PATHS, MATERIALIZER_HARNESSES, markMaterializerContextFile, skillDirForHarness, } from "./harness.js";
 export * from "./harness-prompt.js";
 export { ensurePublicConcurrentProfileRoots, preparePublicConcurrentProfileRevision, } from "./managed-workspace.js";
-export { openCodeMcpConfig } from "./mcp.js";
 export { isMaterializerMcpConfig } from "./mcp-config-ownership.js";
+export { openCodeMcpConfig } from "./mcp-opencode.js";
 export * from "./model-id.js";
 export { buildPiModelsConfig, buildPiModelsConfigFile, PI_MODELS_CONFIG_PATH, resolvePiRuntimePaths, } from "./pi-models-config.js";
 export { applyWorkspacePlan, applyWorkspacePlanWithSecretProvider, } from "./plan-application.js";

package/dist/managed-workspace-bind.js

@@ -60,11 +60,10 @@ export function bindConcurrentLaunch(plan, application, revisionWorkspaceDir, op
                 supportedFiles.add(".codex/system-prompt.md");
             }
             break;
-        case "kimi-code":
-            if (plan.files.some((file) => file.relPath === ".kimi/mcp.json")) {
-                bindFlagFile("--mcp-config-file", ".kimi/mcp.json");
-            }
-            break;
+        // kimi-code has no case: kimi-code 2.x discovers MCP only from
+        // <cwd>/.kimi-code/mcp.json and has no launch flag that rebinds it to the
+        // revision, so a concurrent kimi-code plan carrying one fails closed in
+        // the redirect check below.
         case "opencode": {
             const runtimeConfig = application.runtimeOnlyFiles["opencode.json"];
             if (runtimeConfig !== undefined)

package/dist/managed-workspace-stage.d.ts

@@ -2,7 +2,7 @@ import { lstatSync } from "node:fs";
 import type { AgentProfileSecretProvider } from "@tangle-network/agent-interface";
 import type { ManagedWorkspaceManifest } from "./managed-workspace-types.js";
 import type { ApplyWorkspacePlanOptions, WorkspacePlan, WorkspacePlanApplication } from "./plan-types.js";
-export interface PreparedManagedWorkspace {
+interface PreparedManagedWorkspace {
     /** Entire profile-owned tree. The caller owns its lifetime through the turn. */
     root: string;
     /** Use as the native harness cwd only inside an isolated workspace view. */
@@ -22,3 +22,4 @@ export declare function assertPrivateManagedRoot(root: string): void;
  */
 export declare function prepareManagedWorkspacePlan(plan: WorkspacePlan, managedRoot: string, sharedWorkspaceDir: string, secretProvider: AgentProfileSecretProvider, options?: Pick<ApplyWorkspacePlanOptions, "ownership" | "runtimeOnlyFiles" | "secretFileSlotReferences">): Promise<PreparedManagedWorkspace>;
 export declare function lstatIfPresent(path: string): ReturnType<typeof lstatSync> | null;
+export {};

package/dist/mcp-config-ownership.d.ts

@@ -8,24 +8,6 @@
  * state). Anything else at the path (a user's own keys, extra fields) still
  * refuses: the name alone proves nothing, same rule as `opencode.json`.
  */
-/** Paths owned by this rule. `.gemini/settings.json` is deliberately absent:
- *  it is a broader user settings file the package only contributes one key
- *  to, so its bytes cannot prove authorship. */
-export declare const MATERIALIZER_MCP_CONFIG_PATHS: Set<string>;
-/** The parsed form this rule accepts: `JSON.parse` output narrowed at the
- *  I/O boundary by {@link parseMcpServersConfig}. */
-export interface McpServersConfig {
-    mcpServers: Record<string, Record<string, unknown>>;
-}
-/** Parse workspace bytes into the one shape this rule owns, or `null` when
- *  the bytes are anything else (not an object, other top-level keys, or
- *  server entries that are not objects). The I/O boundary for
- *  {@link isGeneratedMcpConfigShape}. */
-export declare function parseMcpServersConfig(bytes: string): McpServersConfig | null;
-/** Whether a parsed MCP config carries ONLY the registrations this package
- *  generates: no extra top-level keys, and every server entry holds only
- *  generated fields. A user's own key anywhere makes this `false`. */
-export declare function isGeneratedMcpConfigShape(config: McpServersConfig): boolean;
 /** Whether the existing file at `relPath` is this package's own earlier MCP
  *  config output (shape rule above). `undefined` content = no regular file. */
 export declare function isMaterializerMcpConfig(relPath: string, content: () => string | undefined): boolean;

package/dist/mcp-config-ownership.js

@@ -11,9 +11,9 @@
 /** Paths owned by this rule. `.gemini/settings.json` is deliberately absent:
  *  it is a broader user settings file the package only contributes one key
  *  to, so its bytes cannot prove authorship. */
-export const MATERIALIZER_MCP_CONFIG_PATHS = new Set([
+const MATERIALIZER_MCP_CONFIG_PATHS = new Set([
     ".pi/mcp.json",
-    ".kimi/mcp.json",
+    ".kimi-code/mcp.json",
 ]);
 const GENERATED_MCP_SERVER_KEYS = new Set([
     "command",
@@ -31,7 +31,7 @@ const GENERATED_MCP_SERVER_KEYS = new Set([
  *  the bytes are anything else (not an object, other top-level keys, or
  *  server entries that are not objects). The I/O boundary for
  *  {@link isGeneratedMcpConfigShape}. */
-export function parseMcpServersConfig(bytes) {
+function parseMcpServersConfig(bytes) {
     let parsed;
     try {
         parsed = JSON.parse(bytes);
@@ -60,7 +60,7 @@ export function parseMcpServersConfig(bytes) {
 /** Whether a parsed MCP config carries ONLY the registrations this package
  *  generates: no extra top-level keys, and every server entry holds only
  *  generated fields. A user's own key anywhere makes this `false`. */
-export function isGeneratedMcpConfigShape(config) {
+function isGeneratedMcpConfigShape(config) {
     const keys = Object.keys(config);
     if (keys.length !== 1 || keys[0] !== "mcpServers")
         return false;

package/dist/mcp-opencode.d.ts

@@ -0,0 +1,25 @@
+/** OpenCode-native MCP configuration used by workspace and startup paths. */
+export type OpenCodeMcpConfig = Record<string, {
+    type: "remote";
+    url: string;
+    enabled: boolean;
+    headers?: Record<string, AgentProfileConfigValue>;
+    /** Milliseconds; OpenCode bounds this server's connect, tool listing and tool calls by it. */
+    timeout?: number;
+    /** `false` turns off OpenCode's OAuth discovery for this server. */
+    oauth?: false;
+} | {
+    type: "local";
+    command: Array<string | AgentProfileConfigValue>;
+    enabled: boolean;
+    environment?: Record<string, AgentProfileConfigValue>;
+    timeout?: number;
+}>;
+/**
+ * Lower canonical MCP definitions to OpenCode's native startup configuration.
+ * `toolTimeouts` holds the validated `metadata.toolTimeoutMs` of each server
+ * that declared one; without it OpenCode applies the MCP SDK's 60 s default to
+ * every tool call.
+ */
+export declare function openCodeMcpConfig(mcp: Record<string, AgentProfileMcpServer>, toolTimeouts?: ReadonlyMap<string, number>): OpenCodeMcpConfig;
+import type { AgentProfileConfigValue, AgentProfileMcpServer } from "@tangle-network/agent-interface";

package/dist/mcp-opencode.js

@@ -0,0 +1,52 @@
+const carriesAuthorization = (headers) => Object.keys(headers ?? {}).some((header) => header.toLowerCase() === "authorization");
+/**
+ * Lower canonical MCP definitions to OpenCode's native startup configuration.
+ * `toolTimeouts` holds the validated `metadata.toolTimeoutMs` of each server
+ * that declared one; without it OpenCode applies the MCP SDK's 60 s default to
+ * every tool call.
+ */
+export function openCodeMcpConfig(mcp, toolTimeouts = new Map()) {
+    const out = {};
+    for (const [name, s] of Object.entries(mcp)) {
+        if (s.enabled === false)
+            continue;
+        // OpenCode also bounds connect and tool listing by this value, so a server
+        // that hangs on connect holds startup that long; a refused connection still
+        // fails at once.
+        const timeout = toolTimeouts.get(name);
+        if (s.url) {
+            if (s.transport === "sse") {
+                throw new Error(`OpenCode MCP server "${name}" uses unsupported SSE transport`);
+            }
+            const headers = withAppliedToolTimeout(s.headers, timeout);
+            out[name] = {
+                type: "remote",
+                url: s.url,
+                enabled: true,
+                ...(headers ? { headers } : {}),
+                ...(timeout !== undefined ? { timeout } : {}),
+                // A server that takes its credential from these headers has no OAuth
+                // flow. With OAuth on, OpenCode answers its 401 with OAuth discovery at
+                // the server's origin, and the agent sees that discovery's failure
+                // instead of the server's refusal.
+                ...(carriesAuthorization(s.headers) ? { oauth: false } : {}),
+            };
+            continue;
+        }
+        if (!s.command) {
+            throw new Error(`OpenCode MCP server "${name}" must define either url or command`);
+        }
+        if (s.cwd !== undefined) {
+            throw new Error(`OpenCode MCP server "${name}" does not support a cwd field`);
+        }
+        out[name] = {
+            type: "local",
+            command: [s.command, ...(s.args ?? [])],
+            enabled: true,
+            ...(s.env ? { environment: s.env } : {}),
+            ...(timeout !== undefined ? { timeout } : {}),
+        };
+    }
+    return out;
+}
+import { withAppliedToolTimeout } from "./mcp-timeouts.js";

package/dist/mcp-timeouts.d.ts

@@ -0,0 +1,7 @@
+export type ActiveAgentProfileMcpServer = Exclude<AgentProfileMcpServer, {
+    enabled: false;
+}>;
+export declare function mcpToolTimeouts(mcp: Record<string, ActiveAgentProfileMcpServer>, h: HarnessId, unsupported: (d: Unsupported["dimension"], r: string) => void): Map<string, number>;
+export declare function withAppliedToolTimeout(headers: Record<string, AgentProfileConfigValue> | undefined, appliedTimeoutMs: number | undefined): Record<string, AgentProfileConfigValue> | undefined;
+import type { AgentProfileConfigValue, AgentProfileMcpServer } from "@tangle-network/agent-interface";
+import type { HarnessId, Unsupported } from "./plan-types.js";

package/dist/mcp-timeouts.js

@@ -0,0 +1,48 @@
+/**
+ * The header a harness sends to a remote MCP server whose tool-call timeout it
+ * raised, carrying the timeout it applied in milliseconds. A server may hold a
+ * call for nearly that long. A server that does not see the header must assume
+ * the harness default, 60 s for Claude Code, Codex and OpenCode.
+ */
+const MCP_TOOL_TIMEOUT_HEADER = "X-Mcp-Tool-Timeout-Ms";
+const MIN_MCP_TOOL_TIMEOUT_MS = 1_000;
+const MAX_MCP_TOOL_TIMEOUT_MS = 3_600_000;
+/**
+ * The tool-call timeout a profile asks the harness to give one MCP server,
+ * from `metadata.toolTimeoutMs`. Profile metadata is open in every published
+ * schema, so a profile carrying it validates against older consumers, which
+ * ignore it. A malformed value is reported, never guessed.
+ */
+function mcpToolTimeoutMs(server, name, h, unsupported) {
+    const value = server.metadata?.toolTimeoutMs;
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < MIN_MCP_TOOL_TIMEOUT_MS ||
+        value > MAX_MCP_TOOL_TIMEOUT_MS) {
+        unsupported("mcp", `${h}: MCP server "${name}" metadata.toolTimeoutMs must be an integer from ${MIN_MCP_TOOL_TIMEOUT_MS} to ${MAX_MCP_TOOL_TIMEOUT_MS}`);
+        return undefined;
+    }
+    return value;
+}
+export function mcpToolTimeouts(mcp, h, unsupported) {
+    const timeouts = new Map();
+    for (const [name, server] of Object.entries(mcp)) {
+        const value = mcpToolTimeoutMs(server, name, h, unsupported);
+        if (value !== undefined)
+            timeouts.set(name, value);
+    }
+    return timeouts;
+}
+export function withAppliedToolTimeout(headers, appliedTimeoutMs) {
+    if (appliedTimeoutMs === undefined)
+        return headers;
+    return {
+        ...headers,
+        [MCP_TOOL_TIMEOUT_HEADER]: {
+            kind: "public",
+            value: String(appliedTimeoutMs),
+        },
+    };
+}

package/dist/mcp.d.ts

@@ -1,39 +1,4 @@
 export declare function materializeMcp(h: HarnessId, mcp: Record<string, ActiveAgentProfileMcpServer>, plan: WorkspacePlan, add: AddPlanFile, unsupported: (d: Unsupported["dimension"], r: string) => void): void;
-/**
- * The header a harness sends to a remote MCP server whose tool-call timeout it
- * raised, carrying the timeout it applied in milliseconds. A server may hold a
- * call for nearly that long. A server that does not see the header must assume
- * the harness default, 60 s for Claude Code, Codex and OpenCode.
- */
-export declare const MCP_TOOL_TIMEOUT_HEADER = "X-Mcp-Tool-Timeout-Ms";
-/** OpenCode-native MCP configuration used by workspace and startup paths. */
-export type OpenCodeMcpConfig = Record<string, {
-    type: "remote";
-    url: string;
-    enabled: boolean;
-    headers?: Record<string, AgentProfileConfigValue>;
-    /** Milliseconds; OpenCode bounds this server's connect, tool listing and tool calls by it. */
-    timeout?: number;
-    /** `false` turns off OpenCode's OAuth discovery for this server. */
-    oauth?: false;
-} | {
-    type: "local";
-    command: Array<string | AgentProfileConfigValue>;
-    enabled: boolean;
-    environment?: Record<string, AgentProfileConfigValue>;
-    timeout?: number;
-}>;
-/**
- * Lower canonical MCP definitions to OpenCode's native startup configuration.
- * `toolTimeouts` holds the validated `metadata.toolTimeoutMs` of each server
- * that declared one; without it OpenCode applies the MCP SDK's 60 s default to
- * every tool call.
- */
-export declare function openCodeMcpConfig(mcp: Record<string, AgentProfileMcpServer>, toolTimeouts?: ReadonlyMap<string, number>): OpenCodeMcpConfig;
-import type { AgentProfileConfigValue, AgentProfileMcpServer } from "@tangle-network/agent-interface";
+import { type ActiveAgentProfileMcpServer } from "./mcp-timeouts.js";
 import type { AddPlanFile } from "./plan-json.js";
 import type { HarnessId, Unsupported, WorkspacePlan } from "./plan-types.js";
-type ActiveAgentProfileMcpServer = Exclude<AgentProfileMcpServer, {
-    enabled: false;
-}>;
-export {};