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

package/dist/workspace-apply.js

@@ -1,4 +1,8 @@
-export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDir, options, publicPlanDigest = hashWorkspacePlan(publicPlan)) {
+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)) {
         throw new Error("ApplyWorkspacePlanOptions.agentDir must be absolute");
@@ -9,11 +13,6 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         throw new Error("Workspace plan contains agent-root files but ApplyWorkspacePlanOptions.agentDir is missing");
     }
     const rootFor = (root) => root === "workspace" ? workspaceRoot : agentRoot;
-    const fileIdentity = (file) => `${file.root}\0${file.relPath}`;
-    const receiptFile = (file) => ({
-        root: file.root,
-        relPath: file.relPath,
-    });
     const runtimeOnlyFiles = new Set((options.runtimeOnlyFiles ?? []).map(normalizeWorkspaceRelativePath));
     const ownership = validateWorkspaceOwnership(options.ownership);
     const privateFilePaths = new Set(publicFiles.filter((file) => file.secretSlots.length > 0).map(fileIdentity));
@@ -21,6 +20,43 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
     if (existingFiles !== "allow-identical" && existingFiles !== "reject") {
         throw new Error(`Unsupported existing workspace file policy: ${existingFiles}`);
     }
+    return {
+        rootFor,
+        runtimeOnlyFiles,
+        ownership,
+        privateFilePaths,
+        existingFiles,
+    };
+}
+// A prior application of this exact plan makes the workspace live agent
+// state. Preserve changed and removed files. Refresh private generated files
+// because the public digest excludes secret values, and repair unchanged
+// materializer files that still have the writer's ownership.
+function selectResumeFiles(files, ownership, privateFilePaths) {
+    return files.filter((file) => {
+        if (file.ownership !== "materializer")
+            return false;
+        assertNoSymlinkPathComponents(file.rootDir, file.absPath);
+        if (!workspaceFileExists(file.absPath))
+            return false;
+        const matches = workspaceFileMatches(file);
+        const hasCurrentOwnership = holdsCurrentOwnership(file.absPath, ownership);
+        if (privateFilePaths.has(fileIdentity(file))) {
+            return !matches || !hasCurrentOwnership;
+        }
+        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
         .filter((file) => file.root === "workspace" && runtimeOnlyFiles.has(file.relPath))
@@ -32,78 +68,28 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         rootDir: rootFor(file.root),
         absPath: resolveWorkspaceFilePath(rootFor(file.root), file.relPath),
     }));
-    // A prior application of this exact plan makes the workspace live agent
-    // state. Preserve changed and removed files. Refresh private generated files
-    // because the public digest excludes secret values, and repair unchanged
-    // materializer files that still have the writer's ownership. `reject` does
-    // not use this path because it requires an empty target.
+    // `reject` does not resume because it requires an empty target.
     const resumeSamePlan = existingFiles === "allow-identical" &&
         options.appliedPlanDigest !== undefined &&
         options.appliedPlanDigest === publicPlanDigest;
     const filesToApply = resumeSamePlan
-        ? files.filter((file) => {
-            if (file.ownership !== "materializer")
-                return false;
-            assertNoSymlinkPathComponents(file.rootDir, file.absPath);
-            if (!workspaceFileExists(file.absPath))
-                return false;
-            const matches = workspaceFileMatches(file);
-            const hasCurrentOwnership = ownership === undefined ||
-                workspaceFileHasOwnership(file.absPath, ownership);
-            if (privateFilePaths.has(fileIdentity(file))) {
-                return !matches || !hasCurrentOwnership;
-            }
-            return matches && !hasCurrentOwnership;
-        })
+        ? selectResumeFiles(files, ownership, privateFilePaths)
         : files;
     if (resumeSamePlan && filesToApply.length === 0) {
         return {
             receipt: safeWorkspacePlanReceipt(publicPlan, files.map(receiptFile), publicPlanDigest),
-            spawn: {
-                env: { ...resolvedPlan.env },
-                flags: [...resolvedPlan.flags],
-                ...promptIntentFields(resolvedPlan, samePromptIntentValue),
-                ...systemPromptBindingField(resolvedPlan),
-            },
+            spawn: spawnFor(resolvedPlan),
             runtimeOnlyFiles: privateRuntimeFiles,
         };
     }
