@tangle-network/agent-profile-materialize 1.1.7 → 1.1.9

package/dist/control-maps.js

@@ -1,277 +0,0 @@
-export function normalizedControlName(name) {
-    return name.replace(/[^a-zA-Z0-9_]/g, "").toLowerCase();
-}
-function nativeWebToolKind(name) {
-    const posture = resolveNativeWebTools({ [name]: true });
-    if (posture.search === true && posture.fetch === undefined)
-        return "search";
-    if (posture.fetch === true && posture.search === undefined)
-        return "fetch";
-    return undefined;
-}
-const CLAUDE_TOOL_NAMES = {
-    agent: "Agent",
-    askuserquestion: "AskUserQuestion",
-    bash: "Bash",
-    edit: "Edit",
-    glob: "Glob",
-    grep: "Grep",
-    notebookedit: "NotebookEdit",
-    read: "Read",
-    skill: "Skill",
-    task: "Task",
-    taskoutput: "TaskOutput",
-    todowrite: "TodoWrite",
-    webfetch: "WebFetch",
-    websearch: "WebSearch",
-    write: "Write",
-};
-/** Tool IDs accepted by Claude Code. */
-export const CLAUDE_CODE_NATIVE_TOOL_IDS = Object.values(CLAUDE_TOOL_NAMES).sort();
-/** Permission IDs accepted by Claude Code (same as tool IDs). */
-export const CLAUDE_CODE_NATIVE_PERMISSION_IDS = CLAUDE_CODE_NATIVE_TOOL_IDS;
-export function claudeToolName(name) {
-    const web = nativeWebToolKind(name);
-    if (web === "search")
-        return "WebSearch";
-    if (web === "fetch")
-        return "WebFetch";
-    return CLAUDE_TOOL_NAMES[normalizedControlName(name)];
-}
-/** Tool IDs reported by the OpenCode binary shipped in the Sandbox image. */
-export const OPENCODE_NATIVE_TOOL_IDS = [
-    "apply_patch",
-    "bash",
-    "codesearch",
-    "edit",
-    "glob",
-    "grep",
-    "question",
-    "read",
-    "skill",
-    "task",
-    "todowrite",
-    "webfetch",
-    "websearch",
-    "write",
-];
-const OPENCODE_NATIVE_TOOL_ID_SET = new Set(OPENCODE_NATIVE_TOOL_IDS);
-/** Permission IDs accepted by OpenCode (tools except read, plus special permissions). */
-export const OPENCODE_NATIVE_PERMISSION_IDS = [
-    "apply_patch",
-    "bash",
-    "codesearch",
-    "doom_loop",
-    "edit",
-    "external_directory",
-    "glob",
-    "grep",
-    "mcp",
-    "question",
-    "skill",
-    "task",
-    "todowrite",
-    "webfetch",
-    "websearch",
-    "write",
-];
-/** Resolve portable and legacy profile names to current OpenCode tool IDs. */
-export function openCodeNativeToolId(name) {
-    const web = nativeWebToolKind(name);
-    if (web === "search")
-        return "websearch";
-    if (web === "fetch")
-        return "webfetch";
-    const normalized = normalizedControlName(name);
-    if (normalized === "patch")
-        return "apply_patch";
-    return OPENCODE_NATIVE_TOOL_ID_SET.has(normalized) ? normalized : undefined;
-}
-export function openCodeToolName(name) {
-    return openCodeNativeToolId(name);
-}
-export function openCodePermissionName(name) {
-    if (name.includes("*") || name.includes("?"))
-        return undefined;
-    const normalized = normalizedControlName(name);
-    if (["write", "edit"].includes(normalized))
-        return "edit";
-    const web = nativeWebToolKind(name);
-    if (web === "search")
-        return "websearch";
-    if (web === "fetch")
-        return "webfetch";
-    if (["bash", "mcp", "doom_loop", "external_directory"].includes(normalized)) {
-        return normalized;
-    }
-    return normalized !== "read" && OPENCODE_NATIVE_TOOL_ID_SET.has(normalized)
-        ? normalized
-        : undefined;
-}
-/** OpenCode 1.x registers MCP tools as sanitized server + "_" + tool.
- * Accept exact tools and a server-wide rule only for this profile's servers.
- * A generic permission spelling must never become a grant to an undeclared MCP.
- */
-export function openCodeDeclaredMcpPermissionName(name, aliases) {
-    const servers = aliases.map((alias) => ({
-        alias,
-        native: alias.replace(/[^a-zA-Z0-9_-]/g, "_"),
-    }));
-    const matches = servers.filter(({ native }) => name.startsWith(`${native}_`));
-    const match = matches[0];
-    if (!match)
-        return undefined;
-    const { native } = match;
-    const tool = name.slice(native.length + 1);
-    if (tool !== "*" && !/^[a-zA-Z0-9_-]+$/.test(tool))
-        return undefined;
-    // Colliding or nested prefixes cannot identify one server's authority:
-    // foo_* also matches foo_bar_read, including a server named foo_bar.
-    if (matches.length !== 1 ||
-        servers.some((server) => server !== matches[0] &&
-            (server.native.startsWith(`${native}_`) ||
-                native.startsWith(`${server.native}_`)))) {
-        throw new Error(`opencode: ambiguous declared MCP permission "${name}"`);
-    }
-    if (tool !== "*" && openCodePermissionName(name) !== undefined) {
-        throw new Error(`opencode: permission "${name}" names both a native and MCP tool`);
-    }
-    return name;
-}
-export const PI_EXECUTION_CONTROL_EXTENSION_PATH = ".tangle/pi-execution-controls.ts";
-/**
- * Translate only portable spellings whose Pi equivalent differs.
- *
- * Every other exact name is resolved against Pi's live registry, keeping
- * extension and MCP tools profile-configurable without a static catalog.
- */
-export function piToolId(name) {
-    const trimmed = name.trim();
-    if (trimmed.length === 0)
-        return undefined;
-    const portableName = trimmed.toLowerCase();
-    if (portableName === "shell")
-        return "bash";
-    if (portableName === "glob")
-        return "find";
-    return trimmed;
-}
-/**
- * Map tool switches to native ids; spellings of one tool keep its explicit off.
- *
- * Products compose profiles in layers: a shared allowlist, then a product
- * constraint that disables a native tool under its own spelling. Physim adds
- * `webfetch: false` over an allowlist holding `web_fetch: true`. Off is the
- * only value that honours every layer, so it wins regardless of entry order.
- */
-export function mapSupportedBooleanEntries(entries, mapName, onUnsupported) {
-    return mapControlEntries(entries, mapName, onUnsupported, (left, right) => left && right);
-}
-export function permissionAllowsEverything(policy) {
-    return typeof policy === "string"
-        ? policy === "allow"
-        : Object.values(policy).every((value) => value === "allow");
-}
-export function mapSupportedPermissionEntries(entries, mapName, onUnsupported, label) {
-    return mapControlEntries(entries, mapName, onUnsupported, (left, right, nativeName) => mergePermissionPolicies(left, right, `${label} "${nativeName}"`));
-}
-function mapControlEntries(entries, mapName, onUnsupported, merge) {
-    const mapped = new Map();
-    for (const [name, value] of entries) {
-        const nativeName = mapName(name);
-        if (!nativeName) {
-            onUnsupported(name);
-            continue;
-        }
-        const previous = mapped.get(nativeName);
-        mapped.set(nativeName, previous === undefined ? value : merge(previous, value, nativeName));
-    }
-    return [...mapped.entries()].sort(([left], [right]) => compareStrings(left, right));
-}
-const PERMISSION_RESTRICTION = {
-    allow: 0,
-    ask: 1,
-    deny: 2,
-};
-function stricterDecision(left, right) {
-    return PERMISSION_RESTRICTION[right] > PERMISSION_RESTRICTION[left]
-        ? right
-        : left;
-}
-/**
- * Merge policies whose names resolve to one native tool; the stricter
- * decision wins, as an explicit off does for tool switches.
- *
- * Pattern rules merge only when both spellings list the same patterns in the
- * same order. OpenCode applies the last matching pattern, so any other pair
- * has no merge at least as strict as each spelling: `{"*": "deny"}` beside
- * `{"https://x/*": "allow"}` would allow x. Those pairs stay contradictions
- * that `executionControlConflict` reports at admission.
- */
-function mergePermissionPolicies(left, right, label) {
-    if (typeof left === "string" && typeof right === "string") {
-        return stricterDecision(left, right);
-    }
-    if (typeof left === "string" || typeof right === "string") {
-        throw new Error(`${label} aliases mix a whole-tool decision with pattern rules`);
-    }
-    const patterns = Object.keys(left);
-    const rightPatterns = Object.keys(right);
-    if (patterns.length !== rightPatterns.length ||
-        rightPatterns.some((pattern, index) => pattern !== patterns[index])) {
-        throw new Error(`${label} aliases set different pattern rules`);
-    }
-    return Object.fromEntries(Object.entries(left).map(([pattern, decision]) => [
-        pattern,
-        stricterDecision(decision, right[pattern] ?? decision),
-    ]));
-}
-export function claudePermissionRules(entries) {
-    const rules = {
-        allow: [],
-        ask: [],
-        deny: [],
-    };
-    for (const [tool, policy] of entries) {
-        if (typeof policy === "string") {
-            rules[policy].push(tool);
-            continue;
-        }
-        for (const [specifier, decision] of Object.entries(policy).sort(([left], [right]) => compareStrings(left, right))) {
-            rules[decision].push(specifier === "*" ? tool : `${tool}(${specifier})`);
-        }
-    }
-    rules.allow.sort(compareStrings);
-    rules.ask.sort(compareStrings);
-    rules.deny.sort(compareStrings);
-    return rules;
-}
-/**
- * Give each Claude rule one decision. A tool switch and a permission can name
- * the same rule; the stricter decision wins, as deny already beats allow
- * inside Claude Code.
- */
-export function sealClaudePermissionRules(rules) {
-    const owner = new Map();
-    for (const decision of ["allow", "ask", "deny"]) {
-        for (const rule of rules[decision]) {
-            const previous = owner.get(rule);
-            owner.set(rule, previous === undefined
-                ? decision
-                : stricterDecision(previous, decision));
-        }
-    }
-    const sealed = {
-        allow: [],
-        ask: [],
-        deny: [],
-    };
-    for (const [rule, decision] of owner)
-        sealed[decision].push(rule);
-    sealed.allow.sort(compareStrings);
-    sealed.ask.sort(compareStrings);
-    sealed.deny.sort(compareStrings);
-    return sealed;
-}
-import { resolveNativeWebTools } from "@tangle-network/agent-interface";
-import { compareStrings } from "./workspace-files.js";

