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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-profile-materialize",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Materialize an AgentProfile into the native per-harness workspace files (the one shared materializer for cli-bridge, agent-container, and VB).",
   "type": "module",
   "repository": {
@@ -28,18 +28,20 @@
     "@tangle-network/agent-interface": "5.10.2",
     "@tangle-network/agent-interface-current": "npm:@tangle-network/agent-interface@5.10.2",
     "@types/node": "25.6.0",
+    "tsdown": "0.21.10",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.12"
+    "vitest": "^4.1.12",
+    "@tangle-network/runtime-contracts": "0.20.0"
   },
   "peerDependencies": {
     "@tangle-network/agent-interface": "^5.10.2"
   },
   "tangleRelease": {
-    "sourceSha": "317182be2d49d5ca117256b3c807d12ad023a844",
-    "mergedAt": "2026-10-29T05:44:32-06:00"
+    "sourceSha": "5d3675ef9b9b3fc222fc3b5a8cfeedab71aa174a",
+    "mergedAt": "2026-10-29T17:18:52-06:00"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsdown",
     "check-types": "node ../../scripts/tsc-native.mjs --noEmit",
     "clean": "rm -rf dist",
     "test": "pnpm run test:installed-peer && pnpm run test:current-peer",

package/dist/candidate-types.d.ts

@@ -1,36 +0,0 @@
-export interface AgentCandidateWorkspacePlan {
-    sourceProfileDigest: Sha256Digest;
-    harness: HarnessId;
-    files: PlanFile[];
-    env: Record<string, AgentCandidateConfigValue>;
-    flags: AgentCandidateConfigValue[];
-    systemPrompt?: AgentCandidateConfigValue;
-    appendSystemPrompt?: AgentCandidateConfigValue;
-    unsupported: Unsupported[];
-}
-export interface AgentCandidateWorkspacePlanReceipt {
-    profileActivation: AgentCandidateProfileActivation;
-    application: AgentCandidateProfileApplication;
-    env: Record<string, AgentCandidateConfigValue>;
-    flags: AgentCandidateConfigValue[];
-    systemPrompt?: AgentCandidateConfigValue;
-    appendSystemPrompt?: AgentCandidateConfigValue;
-    unsupported: Unsupported[];
-}
-export interface ApplyAgentCandidateWorkspacePlanOptions {
-    /** Absolute private agent directory required by agent-root plan files. */
-    agentDir?: string;
-}
-export interface MaterializeCandidateProfileOptions {
-    /** Exact text fetched from pinned resource refs, keyed by declared SHA-256. */
-    resolvedResources?: ReadonlyMap<Sha256Digest, string>;
-    /**
-     * Launcher controls this caller owns and will bind itself. The declaration
-     * is forwarded to the classic materializer so candidate execution uses the
-     * same lowering as ordinary profile execution.
-     */
-    binds?: readonly BindableLaunchControl[];
-}
-import type { AgentCandidateConfigValue, AgentCandidateProfileActivation, AgentCandidateProfileApplication, Sha256Digest } from "@tangle-network/agent-interface";
-import type { HarnessId } from "./harness.js";
-import type { BindableLaunchControl, PlanFile, Unsupported } from "./plan-types.js";

package/dist/candidate-types.js

@@ -1 +0,0 @@
-export {};

package/dist/candidate.d.ts

@@ -1,9 +0,0 @@
-import type { AgentCandidateProfile, AgentCandidateProfileApplication } from "@tangle-network/agent-interface";
-import type { AgentCandidateWorkspacePlan, AgentCandidateWorkspacePlanReceipt, ApplyAgentCandidateWorkspacePlanOptions, MaterializeCandidateProfileOptions } from "./candidate-types.js";
-import type { HarnessId } from "./harness.js";
-export declare function materializeCandidateProfile(profile: AgentCandidateProfile, harness: HarnessId, opts?: MaterializeCandidateProfileOptions): AgentCandidateWorkspacePlan;
-/**
- * Apply a candidate plan and return its spawn values together with captured
- * canonical evidence. No caller needs to re-serialize or reinterpret the plan.
- */
-export declare function applyAgentCandidateWorkspacePlan(plan: AgentCandidateWorkspacePlan, workspaceDir: string, targetWorkspace: AgentCandidateProfileApplication["targetWorkspace"], options?: ApplyAgentCandidateWorkspacePlanOptions): AgentCandidateWorkspacePlanReceipt;

package/dist/candidate.js

@@ -1,283 +0,0 @@
-import { createHash } from "node:crypto";
-import { agentCandidateProfileActivationSchema, agentCandidateProfileSchema, canonicalCandidateDigest, } from "@tangle-network/agent-interface";
-import { assertMaterializerHarness } from "./harness.js";
-import { hookWrapperSource } from "./hooks.js";
-import { applyWorkspacePlan } from "./plan-application.js";
-import { captureAgentCandidateProfilePlan } from "./plan-digest.js";
-import { normalizePlanFiles } from "./plan-normalize.js";
-import { promptIntentFields, samePromptIntentValue } from "./plan-prompt.js";
-import { assertWorkspacePlanSupported } from "./plan-support.js";
-import { materializeProfile } from "./profile-materializer.js";
-import { compareStrings } from "./workspace-files.js";
-export function materializeCandidateProfile(profile, harness, opts = {}) {
-    assertMaterializerHarness(harness);
-    const candidate = agentCandidateProfileSchema.parse(profile);
-    verifyCandidateInlineResources(candidate);
-    const hookLowering = lowerCandidateHooks(candidate.hooks, harness);
-    const candidateResources = candidate.resources
-        ? candidateResourcesForClassicMaterializer(candidate.resources, opts.resolvedResources)
-        : {};
-    candidateResources.files = [
-        ...(candidateResources.files ?? []),
-        ...hookLowering.wrapperFiles,
-    ];
-    const classicProfile = {
-        ...candidate,
-        resources: candidateResources,
-        mcp: candidateMcpRecordForClassicMaterializer(candidate.mcp),
-        hooks: hookLowering.hooks,
-    };
-    const classicPlan = materializeProfile(classicProfile, harness, {
-        binds: opts.binds,
-        ...(harness === "pi" ? { instructionsRoot: "agent" } : {}),
-    });
-    // Canonical candidate evidence has no field for a launcher-addressed binding.
-    // Refuse that shape instead of returning a candidate plan whose receipt would
-    // omit the exact control still owed by the launcher.
-    if (classicPlan.systemPromptBinding !== undefined) {
-        throw new Error(`Sealed candidate evidence cannot represent a system-prompt binding to ${classicPlan.systemPromptBinding.control}`);
-    }
-    if (hookLowering.unsupportedReason) {
-        classicPlan.unsupported.push({
-            dimension: "hooks",
-            reason: hookLowering.unsupportedReason,
-        });
-    }
-    classicPlan.unsupported.sort((left, right) => compareStrings(`${left.dimension}\0${left.reason}`, `${right.dimension}\0${right.reason}`));
-    assertWorkspacePlanSupported(classicPlan);
-    return {
-        sourceProfileDigest: canonicalCandidateDigest(candidate),
-        harness: classicPlan.harness,
-        files: classicPlan.files,
-        env: candidatePublicRecord(classicPlan.env),
-        flags: classicPlan.flags.map(candidatePublicArgument),
-        ...promptIntentFields(classicPlan, candidatePublicValue),
-        unsupported: classicPlan.unsupported,
-    };
-}
-/**
- * Apply a candidate plan and return its spawn values together with captured
- * canonical evidence. No caller needs to re-serialize or reinterpret the plan.
- */
-export function applyAgentCandidateWorkspacePlan(plan, workspaceDir, targetWorkspace, options = {}) {
-    assertWorkspacePlanSupported(plan);
-    const profilePlan = captureAgentCandidateProfilePlan(plan);
-    const activationFiles = normalizePlanFiles(plan.files).map((file) => ({
-        path: file.relPath,
-        mode: file.mode,
-        content: file.content,
-    }));
-    const activationMaterial = {
-        kind: "agent-candidate-profile-activation",
-        profilePlan,
-        files: activationFiles,
-    };
-    const profileActivation = agentCandidateProfileActivationSchema.parse({
-        ...activationMaterial,
-        digest: canonicalCandidateDigest(activationMaterial),
-    });
-    const applied = applyWorkspacePlan({
-        harness: plan.harness,
-        files: plan.files,
-        env: Object.fromEntries(Object.entries(plan.env).map(([name, value]) => [
-            name,
-            candidatePublicString(value),
-        ])),
-        flags: plan.flags.map(candidatePublicString),
-        ...promptIntentFields(plan, candidatePublicString),
-        unsupported: plan.unsupported,
-    }, workspaceDir, { agentDir: options.agentDir });
-    return {
-        profileActivation,
-        application: {
-            planDigest: profilePlan.digest,
-            targetWorkspace,
-            // The candidate execution-plan contract lists workspace mounts here.
-            // Agent-root placement remains explicit in profile-plan material.files.
-            mountPaths: applied.written,
-        },
-        env: { ...plan.env },
-        flags: [...plan.flags],
-        ...promptIntentFields(plan, samePromptIntentValue),
-        unsupported: [...plan.unsupported],
-    };
-}
-function lowerCandidateHooks(hooks, harness) {
-    if (!hooks || Object.keys(hooks).length === 0)
-        return { wrapperFiles: [] };
-    const nativeHarness = harness;
-    if (nativeHarness !== "codex" && nativeHarness !== "claude-code") {
-        return {
-            wrapperFiles: [],
-            unsupportedReason: `${nativeHarness} hook configuration requires an unverified command-string mapping; ` +
-                "sealed candidate hooks preserve executable, argv, and env separately",
-        };
-    }
-    const wrapperFiles = [];
-    const lowered = {};
-    for (const [event, commands] of Object.entries(hooks)) {
-        lowered[event] = commands.map((command, index) => {
-            const wrapper = candidateHookWrapper(event, index, command);
-            wrapperFiles.push({
-                path: wrapper.path,
-                resource: {
-                    kind: "inline",
-                    name: wrapper.path,
-                    content: wrapper.content,
-                },
-            });
-            return {
-                command: `node ${wrapper.path}`,
-                timeoutMs: command.timeoutMs,
-                blocking: command.blocking,
-                matcher: command.matcher,
-            };
-        });
-    }
-    return { hooks: lowered, wrapperFiles };
-}
-function candidateHookWrapper(event, index, command) {
-    const args = (command.args ?? []).map(candidatePublicString);
-    const env = Object.fromEntries(Object.entries(command.env ?? {})
-        .sort(([left], [right]) => compareStrings(left, right))
-        .map(([name, value]) => [name, candidatePublicString(value)]));
-    const wrapperId = canonicalCandidateDigest({
-        event,
-        index,
-        executable: command.executable,
-        args,
-        env,
-        timeoutMs: command.timeoutMs ?? null,
-        blocking: command.blocking ?? null,
-        matcher: command.matcher ?? null,
-    }).slice("sha256:".length);
-    const path = `.tangle/profile-hooks/${wrapperId}.mjs`;
-    const content = hookWrapperSource(command.executable, args, env);
-    return { path, content };
-}
-function candidateMcpRecordForClassicMaterializer(servers) {
-    if (!servers)
-        return undefined;
-    return Object.fromEntries(Object.entries(servers)
-        .filter((entry) => entry[1].enabled !== false)
-        .map(([name, server]) => [
-        name,
-        candidateMcpForClassicMaterializer(server),
-    ]));
-}
-function candidateMcpForClassicMaterializer(server) {
-    return {
-        command: server.command,
-        ...(server.transport === undefined ? {} : { transport: server.transport }),
-        ...(server.args === undefined
-            ? {}
-            : {
-                args: server.args.map((value) => profilePublicValue(candidatePublicString(value))),
-            }),
-        ...(server.env === undefined
-            ? {}
-            : {
-                env: Object.fromEntries(Object.entries(server.env).map(([name, value]) => [
-                    name,
-                    profilePublicValue(candidatePublicString(value)),
-                ])),
-            }),
-        ...(server.cwd === undefined ? {} : { cwd: server.cwd }),
-    };
-}
-function candidateResourcesForClassicMaterializer(resources, resolvedResources) {
-    const convert = (ref) => {
-        if (ref.kind === "inline") {
-            return { kind: "inline", name: ref.name, content: ref.content };
-        }
-        const content = resolvedResources?.get(ref.sha256);
-        if (content !== undefined) {
-            verifyCandidateResourceBytes(ref, content, ref.name ?? ref.path);
-            return {
-                kind: "inline",
-                name: ref.name ?? ref.path.split("/").at(-1) ?? "resource",
-                content,
-            };
-        }
-        return {
-            kind: "github",
-            repository: `${ref.repository.owner}/${ref.repository.repo}`,
-            path: ref.path,
-            ref: ref.commit,
-            name: ref.name,
-        };
-    };
-    return {
-        ...resources,
-        files: resources.files?.map((mount) => ({
-            path: mount.path,
-            resource: convert(mount.resource),
-            executable: mount.executable,
-        })),
-        tools: resources.tools?.map(convert),
-        skills: resources.skills?.map(convert),
-        agents: resources.agents?.map(convert),
-        commands: resources.commands?.map(convert),
-        instructions: typeof resources.instructions === "string"
-            ? resources.instructions
-            : resources.instructions
-                ? convert(resources.instructions)
-                : undefined,
-        // The candidate wrapper owns the complete unsupported check after it adds
-        // dimensions that the classic materializer cannot represent.
-        failOnError: false,
-    };
-}
-function candidatePublicString(value) {
-    if (value.kind !== "public") {
-        throw new Error("Candidate materialization accepts public config values only");
-    }
-    return value.value;
-}
-function candidatePublicValue(value) {
-    return { kind: "public", value };
-}
-function profilePublicValue(value) {
-    return { kind: "public", value };
-}
-function candidatePublicArgument(value) {
-    if (typeof value !== "string") {
-        throw new Error("Candidate materialization cannot emit private launch arguments");
-    }
-    return candidatePublicValue(value);
-}
-function candidatePublicRecord(values) {
-    return Object.fromEntries(Object.entries(values).map(([name, value]) => {
-        if (typeof value !== "string") {
-            throw new Error("Candidate materialization cannot emit private environment values");
-        }
-        return [name, candidatePublicValue(value)];
-    }));
-}
-function verifyCandidateInlineResources(profile) {
-    const resources = profile.resources;
-    if (!resources)
-        return;
-    const refs = [
-        ...(resources.files?.map((mount) => mount.resource) ?? []),
-        ...(resources.tools ?? []),
-        ...(resources.skills ?? []),
-        ...(resources.agents ?? []),
-        ...(resources.commands ?? []),
-        ...(typeof resources.instructions === "object"
-            ? [resources.instructions]
-            : []),
-    ];
-    for (const ref of refs) {
-        if (ref.kind !== "inline")
-            continue;
-        verifyCandidateResourceBytes(ref, ref.content, ref.name);
-    }
-}
-function verifyCandidateResourceBytes(ref, content, label) {
-    const bytes = Buffer.from(content, "utf8");
-    const digest = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
-    if (bytes.byteLength !== ref.byteLength || digest !== ref.sha256) {
-        throw new Error(`Candidate resource integrity mismatch: ${label}`);
-    }
-}

package/dist/commands.d.ts

@@ -1,2 +0,0 @@
-export declare function materializeCommand(h: HarnessId, name: string, body: string, add: (path: string, content: string, mode?: number) => void, unsupported: (d: Unsupported["dimension"], r: string) => void): void;
-import type { HarnessId, Unsupported } from "./plan-types.js";

package/dist/commands.js

@@ -1,32 +0,0 @@
-export function materializeCommand(h, name, body, add, unsupported) {
-    switch (h) {
-        case "claude-code":
-        case "nanoclaw":
-            add(`.claude/commands/${name}.md`, body.endsWith("\n") ? body : `${body}\n`);
-            break;
-        case "opencode":
-            add(`.opencode/commands/${name}.md`, body.endsWith("\n") ? body : `${body}\n`);
-            break;
-        case "gemini":
-            add(`.gemini/commands/${name}.toml`, `prompt = ${tomlStr(body)}\n`);
-            break;
-        case "pi":
-            add(`.pi/prompts/${name}.md`, body.endsWith("\n") ? body : `${body}\n`);
-            break;
-        case "prime":
-            // Auto-discovered project prompt templates: <cwd>/.prime/agent/prompts
-            // (fork prompt-templates.ts:218 resolves CONFIG_DIR_NAME "prompts";
-            // package-manager.ts:2176-2180 auto-adds the same projectDirs.prompts).
-            add(`.prime/agent/prompts/${name}.md`, body.endsWith("\n") ? body : `${body}\n`);
-            break;
-        case "kimi-code":
-            unsupported("commands", "kimi commands ARE skills (/skill:<name>) — provide as a skill instead");
-            break;
-        case "codex":
-            unsupported("commands", "codex project commands unsupported (~/.codex/prompts is user-global only)");
-            break;
-        default:
-            unsupported("commands", `${h}: no cwd command path`);
-    }
-}
-import { tomlStr } from "./plan-json.js";

package/dist/control-maps.d.ts

@@ -1,58 +0,0 @@
-export declare function normalizedControlName(name: string): string;
-/** Tool IDs accepted by Claude Code. */
-export declare const CLAUDE_CODE_NATIVE_TOOL_IDS: readonly string[];
-/** Permission IDs accepted by Claude Code (same as tool IDs). */
-export declare const CLAUDE_CODE_NATIVE_PERMISSION_IDS: readonly string[];
-export declare function claudeToolName(name: string): string | undefined;
-/** Tool IDs reported by the OpenCode binary shipped in the Sandbox image. */
-export declare const OPENCODE_NATIVE_TOOL_IDS: readonly ["apply_patch", "bash", "codesearch", "edit", "glob", "grep", "question", "read", "skill", "task", "todowrite", "webfetch", "websearch", "write"];
-/** Permission IDs accepted by OpenCode (tools except read, plus special permissions). */
-export declare const OPENCODE_NATIVE_PERMISSION_IDS: readonly ["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 declare function openCodeNativeToolId(name: string): string | undefined;
-export declare function openCodeToolName(name: string): string | undefined;
-export declare function openCodePermissionName(name: string): string | 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 declare function openCodeDeclaredMcpPermissionName(name: string, aliases: readonly string[]): string | undefined;
-export declare 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 declare function piToolId(name: string): string | undefined;
-/**
- * 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 declare function mapSupportedBooleanEntries(entries: [string, boolean][], mapName: (name: string) => string | undefined, onUnsupported: (name: string) => void): [string, boolean][];
-export declare function permissionAllowsEverything(policy: AgentProfilePermission): boolean;
-export declare function mapSupportedPermissionEntries(entries: [string, AgentProfilePermission][], mapName: (name: string) => string | undefined, onUnsupported: (name: string) => void, label: string): [string, AgentProfilePermission][];
-export declare function claudePermissionRules(entries: [string, AgentProfilePermission][]): {
-    allow: string[];
-    ask: string[];
-    deny: string[];
-};
-/**
- * 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 declare function sealClaudePermissionRules(rules: {
-    allow: string[];
-    ask: string[];
-    deny: string[];
-}): {
-    allow: string[];
-    ask: string[];
-    deny: string[];
-};
-import type { AgentProfilePermission } from "@tangle-network/agent-interface";