@tangle-network/agent-profile-materialize 0.15.1 → 0.16.0

package/dist/prime-profile.js

@@ -0,0 +1,284 @@
+const PRIME_SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const PRIME_MAX_SKILL_NAME_LENGTH = 64;
+export const PRIME_PROFILE_DIR_NAME = "profile";
+export const PRIME_SKILLS_DIR_NAME = "skills";
+export const PRIME_SYSTEM_PROMPT_FILE = "system-prompt.md";
+export const PRIME_APPEND_SYSTEM_PROMPT_FILE = "append-system-prompt.md";
+/** Agent-dir global context file the fork reads (resource-loader.ts:59,86). */
+export const PRIME_CONTEXT_FILE = "AGENTS.md";
+/** Fork continual-harness store location under the agent dir (refinement.ts:269-279). */
+export const PRIME_HARNESS_DIR_NAME = "harness";
+export const PRIME_HARNESS_STATE_FILE = "harness_state.json";
+export const PRIME_HARNESS_KINDS = [
+    "prompt",
+    "memory",
+    "skill",
+    "subagent",
+];
+/**
+ * Provenance marker for entries pinned from the profile. Stale removal keys on
+ * it, so agent-written (`source: "agent"`) and user-written entries are never
+ * touched.
+ */
+export const PRIME_PROFILE_ENTRY_SOURCE = "profile";
+/**
+ * Provenance markers written by executors that predate this shared lowering.
+ *
+ * Pruning keys on the source tag, so an executor that switches to the shared
+ * implementation would otherwise leave its own earlier entries behind forever:
+ * they match no current profile and no current source, and the model's
+ * spawnable roster silently accumulates duplicates of every subagent. They are
+ * adopted (pruned or replaced) on the first shared run instead.
+ */
+export const PRIME_LEGACY_PROFILE_ENTRY_SOURCES = [
+    "cli-bridge-profile",
+];
+/** True when the controls materialize anything at all. */
+export function hasPrimeProfileMaterial(controls) {
+    return (controls.systemPrompt !== undefined ||
+        controls.appendSystemPrompt !== undefined ||
+        primeProfileNeedsAgentDir(controls) ||
+        controls.skills.length > 0);
+}
+/**
+ * True when the controls must WRITE INTO the agent dir itself.
+ *
+ * Prompt files and skill dirs are named by a flag, so they can live anywhere
+ * the agent can read (`--system-prompt` / `--append-system-prompt` resolve a
+ * path when it exists, fork resource-loader.ts:41-56; `--skill` takes an
+ * arbitrary dir, :437-442). The context file and the continual-harness store
+ * are located BY the agent dir and have no flag, so they cannot move.
+ *
+ * An executor pointed at an agent dir it does not own (an operator's shared
+ * dir) uses this to refuse exactly the controls it would have to write there,
+ * while still binding the ones it can materialize elsewhere.
+ */
+export function primeProfileNeedsAgentDir(controls) {
+    return controls.instructions !== undefined || controls.subagents.length > 0;
+}
+/**
+ * Read one instruction block, which the profile may carry inline or as a
+ * resource ref. Only inline refs are accepted: resolving a GitHub-backed ref
+ * fetches remote content, which is `resolveAgentProfileResources`' job and
+ * must happen before a profile reaches an executor.
+ */
+function primeInstructionBlock(value, control) {
+    if (typeof value === "string")
+        return value;
+    if (value.kind === "inline")
+        return value.content;
+    rejectPrimeControl(control, "only inline resource refs are accepted — resolve GitHub-backed refs " +
+        "(resolveAgentProfileResources) before handing the profile to this lowering.");
+}
+/**
+ * Validate and extract the profile controls the prime agent-dir lowering
+ * materializes. Throws {@link PrimeProfileError} on any control (or control
+ * facet) the fork has no verified read path for — partial acceptance would
+ * silently drop the rest.
+ */
+export function readPrimeProfileControls(profile) {
+    const controls = { skills: [], subagents: [] };
+    if (!profile)
+        return controls;
+    if (profile.harness !== undefined && profile.harness !== "prime") {
+        rejectPrimeDeclaration("harness", `prime cannot run a profile pinned to harness "${profile.harness}" — ` +
+            'only "prime" (or an unset harness preference) is accepted.');
+    }
+    // An entry with `enabled: false` is OFF, not requested. A fully disabled map
+    // asks for nothing, so accepting it drops no control — which is the only
+    // thing this refusal exists to prevent.
+    const requestedMcp = Object.keys(activeMcpServers(profile.mcp));
+    if (requestedMcp.length > 0) {
+        rejectPrimeControl(`mcp: ${requestedMcp.join(", ")}`, PRIME_MCP_UNSUPPORTED_REASON);
+    }
+    if (profile.connections !== undefined) {
+        rejectPrimeControl("connections", `a hub connection grant resolves to MCP tools, and ${PRIME_MCP_UNSUPPORTED_REASON}`);
+    }
+    if (profile.permissions !== undefined) {
+        rejectPrimeControl("permissions", "prime-agent exposes no permission control at all (full flag scan of fork " +
+            "cli/args.ts:93-295; native tools run unconditionally), so a permission map " +
+            "would be accepted and never enforced.");
+    }
+    if (profile.tools !== undefined) {
+        rejectPrimeControl("tools", "the only per-run tool control is `--tools` over the single builtin `ipython` " +
+            "(fork cli/args.ts:63-64,156-167); bash/edit and the rest are extension-provided " +
+            "and not addressable per run, so a harness-neutral tool map cannot bind to it.");
+    }
+    if (profile.hooks !== undefined) {
+        rejectPrimeControl("hooks", "prime-agent has no hook mechanism (fork cli/args.ts flag scan; extensions are " +
+            "host-trusted JS modules loaded into the agent process, not caller command hooks).");
+    }
+    if (profile.modes !== undefined) {
+        rejectPrimeControl("modes", "prime-agent has no mode concept (fork cli/args.ts flag scan).");
+    }
+    if (profile.confidential !== undefined) {
+        rejectPrimeControl("confidential", "confidential execution is a property of the executor's isolation boundary, not " +
+            "of the agent dir; this lowering cannot establish it.");
+    }
+    const instructionBlocks = [];
+    if (profile.prompt) {
+        const { systemPrompt, appendSystemPrompt, instructions } = profile.prompt;
+        const knownPromptFields = new Set([
+            "systemPrompt",
+            "appendSystemPrompt",
+            "instructions",
+        ]);
+        const unknown = Object.entries(profile.prompt)
+            .filter(([key, value]) => !knownPromptFields.has(key) && value !== undefined)
+            .map(([key]) => key);
+        if (unknown.length > 0) {
+            rejectPrimeControl(`prompt fields: ${unknown.join(", ")}`, "no verified prime-agent read path exists for them.");
+        }
+        if (systemPrompt !== undefined) {
+            if (typeof systemPrompt !== "string" || systemPrompt.trim() === "") {
+                rejectPrimeDeclaration("prompt.systemPrompt", "an empty replacement would delete the built-in system prompt and " +
+                    "install nothing.");
+            }
+            controls.systemPrompt = systemPrompt;
+        }
+        if (appendSystemPrompt !== undefined) {
+            if (typeof appendSystemPrompt !== "string" ||
+                appendSystemPrompt.trim() === "") {
+                rejectPrimeDeclaration("prompt.appendSystemPrompt", "must be non-empty text.");
+            }
+            controls.appendSystemPrompt = appendSystemPrompt;
+        }
+        for (const block of instructions ?? []) {
+            if (typeof block === "string" && block.trim() !== "")
+                instructionBlocks.push(block);
+        }
+    }
+    if (profile.resources) {
+        const { skills, instructions, failOnError, ...unsupported } = profile.resources;
+        const rejectedKeys = Object.entries(unsupported)
+            .filter(([, value]) => value !== undefined)
+            .map(([key]) => key);
+        if (rejectedKeys.length > 0) {
+            rejectPrimeControl(`resources: ${rejectedKeys.join(", ")}`, "only resources.skills (--skill dirs, fork resource-loader.ts:437-442) and " +
+                "resources.instructions (agent-dir AGENTS.md, resource-loader.ts:86) have a " +
+                "verified prime-agent read path. Generic workspace files, tool files, " +
+                "subagent-definition files and prompt templates either have no headless read " +
+                "path or would run caller-authored code inside the agent process.");
+        }
+        if (failOnError === false) {
+            rejectPrimeControl("resources.failOnError: false", "this lowering always fails loud on a resource it cannot " +
+                "materialize; lenient materialization is not implemented.");
+        }
+        if (instructions !== undefined) {
+            const block = primeInstructionBlock(instructions, "resources.instructions");
+            if (block.trim() !== "")
+                instructionBlocks.push(block);
+        }
+        const seen = new Set();
+        for (const [index, ref] of (skills ?? []).entries()) {
+            if (ref.kind !== "inline") {
+                rejectPrimeControl(`resources.skills[${index}]`, "only inline skill refs are accepted — resolve GitHub-backed refs " +
+                    "(resolveAgentProfileResources) before handing the profile to " +
+                    "this lowering.");
+            }
+            const name = ref.name;
+            if (!PRIME_SKILL_NAME_RE.test(name) ||
+                name.length > PRIME_MAX_SKILL_NAME_LENGTH) {
+                rejectPrimeDeclaration(`resources.skills[${index}]`, `name ${JSON.stringify(name)} is not a valid prime skill name — it becomes the ` +
+                    "skill directory name, so it must be lowercase a-z0-9 with single hyphens, at " +
+                    `most ${PRIME_MAX_SKILL_NAME_LENGTH} chars (fork skills.ts:122-147).`);
+            }
+            if (seen.has(name)) {
+                rejectPrimeDeclaration("resources.skills", `declares ${JSON.stringify(name)} twice; duplicate skill names collide in the ` +
+                    "fork's skill registry, which keeps only the first and warns.");
+            }
+            seen.add(name);
+            if (ref.content.trim() === "") {
+                rejectPrimeDeclaration(`resources.skills[${index}]`, `skill ${JSON.stringify(name)} declares no content.`);
+            }
+            controls.skills.push({ name, content: ref.content });
+        }
+    }
+    if (instructionBlocks.length > 0) {
+        controls.instructions = instructionBlocks.join("\n\n");
+    }
+    if (profile.subagents) {
+        const usedIds = new Map();
+        for (const [name, spec] of Object.entries(profile.subagents)) {
+            if (name.trim() === "") {
+                rejectPrimeDeclaration("subagents", "a subagent name must be non-empty.");
+            }
+            const inexpressible = [
+                ["model", spec.model],
+                ["tools", spec.tools],
+                ["permissions", spec.permissions],
+                ["maxSteps", spec.maxSteps],
+            ]
+                .filter(([, value]) => value !== undefined)
+                .map(([key]) => key);
+            if (inexpressible.length > 0) {
+                rejectPrimeControl(`subagents[${JSON.stringify(name)}] fields: ${inexpressible.join(", ")}`, "a prime continual-harness subagent spec is prompt-roster " +
+                    "guidance for `await rlm('<task>')` (fork refinement.ts:483-496) " +
+                    "and pins no model, tool set, permission, or step budget on the " +
+                    "spawned child.");
+            }
+            if (!spec.description?.trim() && !spec.prompt?.trim()) {
+                rejectPrimeDeclaration(`subagents[${JSON.stringify(name)}]`, "declares no behavior — a spec needs a description and/or prompt, since an " +
+                    "empty entry gives the model an empty roster line.");
+            }
+            const id = primeSubagentEntryId(name);
+            const clash = usedIds.get(id);
+            if (clash !== undefined) {
+                rejectPrimeDeclaration(`subagents[${JSON.stringify(name)}]`, `collides with subagent ${JSON.stringify(clash)} on harness-state id ` +
+                    `${JSON.stringify(id)}.`);
+            }
+            usedIds.set(id, name);
+            controls.subagents.push({
+                name,
+                description: spec.description,
+                prompt: spec.prompt,
+                metadata: spec.metadata,
+            });
+        }
+    }
+    return controls;
+}
+/**
+ * Refuse a run whose selected model disagrees with the profile's own.
+ *
+ * One authority per run: a profile names the model it was written and scored
+ * against, so running it on a different one silently scores a different agent.
+ * Both sides go through {@link modelIdsMatch}, so the qualification level a
+ * caller happened to use is not a conflict.
+ *
+ * `provider` is the executor's PROVIDER SELECTION, and is compared only when
+ * the executor's provider is part of model identity. An executor whose
+ * provider key is merely a namespace inside the agent dir passes it as
+ * undefined and gets the model-name comparison alone.
+ */
+export function assertPrimeModelAgreement(profile, selected) {
+    const declared = profile?.model?.default;
+    const declaredProvider = profile?.model?.provider;
+    if (declared !== undefined) {
+        const selectedId = qualifyModelId(selected.provider, selected.model);
+        const declaredId = qualifyModelId(declaredProvider, declared);
+        if (!modelIdsMatch(selectedId, declaredId, selected.provider)) {
+            rejectPrimeDeclaration("model.default", `the run selects ${JSON.stringify(selectedId)} but the profile names ` +
+                `${JSON.stringify(declaredId)}; a profile must not be scored against a model it ` +
+                "does not name.");
+        }
+        return;
+    }
+    if (selected.provider !== undefined &&
+        declaredProvider !== undefined &&
+        declaredProvider !== selected.provider) {
+        rejectPrimeDeclaration("model.provider", `the run selects provider ${JSON.stringify(selected.provider)} but the profile names ` +
+            `${JSON.stringify(declaredProvider)}.`);
+    }
+}
+/** Deterministic harness-state entry id for a profile subagent name. */
+export function primeSubagentEntryId(name) {
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return `profile-${slug || "subagent"}`;
+}
+import { modelIdsMatch, qualifyModelId } from "./model-id.js";
+import { PRIME_MCP_UNSUPPORTED_REASON, rejectPrimeControl, rejectPrimeDeclaration, } from "./prime-fork.js";
+import { activeMcpServers } from "./profile-support.js";