package/dist/execution-controls.d.ts

@@ -1,5 +0,0 @@
-export declare function materializeExecutionControls(h: HarnessId, tools: Record<string, boolean> | undefined, permissions: Record<string, AgentProfilePermission> | undefined, modes: AgentProfile["modes"], plan: WorkspacePlan, add: AddPlanFile, unsupported: (d: Unsupported["dimension"], r: string) => void, mcpAliases?: readonly string[]): void;
-import type { AgentProfile, AgentProfilePermission } from "@tangle-network/agent-interface";
-import type { HarnessId } from "./harness.js";
-import type { AddPlanFile } from "./plan-json.js";
-import type { Unsupported, WorkspacePlan } from "./plan-types.js";

package/dist/execution-controls.js

@@ -1,199 +0,0 @@
-export function materializeExecutionControls(h, tools, permissions, modes, plan, add, unsupported, mcpAliases = []) {
-    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":
-            materializeClaudeControls(toolEntries, permissionEntries, plan, add, unsupported);
-            break;
-        case "opencode":
-            materializeOpenCodeControls(toolEntries, permissionEntries, add, unsupported, mcpAliases);
-            break;
-        case "codex":
-            materializeCodexControls(toolEntries, permissionEntries, plan, unsupported);
-            break;
-        case "pi":
-            materializePiControls(toolEntries, permissionEntries, plan, add, unsupported);
-            break;
-        default:
-            if (toolEntries.length > 0) {
-                unsupported("tools", `${h}: no verified primary-process tool availability mapping`);
-            }
-            if (permissionEntries.length > 0) {
-                unsupported("permissions", `${h}: no verified primary-process permission policy mapping`);
-            }
-    }
-    if (modes && Object.keys(modes).length > 0) {
-        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";',
-        `const enabledTools = Object.freeze(${JSON.stringify(enabledTools)});`,
-        `const excludedTools = Object.freeze(${JSON.stringify(excludedTools)});`,
-        "",
-        "function failProfile(message) {",
-        "  try {",
-        '    writeSync(2, "Pi profile execution controls failed: " + message + "\\n");',
-        "  } finally {",
-        "    process.exit(78);",
-        "  }",
-        "}",
-        "",
-        "function resolveTool(reference, available, required) {",
-        "  if (available.includes(reference)) return reference;",
-        "  const folded = reference.toLowerCase();",
-        "  const matches = available.filter((name) => name.toLowerCase() === folded);",
-        "  if (matches.length === 1) return matches[0];",
-        "  if (matches.length > 1) {",
-        "    failProfile('tool \"' + reference + '\" is ambiguous: ' + matches.join(\", \"));",
-        "  }",
-        "  if (required) {",
-        "    failProfile('requested tool \"' + reference + '\" is unavailable');",
-        "  }",
-        "  return undefined;",
-        "}",
-        "",
-        "function applyControls(pi) {",
-        "  const available = pi.getAllTools().map((tool) => tool.name);",
-        "  for (const reference of excludedTools) {",
-        "    const remaining = resolveTool(reference, available, false);",
-        "    if (remaining !== undefined) {",
-        "      failProfile(",
-        "        'excluded tool \"' + reference + '\" remains available as \"' + remaining +",
-        "        '\"; pass its exact registered Pi name',",
-        "      );",
-        "    }",
-        "  }",
-        "  const enabled = enabledTools.map((name) =>",
-        "    resolveTool(name, available, true),",
-        "  );",
-        "  const active = new Set(pi.getActiveTools());",
-        "  for (const name of enabled) active.add(name);",
-        "  pi.setActiveTools([...active]);",
-        "}",
-        "",
-        "export default function applyProfileExecutionControls(pi) {",
-        '  pi.on("before_agent_start", () => applyControls(pi));',
-        '  pi.on("turn_start", () => applyControls(pi));',
-        "}",
-        "",
-    ].join("\n");
-}
-import { resolveNativeWebTools } from "@tangle-network/agent-interface";
-import { CLAUDE_CODE_NATIVE_PERMISSION_IDS, CLAUDE_CODE_NATIVE_TOOL_IDS, claudePermissionRules, claudeToolName, mapSupportedBooleanEntries, mapSupportedPermissionEntries, normalizedControlName, OPENCODE_NATIVE_PERMISSION_IDS, OPENCODE_NATIVE_TOOL_IDS, openCodeDeclaredMcpPermissionName, openCodePermissionName, openCodeToolName, PI_EXECUTION_CONTROL_EXTENSION_PATH, permissionAllowsEverything, piToolId, sealClaudePermissionRules, } from "./control-maps.js";
-import { CLAUDE_SETTINGS_PATH, OPENCODE_CONFIG_FILE, OPENCODE_CONFIG_SCHEMA, } from "./harness.js";
-import { registerClaudeSettings } from "./hooks.js";
-import { serializeWorkspacePlanJson } from "./plan-json.js";
-import { compareStrings } from "./workspace-files.js";