-    // An owned path holds this package's own earlier output, so re-applying
-    // into the same workspace replaces it rather than failing the turn — once
-    // the bytes already there prove that provenance. The replacement keeps what
-    // an agent appended below a generated context file (its memory), so it can
-    // differ from the planned bytes. `reject` still refuses: that policy is
-    // "nothing may pre-exist here", which is a statement about the workspace,
-    // not authorship.
-    const plannedContent = new Map(filesToApply.map((file) => [fileIdentity(file), file.content]));
-    const replacement = (file) => {
-        const planned = plannedContent.get(fileIdentity(file));
-        if (existingFiles !== "allow-identical" ||
-            file.ownership !== "materializer" ||
-            planned === undefined) {
-            return undefined;
-        }
-        return materializerReplacement(file.relPath, () => regularFileContent(file.absPath), planned);
+    const context = {
+        rootFor,
+        existingFiles,
+        ownership,
+        publicPlanDigest,
+        plannedContent: new Map(filesToApply.map((file) => [fileIdentity(file), file.content])),
     };
-    // Validate the complete plan before the first write so a late traversal or
-    // existing symlink cannot leave a partially materialized workspace.
-    const writes = [];
-    for (const file of filesToApply) {
-        assertNoSymlinkPathComponents(file.rootDir, file.absPath);
-        if (!workspaceFileExists(file.absPath)) {
-            writes.push(file);
-            continue;
-        }
-        const content = replacement(file);
-        if (content !== undefined) {
-            writes.push({ ...file, content });
-            continue;
-        }
-        if (existingFiles === "reject" || !workspaceFileMatches(file)) {
-            throw new Error(workspaceFileConflictMessage(file, existingFiles, publicPlanDigest));
-        }
-        writes.push(file);
-    }
+    const writes = planWrites(filesToApply, context);
     // Parent directories remain on failure because they may contain concurrent
     // workspace state that this call does not own.
     for (const file of writes) {
@@ -113,137 +99,17 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         assertNoSymlinkPathComponents(file.rootDir, file.absPath);
     }
     const prepared = [];
-    // Prepared temp links stay alive through publication and rollback. Their
-    // inodes distinguish files created here from concurrent replacements.
     try {
-        for (const file of writes) {
-            if (existingFiles === "allow-identical" &&
-                workspaceFileExists(file.absPath) &&
-                workspaceFileMatches(file) &&
-                (file.ownership !== "materializer" ||
-                    ownership === undefined ||
-                    workspaceFileHasOwnership(file.absPath, ownership))) {
-                continue;
-            }
-            prepared.push(prepareWorkspaceFile(file.rootDir, file, ownership));
-        }
-        for (const entry of prepared) {
-            assertNoSymlinkPathComponents(rootFor(entry.file.root), entry.file.absPath);
-            try {
-                linkSync(entry.temporaryPath, entry.file.absPath);
-                entry.published = true;
-            }
-            catch (error) {
-                if (isFsError(error, "EEXIST") &&
-                    existingFiles === "allow-identical" &&
-                    workspaceFileMatches(entry.file) &&
-                    (entry.file.ownership !== "materializer" ||
-                        ownership === undefined ||
-                        workspaceFileHasOwnership(entry.file.absPath, ownership))) {
-                    continue;
-                }
-                if (isFsError(error, "EEXIST") &&
-                    replacement(entry.file) === entry.file.content) {
-                    // The replacement is recomposed from the bytes there now, so an
-                    // agent append that landed since validation refuses below instead
-                    // of being overwritten; one landing between that read and the
-                    // rename is not detected.
-                    // rename() replaces in one step, so no window exists in which the
-                    // path is missing and a concurrent spawn reads nothing. The staged
-                    // inode moves onto the path, which is what rollback identifies the
-                    // file by, so an abort still removes exactly what this call
-                    // published — leaving the path ABSENT rather than restored to the
-                    // superseded bytes. That is the fail-closed direction: the harness
-                    // whose flag names a missing file refuses to start, whereas silently
-                    // restored previous-turn bytes would run the wrong prompt. A replaced
-                    // file that holds an agent's appended text is the exception: it is
-                    // linked aside first and restored, because removing it would delete
-                    // the agent's own text.
-                    assertNoSymlinkPathComponents(rootFor(entry.file.root), entry.file.absPath);
-                    if (entry.file.content !== plannedContent.get(fileIdentity(entry.file))) {
-                        const superseded = join(dirname(entry.file.absPath), `.agent-profile-${randomUUID()}.superseded`);
-                        linkSync(entry.file.absPath, superseded);
-                        entry.superseded = superseded;
-                    }
-                    renameSync(entry.temporaryPath, entry.file.absPath);
-                    entry.published = true;
-                    continue;
-                }
-                if (isFsError(error, "EEXIST")) {
-                    throw new Error(workspaceFileConflictMessage(entry.file, existingFiles, publicPlanDigest), { cause: error });
-                }
-                throw error;
-            }
-        }
+        publishWrites(writes, prepared, context);
     }
     catch (error) {
-        const cleanupErrors = [];
-        for (const entry of [...prepared].reverse()) {
-            try {
-                if (entry.published &&
-                    workspacePathHasIdentity(entry.file.absPath, entry.identity)) {
-                    if (entry.superseded) {
-                        renameSync(entry.superseded, entry.file.absPath);
-                    }
-                    else {
-                        unlinkSync(entry.file.absPath);
-                    }
-                }
-            }
-            catch (cleanupError) {
-                cleanupErrors.push(cleanupError);
-            }
-            try {
-                if (entry.superseded)
-                    unlinkSync(entry.superseded);
-            }
-            catch (cleanupError) {
-                if (!isFsError(cleanupError, "ENOENT"))
-                    cleanupErrors.push(cleanupError);
-            }
-            try {
-                if (workspacePathHasIdentity(entry.temporaryPath, entry.identity)) {
-                    unlinkSync(entry.temporaryPath);
-                }
-            }
-            catch (cleanupError) {
-                cleanupErrors.push(cleanupError);
-            }
-        }
-        if (cleanupErrors.length > 0) {
-            throw new AggregateError([error, ...cleanupErrors], "Failed to apply workspace plan and roll back published files");
-        }
-        throw error;
+        rollbackPublished(prepared, error);
     }
     const receipt = safeWorkspacePlanReceipt(publicPlan, files.map(receiptFile), publicPlanDigest);
-    const cleanupErrors = [];
-    const temporaryPaths = [];
-    for (const entry of prepared) {
-        for (const path of [entry.temporaryPath, entry.superseded]) {
-            if (path === undefined)
-                continue;
-            try {
-                unlinkSync(path);
-            }
-            catch (error) {
-                if (!isFsError(error, "ENOENT")) {
-                    cleanupErrors.push(error);
-                    temporaryPaths.push(path);
-                }
-            }
-        }
-    }
-    if (cleanupErrors.length > 0) {
-        throw new WorkspacePlanCleanupError(cleanupErrors, receipt, temporaryPaths);
-    }
+    removeTemporaries(prepared, receipt);
     return {
         receipt,
-        spawn: {
-            env: { ...resolvedPlan.env },
-            flags: [...resolvedPlan.flags],
-            ...promptIntentFields(resolvedPlan, samePromptIntentValue),
-            ...systemPromptBindingField(resolvedPlan),
-        },
+        spawn: spawnFor(resolvedPlan),
         runtimeOnlyFiles: privateRuntimeFiles,
     };
 }