package/dist/profile-materializer.d.ts

@@ -0,0 +1,12 @@
+import type { AgentProfile, AgentProfileSecretProvider } from "@tangle-network/agent-interface";
+import { type HarnessId } from "./harness.js";
+import { type BindableLaunchControl, type SkippableDimension, type WorkspacePlan } from "./plan-types.js";
+export declare const UNAVAILABLE_AGENT_PROFILE_SECRET_PROVIDER: AgentProfileSecretProvider;
+/**
+ * Build a pure workspace plan for one canonical harness.
+ * The caller applies files, environment, and flags at its process boundary.
+ */
+export declare function materializeProfile(inputProfile: AgentProfile, harness: HarnessId, opts?: {
+    skip?: SkippableDimension[];
+    binds?: readonly BindableLaunchControl[];
+}): WorkspacePlan;

package/dist/profile-materializer.js

@@ -0,0 +1,59 @@
+import { agentProfileSchema } from "@tangle-network/agent-interface";
+import { materializeExecutionControls } from "./execution-controls.js";
+import { assertMaterializerHarness } from "./harness.js";
+import { materializeHooks } from "./hooks.js";
+import { materializeMcp } from "./mcp.js";
+import { assertBindableLaunchControls, assertSkippableDimensions, } from "./plan-types.js";
+import { createProfilePlanBuilder } from "./profile-plan.js";
+import { lowerProfilePrompt } from "./profile-prompt.js";
+import { activeMcpServers, extensionNamespaces } from "./profile-support.js";
+import { lowerProfileCommands, lowerProfileResources, lowerProfileSkills, } from "./resource-lowering.js";
+import { materializeSubagent } from "./subagents.js";
+export const UNAVAILABLE_AGENT_PROFILE_SECRET_PROVIDER = Object.freeze({
+    async get() {
+        return undefined;
+    },
+});
+/**
+ * Build a pure workspace plan for one canonical harness.
+ * The caller applies files, environment, and flags at its process boundary.
+ */
+export function materializeProfile(inputProfile, harness, opts = {}) {
+    assertMaterializerHarness(harness);
+    const profile = agentProfileSchema.parse(inputProfile);
+    const skip = new Set(assertSkippableDimensions(opts.skip));
+    const binds = assertBindableLaunchControls(opts.binds);
+    const builder = createProfilePlanBuilder(harness);
+    lowerProfileResources(profile, harness, builder);
+    lowerProfilePrompt(profile, harness, binds, builder);
+    materializeExecutionControls(harness, profile.tools, profile.permissions, profile.modes, builder.plan, builder.add, builder.unsupported);
+    if ((profile.connections?.length ?? 0) > 0) {
+        builder.unsupported("connections", `${harness}: Hub connections must be resolved to authorized MCP servers by the execution runtime`);
+    }
+    if (profile.confidential !== undefined) {
+        builder.unsupported("confidential", `${harness}: confidential execution requires runtime placement and attestation, not workspace files`);
+    }
+    lowerProfileSkills(profile, harness, builder);
+    const mcp = activeMcpServers(profile.mcp);
+    if (!skip.has("mcp") && Object.keys(mcp).length > 0) {
+        materializeMcp(harness, mcp, builder.plan, builder.add, builder.unsupported);
+    }
+    const hooks = profile.hooks ?? {};
+    if (Object.keys(hooks).length > 0) {
+        materializeHooks(harness, hooks, builder.add, builder.unsupported, builder.plan);
+    }
+    const subagents = profile.subagents ?? {};
+    for (const [name, subagent] of Object.entries(subagents)) {
+        materializeSubagent(harness, name, subagent, builder.plan, builder.add, builder.unsupported);
+    }
+    if (!skip.has("extensions")) {
+        for (const namespace of extensionNamespaces(harness)) {
+            const extension = profile.extensions?.[namespace];
+            if (extension && Object.keys(extension).length > 0) {
+                builder.unsupported("extensions", `${harness}: extension namespace "${namespace}" requires provider-native handling`);
+            }
+        }
+    }
+    lowerProfileCommands(profile, harness, builder);
+    return builder.finalize(profile.resources?.failOnError);
+}