package/dist/harness-prompt.d.ts

@@ -1,22 +0,0 @@
-import type { AgentProfile } from "@tangle-network/agent-interface";
-import type { HarnessId } from "./harness.js";
-/** Keep controlled Codex launches on declared tools, not account apps or plugins. */
-export declare const CODEX_DISABLED_FEATURE_ARGS: readonly string[];
-/**
- * Whether a run keeps the harness's own system prompt, so that a host's
- * environment context joins the profile's addition instead of replacing the
- * harness prompt.
- *
- * A profile that declares prompt intent (`prompt.instructions` or
- * `prompt.appendSystemPrompt`) without `prompt.systemPrompt` asked for the
- * harness prompt to stay in force: that is what `appendSystemPrompt` means.
- * A host that replaced it with its own template would delete exactly what the
- * profile kept. Every Discovery research director ran under the
- * sandbox's app-builder template this way: claude-code through
- * `--system-prompt`, opencode through a generated primary agent.
- */
-export declare function keepsHarnessSystemPrompt(profile: AgentProfile | undefined, harness: HarnessId | string | undefined): boolean;
-/** Join prompt additions in order, skipping empty ones. */
-export declare function joinSystemPromptAdditions(...additions: Array<string | undefined>): string | undefined;
-/** Native inline context has a bounded argument; long context belongs in resources.files. */
-export declare function codexDeveloperInstructionArgs(value: string | undefined, flags?: readonly string[]): string[];