@@ -264,13 +130,11 @@ function safeWorkspacePlanReceipt(plan, writtenFiles, workspacePlanDigest = hash
         writtenFiles: writtenFiles.map((file) => ({ ...file })),
     };
 }
-import { randomUUID } from "node:crypto";
-import { linkSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { materializerReplacement } from "./harness.js";
+import { mkdirSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
 import { hashWorkspacePlan } from "./plan-digest.js";
 import { normalizePlanFiles, normalizeWorkspacePlanArgument, } from "./plan-normalize.js";
 import { promptIntentFields, samePromptIntentValue, systemPromptBindingField, } from "./plan-prompt.js";
-import { WorkspacePlanCleanupError } from "./plan-types.js";
-import { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, } from "./workspace-apply-files.js";
+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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-profile-materialize",
-  "version": "0.27.1",
+  "version": "0.27.3",
   "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,12 +35,12 @@
     "@tangle-network/agent-interface": "^3.0.0 || ^4.0.0 || ^5.0.0"
   },
   "tangleRelease": {
-    "sourceSha": "5a536a79fbd83dfa11da194bf5348cf0d73f224d",
-    "mergedAt": "2026-10-21T05:59:51-06:00"
+    "sourceSha": "b66b40689425eb54bcb3c576be0ac54cf93770b1",
+    "mergedAt": "2026-10-23T18:31:26-06:00"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "check-types": "tsc --noEmit",
+    "check-types": "node ../../scripts/tsc-native.mjs --noEmit",
     "clean": "rm -rf dist",
     "test": "pnpm run test:installed-peer && pnpm run test:current-peer",
     "test:installed-peer": "vitest run",