package/dist/profile-plan.d.ts

@@ -0,0 +1,14 @@
+import type { AgentProfileConfigValue } 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";
+export interface ProfilePlanBuilder {
+    plan: WorkspacePlan;
+    add: AddPlanFile;
+    addExplicitResource: AddExplicitResource;
+    unsupported: (dimension: Unsupported["dimension"], reason: string) => void;
+    finalize: (failOnError?: boolean) => WorkspacePlan;
+}
+export type AddExplicitResource = (dimension: Unsupported["dimension"], path: string, content: string, mode?: number) => void;
+export declare function createProfilePlanBuilder(harness: HarnessId): ProfilePlanBuilder;
+export declare function setPlanEnvironment(plan: WorkspacePlan, name: string, value: string | AgentProfileConfigValue): void;

package/dist/profile-plan.js

@@ -0,0 +1,86 @@
+import { MATERIALIZER_OWNED_PATHS } from "./harness.js";
+import { workspacePlanConfigValue } from "./plan-json.js";
+import { mergeJsonFiles } from "./plan-normalize.js";
+import { formatUnsupported } from "./plan-support.js";
+import { compareStrings, normalizeWorkspaceRelativePath, PRIVATE_FILE_MODE, validateFileMode, } from "./workspace-files.js";
+export function createProfilePlanBuilder(harness) {
+    const plan = {
+        harness,
+        files: [],
+        env: {},
+        flags: [],
+        unsupported: [],
+        requires: [],
+    };
+    const pushPlanFile = (relPath, serialized, source, mode) => {
+        const normalizedPath = normalizeWorkspaceRelativePath(relPath);
+        const content = typeof serialized === "string" ? serialized : serialized.content;
+        const secretSlots = typeof serialized === "string" ? undefined : serialized.secretSlots;
+        const fileMode = mode ??
+            (secretSlots !== undefined && secretSlots.length > 0
+                ? PRIVATE_FILE_MODE
+                : undefined);
+        plan.files.push({
+            relPath: normalizedPath,
+            content,
+            source,
+            ...(source === "generated" && MATERIALIZER_OWNED_PATHS.has(normalizedPath)
+                ? { ownership: "materializer" }
+                : {}),
+            ...(fileMode === undefined ? {} : { mode: validateFileMode(fileMode) }),
+            ...(secretSlots === undefined
+                ? {}
+                : {
+                    secretSlots: secretSlots.map((slot) => ({
+                        path: [...slot.path],
+                        ref: { ...slot.ref },
+                    })),
+                }),
+        });
+    };
+    const add = (relPath, content, mode) => pushPlanFile(relPath, content, "generated", mode);
+    const unsupported = (dimension, reason) => plan.unsupported.push({ dimension, reason });
+    const explicitResourcePaths = new Map();
+    const addExplicitResource = (dimension, relPath, content, mode) => {
+        const normalizedPath = normalizeWorkspaceRelativePath(relPath);
+        const previousDimension = explicitResourcePaths.get(normalizedPath);
+        if (previousDimension) {
+            throw new Error(`Duplicate profile resource path: ${normalizedPath} (${previousDimension}, ${dimension})`);
+        }
+        if (MATERIALIZER_OWNED_PATHS.has(normalizedPath)) {
+            throw new Error(`Profile resource path is reserved by the materializer: ${normalizedPath} (${dimension}). ` +
+                "This package writes that path itself and replaces it on re-application, so a mount " +
+                "there cannot survive; choose another path.");
+        }
+        explicitResourcePaths.set(normalizedPath, dimension);
+        pushPlanFile(normalizedPath, content, "user", mode);
+    };
+    return {
+        plan,
+        add,
+        addExplicitResource,
+        unsupported,
+        finalize(failOnError) {
+            for (const [relPath, dimension] of explicitResourcePaths) {
+                const writers = plan.files.filter((file) => file.relPath === relPath).length;
+                if (writers > 1) {
+                    throw new Error(`Profile ${dimension} resource conflicts with generated harness file: ${relPath}`);
+                }
+            }
+            plan.files = mergeJsonFiles(plan.files).sort((a, b) => compareStrings(a.relPath, b.relPath));
+            if (failOnError && plan.unsupported.length) {
+                throw new Error(formatUnsupported(plan.unsupported));
+            }
+            return plan;
+        },
+    };
+}
+export function setPlanEnvironment(plan, name, value) {
+    const normalized = typeof value === "string" ? value : workspacePlanConfigValue(value);
+    const previous = plan.env[name];
+    if (previous !== undefined &&
+        JSON.stringify(previous) !== JSON.stringify(normalized)) {
+        throw new Error(`profile environment values disagree for ${name}`);
+    }
+    plan.env[name] = normalized;
+}