package/dist/harness-prompt.js

@@ -1,64 +0,0 @@
-/** Keep controlled Codex launches on declared tools, not account apps or plugins. */
-export const CODEX_DISABLED_FEATURE_ARGS = [
-    "apps",
-    "plugins",
-].flatMap((feature) => ["-c", `features.${feature}=false`]);
-/**
- * Harnesses whose adapter can carry a host's environment context as an
- * ADDITION to the harness's own system prompt:
- *
- * - claude-code and pi: `--append-system-prompt`.
- * - opencode: the addition file that opencode.json names in `instructions`
- *   (OPENCODE_APPEND_SYSTEM_PROMPT_FILE). OpenCode's own prompt stays because
- *   no profile primary agent replaces it.
- * - codex: `developer_instructions`, which codex sends after its own base
- *   instructions.
- *
- * Every other harness keeps the host's replacement, unchanged.
- */
-const HARNESSES_WITH_ADDITIVE_HOST_PROMPT = new Set(["claude-code", "pi", "opencode", "codex"]);
-/**
- * Whether a run keeps the harness's own system prompt, so that a host's
- * environment context joins the profile's addition instead of replacing the
- * harness prompt.
- *
- * A profile that declares prompt intent (`prompt.instructions` or
- * `prompt.appendSystemPrompt`) without `prompt.systemPrompt` asked for the
- * harness prompt to stay in force: that is what `appendSystemPrompt` means.
- * A host that replaced it with its own template would delete exactly what the
- * profile kept. Every Discovery research director ran under the
- * sandbox's app-builder template this way: claude-code through
- * `--system-prompt`, opencode through a generated primary agent.
- */
-export function keepsHarnessSystemPrompt(profile, harness) {
-    const prompt = profile?.prompt;
-    if (!profile || prompt?.systemPrompt !== undefined)
-        return false;
-    return (HARNESSES_WITH_ADDITIVE_HOST_PROMPT.has(harness ?? "") &&
-        ((prompt?.instructions?.length ?? 0) > 0 ||
-            prompt?.appendSystemPrompt !== undefined ||
-            (harness === "codex" && profile.resources?.instructions !== undefined)));
-}
-/** Join prompt additions in order, skipping empty ones. */
-export function joinSystemPromptAdditions(...additions) {
-    const parts = additions.map((addition) => addition?.trim()).filter(Boolean);
-    return parts.join("\n\n") || undefined;
-}
-/** Native inline context has a bounded argument; long context belongs in resources.files. */
-export function codexDeveloperInstructionArgs(value, flags = []) {
-    if (value === undefined)
-        return [];
-    if (flags.some((flag, index) => {
-        const selector = ["-c", "--config"].includes(flags[index - 1] ?? "")
-            ? flag
-            : /^(?:--config=|-c=?)(.+)$/su.exec(flag)?.[1];
-        return (selector &&
-            /^(?:developer_instructions\s*=|["'])/u.test(selector.trimStart()));
-    }))
-        throw new Error("Codex context conflicts with a caller configuration override; put developer_instructions in the AgentProfile and use unquoted configuration keys");
-    const encoded = `developer_instructions=${JSON.stringify(value)}`;
-    // This is the adapter's portable inline budget, not an OS capacity claim.
-    if (Buffer.byteLength(encoded, "utf8") > 64 * 1024)
-        throw new Error("Codex inline context is too large; move long context into profile.resources.files and keep prompt.instructions short");
-    return ["-c", encoded];
-}