@tangle-network/agent-profile-materialize 0.28.3 → 0.28.5

package/dist/managed-workspace-bind.js

@@ -1,4 +1,6 @@
 import { dirname, join } from "node:path";
+import { CODEX_SYSTEM_PROMPT_FILE } from "./harness.js";
+import { bindWorkspaceLaunchFlags } from "./workspace-launch.js";
 /**
  * Paths a secret OpenCode revision serves from its own immutable tree:
  * read-only profile content under `reference/`, skills, and OpenCode's
@@ -6,21 +8,6 @@ import { dirname, join } from "node:path";
  * `.opencode/{agent,agents}/**\/*.md` and `.opencode/{command,commands}/**\/*.md`).
  */
 const SECRET_REVISION_NATIVE_PATH = /^(?:reference\/|\.opencode\/skills\/|\.opencode\/(?:agents?|commands?)\/(?:[^./][^/]*\/)*[^./][^/]*\.md$)/u;
-/**
- * A secret OpenCode turn launches with its revision's `workspace` as cwd and
- * that tree's `.opencode` as its explicit config directory (the sealed launch
- * in sdk-provider-opencode). So skills, agents and commands load from the
- * digest-attested revision, and a cwd-relative `reference/` path resolves to
- * this revision's own read-only copy, never to the shared workspace that
- * concurrent revisions share. The binding stays limited to these paths, never
- * an app's own directory.
- */
-function ridesSecretRevision(plan, file, options) {
-    return (options.secretOpenCodeRevision === true &&
-        plan.harness === "opencode" &&
-        (file.root ?? "workspace") === "workspace" &&
-        SECRET_REVISION_NATIVE_PATH.test(file.relPath));
-}
 export function bindConcurrentLaunch(plan, application, revisionWorkspaceDir, options = {}) {
     if (plan.requires?.length) {
         throw new Error(`Concurrent ${plan.harness} profile needs a native extension that this launcher cannot attest`);
@@ -28,7 +15,7 @@ export function bindConcurrentLaunch(plan, application, revisionWorkspaceDir, op
     if (application.spawn.systemPromptBinding) {
         throw new Error(`Concurrent ${plan.harness} profile has an unbound system prompt control`);
     }
-    const flags = [...application.spawn.flags];
+    const flags = bindWorkspaceLaunchFlags(plan, application.spawn.flags, revisionWorkspaceDir);
     const env = { ...application.spawn.env };
     const supportedFiles = new Set();
     const bindFlagFile = (flag, relPath) => {
@@ -50,14 +37,11 @@ export function bindConcurrentLaunch(plan, application, revisionWorkspaceDir, op
             }
             break;
         case "codex":
-            if (plan.files.some((file) => file.relPath === ".codex/system-prompt.md")) {
-                const original = "model_instructions_file=.codex/system-prompt.md";
-                const index = flags.findIndex((value, at) => value === original && flags[at - 1] === "-c");
-                if (index < 0)
+            if (plan.files.some((file) => file.relPath === CODEX_SYSTEM_PROMPT_FILE)) {
+                if (!plan.flags.some((value, at) => value === `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}` &&
+                    plan.flags[at - 1] === "-c"))
                     throw new Error("Concurrent codex profile lacks model_instructions_file binding");
-                flags[index] =
-                    `model_instructions_file=${join(revisionWorkspaceDir, ".codex/system-prompt.md")}`;
-                supportedFiles.add(".codex/system-prompt.md");
+                supportedFiles.add(CODEX_SYSTEM_PROMPT_FILE);
             }
             break;
         // kimi-code has no case: kimi-code 2.x discovers MCP only from
@@ -91,7 +75,13 @@ export function bindConcurrentLaunch(plan, application, revisionWorkspaceDir, op
     // its directory, absolute in that revision, joins the launch PATH.
     const toolBinDirs = [];
     for (const file of plan.files) {
-        if (ridesSecretRevision(plan, file, options)) {
+        // Secret OpenCode launches from its immutable revision workspace, with
+        // that revision's .opencode as config directory. These relative native
+        // resources therefore read the revision, never the shared workspace.
+        if (options.secretOpenCodeRevision === true &&
+            plan.harness === "opencode" &&
+            (file.root ?? "workspace") === "workspace" &&
+            SECRET_REVISION_NATIVE_PATH.test(file.relPath)) {
             if (file.relPath.startsWith("reference/") &&
                 ((file.mode ?? 0) & 0o111) !== 0) {
                 const dir = join(revisionWorkspaceDir, dirname(file.relPath));

package/dist/managed-workspace-stage.js

@@ -4,6 +4,7 @@ import { basename, dirname, extname, join, resolve, sep } from "node:path";
 import { applyWorkspacePlanWithSecretProvider } from "./plan-application.js";
 import { hashWorkspacePlan } from "./plan-digest.js";
 import { normalizeWorkspaceRelativePath } from "./workspace-files.js";
+import { bindWorkspaceLaunchFlags } from "./workspace-launch.js";
 export function assertPrivateManagedRoot(root) {
     if (!root || resolve(root) !== root) {
         throw new Error("Managed workspace root must be an absolute path");
@@ -88,7 +89,10 @@ export async function prepareManagedWorkspacePlan(plan, managedRoot, sharedWorks
             sha256: createHash("sha256").update(content).digest("hex"),
         }));
         const spawnDigest = createHash("sha256")
-            .update(JSON.stringify(application.spawn))
+            .update(JSON.stringify({
+            ...application.spawn,
+            flags: bindWorkspaceLaunchFlags(plan, application.spawn.flags),
+        }))
             .digest("hex");
         const materializedDigest = `sha256:${createHash("sha256")
             .update(JSON.stringify({

package/dist/managed-workspace.js

@@ -94,7 +94,14 @@ export async function preparePublicConcurrentProfileRevision(input) {
         return {
             directory,
             manifest: prepared.manifest,
-            application: { ...prepared.application, spawn },
+            application: {
+                ...prepared.application,
+                receipt: {
+                    ...prepared.application.receipt,
+                    flags: [...spawn.flags],
+                },
+                spawn,
+            },
         };
     }
     catch (error) {

package/dist/workspace-apply.js

@@ -1,7 +1,3 @@
-const receiptFile = (file) => ({
-    root: file.root,
-    relPath: file.relPath,
-});
 function readApplyInput(publicPlan, workspaceDir, options) {
     const workspaceRoot = resolve(workspaceDir);
     if (options.agentDir !== undefined && !isAbsolute(options.agentDir)) {
@@ -47,27 +43,42 @@ function selectResumeFiles(files, ownership, privateFilePaths) {
         return matches && !hasCurrentOwnership;
     });
 }
-function spawnFor(resolvedPlan) {
-    return {
-        env: { ...resolvedPlan.env },
-        flags: [...resolvedPlan.flags],
-        ...promptIntentFields(resolvedPlan, samePromptIntentValue),
-        ...systemPromptBindingField(resolvedPlan),
-    };
-}
 export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDir, options, publicPlanDigest = hashWorkspacePlan(publicPlan)) {
     const { rootFor, runtimeOnlyFiles, ownership, privateFilePaths, existingFiles, } = readApplyInput(publicPlan, workspaceDir, options);
-    const resolvedFiles = resolvedPlan.files;
-    const privateRuntimeFiles = Object.fromEntries(resolvedFiles
+    const privateRuntimeFiles = Object.fromEntries(resolvedPlan.files
         .filter((file) => file.root === "workspace" && runtimeOnlyFiles.has(file.relPath))
         .map((file) => [file.relPath, file.content]));
-    const files = resolvedFiles
+    const files = resolvedPlan.files
         .filter((file) => file.root !== "workspace" || !runtimeOnlyFiles.has(file.relPath))
         .map((file) => ({
         ...file,
         rootDir: rootFor(file.root),
         absPath: resolveWorkspaceFilePath(rootFor(file.root), file.relPath),
     }));
+    const application = {
+        receipt: {
+            workspacePlanDigest: publicPlanDigest,
+            env: Object.fromEntries(Object.entries(publicPlan.env).map(([name, value]) => [
+                name,
+                typeof value === "string" ? value : { ...value },
+            ])),
+            flags: bindWorkspaceLaunchFlags(publicPlan, publicPlan.flags, workspaceDir).map(normalizeWorkspacePlanArgument),
+            ...promptIntentFields(publicPlan, samePromptIntentValue),
+            ...systemPromptBindingField(publicPlan),
+            unsupported: publicPlan.unsupported.map((entry) => ({ ...entry })),
+            written: files
+                .filter((file) => file.root === "workspace")
+                .map((file) => file.relPath),
+            writtenFiles: files.map(({ root, relPath }) => ({ root, relPath })),
+        },
+        spawn: {
+            env: { ...resolvedPlan.env },
+            flags: bindWorkspaceLaunchFlags(publicPlan, resolvedPlan.flags, workspaceDir),
+            ...promptIntentFields(resolvedPlan, samePromptIntentValue),
+            ...systemPromptBindingField(resolvedPlan),
+        },
+        runtimeOnlyFiles: privateRuntimeFiles,
+    };
     // `reject` does not resume because it requires an empty target.
     const resumeSamePlan = existingFiles === "allow-identical" &&
         options.appliedPlanDigest !== undefined &&
@@ -76,11 +87,7 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         ? selectResumeFiles(files, ownership, privateFilePaths)
         : files;
     if (resumeSamePlan && filesToApply.length === 0) {
-        return {
-            receipt: safeWorkspacePlanReceipt(publicPlan, files.map(receiptFile), publicPlanDigest),
-            spawn: spawnFor(resolvedPlan),
-            runtimeOnlyFiles: privateRuntimeFiles,
-        };
+        return application;
     }
     const context = {
         rootFor,
@@ -94,8 +101,6 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
     // workspace state that this call does not own.
     for (const file of writes) {
         mkdirSync(dirname(file.absPath), { recursive: true });
-    }
-    for (const file of writes) {
         assertNoSymlinkPathComponents(file.rootDir, file.absPath);
     }
     const prepared = [];
@@ -105,30 +110,8 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
     catch (error) {
         rollbackPublished(prepared, error);
     }
-    const receipt = safeWorkspacePlanReceipt(publicPlan, files.map(receiptFile), publicPlanDigest);
-    removeTemporaries(prepared, receipt);
-    return {
-        receipt,
-        spawn: spawnFor(resolvedPlan),
-        runtimeOnlyFiles: privateRuntimeFiles,
-    };
-}
-function safeWorkspacePlanReceipt(plan, writtenFiles, workspacePlanDigest = hashWorkspacePlan(plan)) {
-    return {
-        workspacePlanDigest,
-        env: Object.fromEntries(Object.entries(plan.env).map(([name, value]) => [
-            name,
-            typeof value === "string" ? value : { ...value },
-        ])),
-        flags: plan.flags.map(normalizeWorkspacePlanArgument),
-        ...promptIntentFields(plan, samePromptIntentValue),
-        ...systemPromptBindingField(plan),
-        unsupported: plan.unsupported.map((entry) => ({ ...entry })),
-        written: writtenFiles
-            .filter((file) => file.root === "workspace")
-            .map((file) => file.relPath),
-        writtenFiles: writtenFiles.map((file) => ({ ...file })),
-    };
+    removeTemporaries(prepared, application.receipt);
+    return application;
 }
 import { mkdirSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
@@ -138,3 +121,4 @@ import { promptIntentFields, samePromptIntentValue, systemPromptBindingField, }
 import { assertNoSymlinkPathComponents, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileExists, workspaceFileMatches, } from "./workspace-apply-files.js";
 import { fileIdentity, holdsCurrentOwnership, planWrites, publishWrites, removeTemporaries, rollbackPublished, } from "./workspace-apply-publish.js";
 import { normalizeWorkspaceRelativePath } from "./workspace-files.js";
+import { bindWorkspaceLaunchFlags } from "./workspace-launch.js";

package/dist/workspace-launch.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspacePlan } from "./plan-types.js";
+/** Bind launch paths; omit the workspace to hash portable content identity. */
+export declare function bindWorkspaceLaunchFlags<T>(plan: WorkspacePlan, flags: readonly T[], workspaceDir?: string): (T | string)[];

package/dist/workspace-launch.js

@@ -0,0 +1,13 @@
+import { resolve } from "node:path";
+import { CODEX_SYSTEM_PROMPT_FILE } from "./harness.js";
+import { tomlStr } from "./plan-json.js";
+/** Bind launch paths; omit the workspace to hash portable content identity. */
+export function bindWorkspaceLaunchFlags(plan, flags, workspaceDir) {
+    return flags.map((flag, at) => plan.harness === "codex" &&
+        plan.flags[at - 1] === "-c" &&
+        plan.flags[at] === `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}`
+        ? workspaceDir === undefined
+            ? `model_instructions_file=${CODEX_SYSTEM_PROMPT_FILE}`
+            : `model_instructions_file=${tomlStr(resolve(workspaceDir, CODEX_SYSTEM_PROMPT_FILE))}`
+        : flag);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-profile-materialize",
-  "version": "0.28.3",
+  "version": "0.28.5",
   "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": {
@@ -35,8 +35,8 @@
     "@tangle-network/agent-interface": "^3.0.0 || ^4.0.0 || ^5.0.0"
   },
   "tangleRelease": {
-    "sourceSha": "24a394c180d411cd9a0d639b32cbf4d2f128458d",
-    "mergedAt": "2026-10-26T11:23:55-06:00"
+    "sourceSha": "02fcaa7cdd12f1cea201a8e929a7772232549e3e",
+    "mergedAt": "2026-10-26T14:54:59-06:00"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",