package/dist/profile-prompt.d.ts

@@ -0,0 +1,4 @@
+import type { AgentProfile } from "@tangle-network/agent-interface";
+import type { BindableLaunchControl, HarnessId } from "./plan-types.js";
+import type { ProfilePlanBuilder } from "./profile-plan.js";
+export declare function lowerProfilePrompt(profile: AgentProfile, harness: HarnessId, binds: ReadonlySet<BindableLaunchControl>, builder: ProfilePlanBuilder): void;

package/dist/profile-prompt.js

@@ -0,0 +1,105 @@
+import { appendSystemPromptRefusal, CODEX_SYSTEM_PROMPT_FILE, CONTEXT_FILE, OPENCODE_APPEND_SYSTEM_PROMPT_FILE, OPENCODE_PRIMARY_AGENT_PREFIX, systemPromptRefusal, } from "./harness.js";
+import { sha256 } from "./plan-digest.js";
+import { serializeWorkspacePlanJson } from "./plan-json.js";
+export function lowerProfilePrompt(profile, harness, binds, builder) {
+    const { plan, add, unsupported } = builder;
+    if (profile.prompt?.systemPrompt !== undefined) {
+        if (harness === "claude-code" || harness === "pi" || harness === "prime") {
+            plan.systemPrompt = profile.prompt.systemPrompt;
+        }
+        else if (harness === "codex") {
+            add(CODEX_SYSTEM_PROMPT_FILE, profile.prompt.systemPrompt);
+            plan.flags.push("-c", `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}`);
+        }
+        else if (harness === "gemini") {
+            add(".gemini/system.md", profile.prompt.systemPrompt);
+            plan.env.GEMINI_SYSTEM_MD = "1";
+        }
+        else if (harness === "opencode") {
+            const systemPrompt = profile.prompt.systemPrompt;
+            if (systemPrompt.trim().length === 0) {
+                throw new Error("opencode cannot express an empty exact system-prompt replacement");
+            }
+            if (binds.has("opencode.agent-prompt")) {
+                plan.systemPromptBinding = {
+                    intent: "replace",
+                    control: "opencode.agent-prompt",
+                    systemPrompt,
+                };
+            }
+            else if (binds.has("systemPrompt")) {
+                const primaryAgentName = `${OPENCODE_PRIMARY_AGENT_PREFIX}${sha256(systemPrompt).slice(0, 16)}`;
+                const primaryAgentPath = `.opencode/agents/${primaryAgentName}.md`;
+                if (profile.subagents?.[primaryAgentName] !== undefined) {
+                    throw new Error(`opencode: subagent name "${primaryAgentName}" is reserved for the profile primary agent`);
+                }
+                plan.systemPrompt = systemPrompt;
+                add(primaryAgentPath, ["---", "mode: primary", "---", systemPrompt, ""].join("\n"));
+                plan.flags.push("--agent", primaryAgentName);
+            }
+            else {
+                unsupported("systemPrompt", systemPromptRefusal(harness));
+            }
+        }
+        else {
+            unsupported("systemPrompt", systemPromptRefusal(harness));
+        }
+    }
+    const openCodeInstructionFiles = [];
+    const openCodeConfigUnreachable = harness === "opencode" && binds.has("opencode.agent-prompt");
+    if (profile.prompt?.appendSystemPrompt !== undefined) {
+        const appendSystemPrompt = profile.prompt.appendSystemPrompt;
+        if (appendSystemPrompt.trim().length === 0) {
+            throw new Error("prompt.appendSystemPrompt must be non-empty text");
+        }
+        if (openCodeConfigUnreachable) {
+            unsupported("appendSystemPrompt", "opencode: the launcher that binds opencode.agent-prompt composes opencode's config itself and loads no workspace opencode.json, so an addition registered there would never reach the model; compose it into the launcher's own instructions[]");
+        }
+        else if (harness === "opencode") {
+            add(OPENCODE_APPEND_SYSTEM_PROMPT_FILE, appendSystemPrompt.endsWith("\n")
+                ? appendSystemPrompt
+                : `${appendSystemPrompt}\n`);
+            openCodeInstructionFiles.push(OPENCODE_APPEND_SYSTEM_PROMPT_FILE);
+        }
+        else if (harness === "claude-code" ||
+            harness === "pi" ||
+            harness === "prime") {
+            plan.appendSystemPrompt = appendSystemPrompt;
+        }
+        else {
+            unsupported("appendSystemPrompt", appendSystemPromptRefusal(harness));
+        }
+    }
+    const instructions = [];
+    if (profile.prompt?.instructions?.length) {
+        instructions.push(...profile.prompt.instructions);
+    }
+    const resourceInstructions = profile.resources?.instructions;
+    if (typeof resourceInstructions === "string") {
+        instructions.push(resourceInstructions);
+    }
+    else if (resourceInstructions && resourceInstructions.kind === "inline") {
+        instructions.push(resourceInstructions.content);
+    }
+    else if (resourceInstructions) {
+        unsupported("instructions", "instruction ref is not inline (github refs need async pre-resolution)");
+    }
+    if (instructions.length) {
+        if (openCodeConfigUnreachable) {
+            unsupported("instructions", "opencode: the launcher that binds opencode.agent-prompt composes opencode's config itself and loads no workspace opencode.json, so an instruction file registered there would never reach the model; compose it into the launcher's own instructions[]");
+        }
+        else {
+            const instructionPath = CONTEXT_FILE[harness];
+            add(instructionPath, `${instructions.join("\n\n")}\n`);
+            if (harness === "opencode") {
+                openCodeInstructionFiles.push(instructionPath);
+            }
+        }
+    }
+    if (openCodeInstructionFiles.length > 0) {
+        add("opencode.json", serializeWorkspacePlanJson({
+            $schema: "https://opencode.ai/config.json",
+            instructions: openCodeInstructionFiles,
+        }));
+    }
+}

package/dist/profile-support.d.ts

@@ -0,0 +1,8 @@
+import type { AgentProfile, AgentProfileMcpServer } from "@tangle-network/agent-interface";
+import type { HarnessId } from "./harness.js";
+type ActiveAgentProfileMcpServer = Exclude<AgentProfileMcpServer, {
+    enabled: false;
+}>;
+export declare function activeMcpServers(servers: AgentProfile["mcp"]): Record<string, ActiveAgentProfileMcpServer>;
+export declare function extensionNamespaces(harness: HarnessId): string[];
+export {};

package/dist/profile-support.js

@@ -0,0 +1,6 @@
+export function activeMcpServers(servers) {
+    return Object.fromEntries(Object.entries(servers ?? {}).filter((entry) => entry[1].enabled !== false));
+}
+export function extensionNamespaces(harness) {
+    return [harness];
+}

package/dist/resource-lowering.d.ts

@@ -0,0 +1,7 @@
+import type { AgentProfile } from "@tangle-network/agent-interface";
+import type { HarnessId } from "./harness.js";
+import type { ProfilePlanBuilder } from "./profile-plan.js";
+export declare function lowerProfileResources(profile: AgentProfile, harness: HarnessId, builder: ProfilePlanBuilder): void;
+export declare function lowerProfileSkills(profile: AgentProfile, harness: HarnessId, builder: ProfilePlanBuilder): void;
+export declare function lowerProfileCommands(profile: AgentProfile, harness: HarnessId, builder: ProfilePlanBuilder): void;
+export declare function agentResourceDirectory(harness: HarnessId): string | null;