@tangle-network/agent-profile-materialize 0.17.1 → 0.17.3

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export type { HarnessId } from "./harness.js";
 export { HARNESS_SKILL_DIRS, harnessAutoLoadsContextFile, harnessContextFile, isMaterializerHarness, MATERIALIZER_HARNESSES, skillDirForHarness, } from "./harness.js";
 export type { OpenCodeMcpConfig } from "./mcp.js";
 export { openCodeMcpConfig } from "./mcp.js";
-export { modelIdsMatch, qualifyModelId } from "./model-id.js";
+export { modelIdsMatch, qualifyModelId, unqualifyModelId, } from "./model-id.js";
 export { buildPiModelsConfig, buildPiModelsConfigFile, PI_MODELS_CONFIG_PATH, type PiModelsConfigFile, type PiModelsConfigInput, } from "./pi-models-config.js";
 export { applyWorkspacePlan, applyWorkspacePlanWithSecretProvider, } from "./plan-application.js";
 export { agentCandidateProfilePlanMaterial, canonicalizeAgentCandidateProfilePlan, captureAgentCandidateProfilePlan, hashWorkspacePlan, } from "./plan-digest.js";

package/dist/index.js

@@ -3,7 +3,7 @@ export { applyAgentCandidateWorkspacePlan, materializeCandidateProfile, } from "
 export { OPENCODE_NATIVE_TOOL_IDS, openCodeNativeToolId, } from "./control-maps.js";
 export { HARNESS_SKILL_DIRS, harnessAutoLoadsContextFile, harnessContextFile, isMaterializerHarness, MATERIALIZER_HARNESSES, skillDirForHarness, } from "./harness.js";
 export { openCodeMcpConfig } from "./mcp.js";
-export { modelIdsMatch, qualifyModelId } from "./model-id.js";
+export { modelIdsMatch, qualifyModelId, unqualifyModelId, } from "./model-id.js";
 export { buildPiModelsConfig, buildPiModelsConfigFile, PI_MODELS_CONFIG_PATH, } from "./pi-models-config.js";
 export { applyWorkspacePlan, applyWorkspacePlanWithSecretProvider, } from "./plan-application.js";
 export { agentCandidateProfilePlanMaterial, canonicalizeAgentCandidateProfilePlan, captureAgentCandidateProfilePlan, hashWorkspacePlan, } from "./plan-digest.js";

package/dist/model-id.d.ts

@@ -26,6 +26,19 @@
  * `qualifyModelId(p, qualifyModelId(p, m)) === qualifyModelId(p, m)`.
  */
 export declare function qualifyModelId<T extends string | undefined>(provider: string | undefined, modelId: T): T;
+/**
+ * Remove one exact `provider/` qualification from `modelId`.
+ *
+ * This is the inverse operation for a model id that was qualified by this
+ * provider. It removes only the known outer prefix and preserves upstream
+ * segments such as `zai/glm-4.7`.
+ *
+ * The helper removes one outer qualification per call. It leaves missing
+ * providers and model ids unchanged.
+ */
+export declare function unqualifyModelId(provider: string | undefined, modelId: string): string;
+export declare function unqualifyModelId(provider: string | undefined, modelId: undefined): undefined;
+export declare function unqualifyModelId(provider: string | undefined, modelId: string | undefined): string | undefined;
 /**
  * Do two model ids name the same model?
  *

package/dist/model-id.js

@@ -32,6 +32,14 @@ export function qualifyModelId(provider, modelId) {
         return modelId;
     return `${provider}/${modelId}`;
 }
+export function unqualifyModelId(provider, modelId) {
+    if (!provider || !modelId)
+        return modelId;
+    const providerPrefix = `${provider}/`;
+    return modelId.startsWith(providerPrefix)
+        ? modelId.slice(providerPrefix.length)
+        : modelId;
+}
 /**
  * Do two model ids name the same model?
  *

package/dist/plan-types.d.ts

@@ -281,16 +281,21 @@ export declare class WorkspacePlanCleanupError extends AggregateError {
 export interface ApplyWorkspacePlanOptions {
     /** Plan files consumed in memory by the runtime and never persisted to cwd. */
     runtimeOnlyFiles?: readonly string[];
+    /** Own newly written workspace files as the process that will read them. */
+    ownership?: {
+        uid: number;
+        gid: number;
+    };
     /** Existing workspace paths are either exact idempotent inputs or forbidden. */
     existingFiles?: "allow-identical" | "reject";
     /**
      * `workspacePlanDigest` of a plan a prior call already applied into this
-     * workspace. When it equals this plan's digest, application writes no files:
-     * the workspace holds the running agent's live state, and a file the agent
-     * edited or removed since the prior application stays exactly as the agent
-     * left it. Env, flags, prompt intents, and the receipt are still produced.
-     * A different digest applies normally, so a plan that changed mid-session
-     * still meets the existing-file refusal.
+     * workspace. When it equals this plan's digest, application changes no file
+     * content. It can repair ownership on unchanged materializer-owned files.
+     * A file the agent edited or removed stays exactly as the agent left it.
+     * Env, flags, prompt intents, and the receipt are still produced. A different
+     * digest applies normally, so a changed plan still meets the existing-file
+     * refusal.
      */
     appliedPlanDigest?: string;
 }

package/dist/workspace-apply-files.d.ts

@@ -0,0 +1,50 @@
+declare function workspaceFileExists(pathValue: string): boolean;
+declare function regularFileContent(pathValue: string): string | undefined;
+declare function workspaceFileMatches(file: NormalizedPlanFile & {
+    absPath: string;
+}): boolean;
+declare function workspaceFileHasOwnership(pathValue: string, ownership: {
+    uid: number;
+    gid: number;
+}): boolean;
+declare function validateWorkspaceOwnership(ownership: ApplyWorkspacePlanOptions["ownership"]): {
+    uid: number;
+    gid: number;
+} | undefined;
+/**
+ * The refusal names what differs — planned versus existing content digest,
+ * mode, or file kind — plus the plan digest, so the operator can tell a
+ * mid-session profile swap from an agent-edited workspace file without
+ * reproducing the workspace. Reads here are best-effort diagnosis inside an
+ * already-failing path; an unreadable existing file is reported, not thrown
+ * over.
+ */
+declare function workspaceFileConflictMessage(file: NormalizedPlanFile & {
+    absPath: string;
+}, existingFiles: "allow-identical" | "reject", planDigest: string): string;
+interface WorkspaceFileIdentity {
+    device: number;
+    inode: number;
+}
+interface PreparedWorkspaceFile {
+    file: NormalizedPlanFile & {
+        absPath: string;
+    };
+    temporaryPath: string;
+    identity: WorkspaceFileIdentity;
+    published: boolean;
+}
+declare function prepareWorkspaceFile(workspaceRoot: string, file: NormalizedPlanFile & {
+    absPath: string;
+}, ownership: {
+    uid: number;
+    gid: number;
+} | undefined): PreparedWorkspaceFile;
+declare function workspacePathHasIdentity(pathValue: string, identity: WorkspaceFileIdentity): boolean;
+declare function resolveWorkspaceFilePath(workspaceRoot: string, relativePath: string): string;
+declare function assertNoSymlinkPathComponents(workspaceRoot: string, targetPath: string): void;
+declare function isFsError(error: unknown, code: string): error is NodeJS.ErrnoException;
+export type { PreparedWorkspaceFile };
+export { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, };
+import type { NormalizedPlanFile } from "./plan-normalize.js";
+import type { ApplyWorkspacePlanOptions } from "./plan-types.js";

package/dist/workspace-apply-files.js

@@ -0,0 +1,178 @@
+function workspaceFileExists(pathValue) {
+    try {
+        lstatSync(pathValue);
+        return true;
+    }
+    catch (error) {
+        if (isFsError(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+}
+function regularFileContent(pathValue) {
+    return lstatSync(pathValue).isFile()
+        ? readFileSync(pathValue, "utf8")
+        : undefined;
+}
+function workspaceFileMatches(file) {
+    const stats = lstatSync(file.absPath);
+    return (stats.isFile() &&
+        (stats.mode & 0o777) === file.mode &&
+        readFileSync(file.absPath, "utf8") === file.content);
+}
+function workspaceFileHasOwnership(pathValue, ownership) {
+    const stats = lstatSync(pathValue);
+    return (stats.isFile() && stats.uid === ownership.uid && stats.gid === ownership.gid);
+}
+function validateWorkspaceOwnership(ownership) {
+    if (ownership === undefined)
+        return undefined;
+    if (!Number.isInteger(ownership.uid) ||
+        ownership.uid < 0 ||
+        !Number.isInteger(ownership.gid) ||
+        ownership.gid < 0) {
+        throw new Error("Workspace file ownership must use non-negative integer uid/gid values");
+    }
+    return ownership;
+}
+function sha256Hex(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+/**
+ * The refusal names what differs — planned versus existing content digest,
+ * mode, or file kind — plus the plan digest, so the operator can tell a
+ * mid-session profile swap from an agent-edited workspace file without
+ * reproducing the workspace. Reads here are best-effort diagnosis inside an
+ * already-failing path; an unreadable existing file is reported, not thrown
+ * over.
+ */
+function workspaceFileConflictMessage(file, existingFiles, planDigest) {
+    const prefix = `Refusing to replace existing workspace file: ${file.relPath}`;
+    if (existingFiles === "reject") {
+        return `${prefix} — the reject policy forbids any pre-existing plan path (plan ${planDigest})`;
+    }
+    const planned = `planned sha256:${sha256Hex(file.content)} mode ${file.mode.toString(8)}`;
+    let existing;
+    try {
+        const stats = lstatSync(file.absPath);
+        if (!stats.isFile()) {
+            existing = stats.isSymbolicLink()
+                ? "existing path is a symlink, not a regular file"
+                : "existing path is not a regular file";
+        }
+        else {
+            const mode = (stats.mode & 0o777).toString(8);
+            existing = `existing sha256:${sha256Hex(readFileSync(file.absPath))} mode ${mode}`;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        existing = `existing file unreadable: ${message}`;
+    }
+    return `${prefix} — ${planned} != ${existing} (plan ${planDigest})`;
+}
+function prepareWorkspaceFile(workspaceRoot, file, ownership) {
+    assertNoSymlinkPathComponents(workspaceRoot, file.absPath);
+    const temporaryPath = join(dirname(file.absPath), `.agent-profile-${randomUUID()}.tmp`);
+    let descriptor;
+    try {
+        descriptor = openSync(temporaryPath, SAFE_WRITE_FLAGS, 0o600);
+        writeFileSync(descriptor, file.content, "utf8");
+        if (ownership)
+            fchownSync(descriptor, ownership.uid, ownership.gid);
+        fchmodSync(descriptor, file.mode);
+        const stats = fstatSync(descriptor);
+        const descriptorToClose = descriptor;
+        descriptor = undefined;
+        closeSync(descriptorToClose);
+        return {
+            file,
+            temporaryPath,
+            identity: { device: stats.dev, inode: stats.ino },
+            published: false,
+        };
+    }
+    catch (error) {
+        const cleanupErrors = [];
+        if (descriptor !== undefined) {
+            try {
+                closeSync(descriptor);
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+        }
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch (cleanupError) {
+            if (!isFsError(cleanupError, "ENOENT"))
+                cleanupErrors.push(cleanupError);
+        }
+        if (cleanupErrors.length > 0) {
+            throw new AggregateError([error, ...cleanupErrors], `Failed to prepare workspace file: ${file.relPath}`);
+        }
+        throw error;
+    }
+}
+function workspacePathHasIdentity(pathValue, identity) {
+    try {
+        const stats = lstatSync(pathValue);
+        return stats.dev === identity.device && stats.ino === identity.inode;
+    }
+    catch (error) {
+        if (isFsError(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+}
+function resolveWorkspaceFilePath(workspaceRoot, relativePath) {
+    const targetPath = resolve(workspaceRoot, ...relativePath.split("/"));
+    const targetRelativePath = relative(workspaceRoot, targetPath);
+    if (!targetRelativePath ||
+        targetRelativePath === ".." ||
+        targetRelativePath.startsWith(`..${sep}`) ||
+        isAbsolute(targetRelativePath)) {
+        throw new Error(`Refusing to materialize profile file outside workspace: ${relativePath}`);
+    }
+    return targetPath;
+}
+function assertNoSymlinkPathComponents(workspaceRoot, targetPath) {
+    const targetRelativePath = relative(workspaceRoot, targetPath);
+    let currentPath = workspaceRoot;
+    const components = ["", ...targetRelativePath.split(sep)];
+    for (const [index, component] of components.entries()) {
+        if (component)
+            currentPath = join(currentPath, component);
+        let stats;
+        try {
+            stats = lstatSync(currentPath);
+        }
+        catch (error) {
+            if (isFsError(error, "ENOENT"))
+                return;
+            if (isFsError(error, "ELOOP")) {
+                throw new Error(`Refusing to materialize profile file through symlink path: ${targetRelativePath}`);
+            }
+            throw error;
+        }
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Refusing to materialize profile file through symlink path: ${targetRelativePath}`);
+        }
+        const isTarget = index === components.length - 1;
+        if ((!isTarget && !stats.isDirectory()) || (isTarget && !stats.isFile())) {
+            throw new Error(`Refusing to materialize profile file through non-file path: ${targetRelativePath}`);
+        }
+    }
+}
+function isFsError(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === code);
+}
+export { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, };
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, fchmodSync, fchownSync, fstatSync, lstatSync, openSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { SAFE_WRITE_FLAGS } from "./workspace-files.js";

package/dist/workspace-apply.js

@@ -1,6 +1,10 @@
 export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDir, options, publicPlanDigest = hashWorkspacePlan(publicPlan)) {
     const workspaceRoot = resolve(workspaceDir);
     const runtimeOnlyFiles = new Set((options.runtimeOnlyFiles ?? []).map(normalizeWorkspaceRelativePath));
+    const ownership = validateWorkspaceOwnership(options.ownership);
+    const privateFilePaths = new Set(normalizePlanFiles(publicPlan.files)
+        .filter((file) => file.secretSlots.length > 0)
+        .map((file) => file.relPath));
     const existingFiles = options.existingFiles ?? "allow-identical";
     if (existingFiles !== "allow-identical" && existingFiles !== "reject") {
         throw new Error(`Unsupported existing workspace file policy: ${existingFiles}`);
@@ -15,17 +19,31 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         ...file,
         absPath: resolveWorkspaceFilePath(workspaceRoot, file.relPath),
     }));
-    // A prior application of THIS EXACT plan makes the workspace the running
-    // agent's live state: a file the agent edited or removed since then is the
-    // session's own memory, not a conflict, so a byte comparison against the
-    // plan would refuse a resume the caller proved is unchanged. The digest the
-    // caller passes is its own record of what it already applied here; only the
-    // caller can know that, which is why this is an option and not an inference
-    // from disk. `reject` is not short-circuited: that policy asserts an empty
-    // target and must keep failing on any pre-existing path.
-    if (existingFiles === "allow-identical" &&
+    // 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.
+    const resumeSamePlan = existingFiles === "allow-identical" &&
         options.appliedPlanDigest !== undefined &&
-        options.appliedPlanDigest === publicPlanDigest) {
+        options.appliedPlanDigest === publicPlanDigest;
+    const filesToApply = resumeSamePlan
+        ? files.filter((file) => {
+            if (file.ownership !== "materializer")
+                return false;
+            assertNoSymlinkPathComponents(workspaceRoot, file.absPath);
+            if (!workspaceFileExists(file.absPath))
+                return false;
+            const matches = workspaceFileMatches(file);
+            const hasCurrentOwnership = ownership === undefined ||
+                workspaceFileHasOwnership(file.absPath, ownership);
+            if (privateFilePaths.has(file.relPath)) {
+                return !matches || !hasCurrentOwnership;
+            }
+            return matches && !hasCurrentOwnership;
+        })
+        : files;
+    if (resumeSamePlan && filesToApply.length === 0) {
         return {
             receipt: safeWorkspacePlanReceipt(publicPlan, files.map((file) => file.relPath), publicPlanDigest),
             spawn: {
@@ -47,7 +65,7 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         isMaterializerOutput(file.relPath, () => regularFileContent(file.absPath));
     // Validate the complete plan before the first write so a late traversal or
     // existing symlink cannot leave a partially materialized workspace.
-    for (const file of files) {
+    for (const file of filesToApply) {
         assertNoSymlinkPathComponents(workspaceRoot, file.absPath);
         if (workspaceFileExists(file.absPath) &&
             !mayReplace(file) &&
@@ -57,23 +75,26 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
     }
     // Parent directories remain on failure because they may contain concurrent
     // workspace state that this call does not own.
-    for (const file of files) {
+    for (const file of filesToApply) {
         mkdirSync(dirname(file.absPath), { recursive: true });
     }
-    for (const file of files) {
+    for (const file of filesToApply) {
         assertNoSymlinkPathComponents(workspaceRoot, 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 files) {
+        for (const file of filesToApply) {
             if (existingFiles === "allow-identical" &&
                 workspaceFileExists(file.absPath) &&
-                workspaceFileMatches(file)) {
+                workspaceFileMatches(file) &&
+                (file.ownership !== "materializer" ||
+                    ownership === undefined ||
+                    workspaceFileHasOwnership(file.absPath, ownership))) {
                 continue;
             }
-            prepared.push(prepareWorkspaceFile(workspaceRoot, file));
+            prepared.push(prepareWorkspaceFile(workspaceRoot, file, ownership));
         }
         for (const entry of prepared) {
             assertNoSymlinkPathComponents(workspaceRoot, entry.file.absPath);
@@ -84,7 +105,10 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
             catch (error) {
                 if (isFsError(error, "EEXIST") &&
                     existingFiles === "allow-identical" &&
-                    workspaceFileMatches(entry.file)) {
+                    workspaceFileMatches(entry.file) &&
+                    (entry.file.ownership !== "materializer" ||
+                        ownership === undefined ||
+                        workspaceFileHasOwnership(entry.file.absPath, ownership))) {
                     continue;
                 }
                 if (isFsError(error, "EEXIST") && mayReplace(entry.file)) {
@@ -162,162 +186,6 @@ export function applyResolvedWorkspacePlan(publicPlan, resolvedPlan, workspaceDi
         runtimeOnlyFiles: privateRuntimeFiles,
     };
 }
-function workspaceFileExists(pathValue) {
-    try {
-        lstatSync(pathValue);
-        return true;
-    }
-    catch (error) {
-        if (isFsError(error, "ENOENT"))
-            return false;
-        throw error;
-    }
-}
-function regularFileContent(pathValue) {
-    return lstatSync(pathValue).isFile()
-        ? readFileSync(pathValue, "utf8")
-        : undefined;
-}
-function workspaceFileMatches(file) {
-    const stats = lstatSync(file.absPath);
-    return (stats.isFile() &&
-        (stats.mode & 0o777) === file.mode &&
-        readFileSync(file.absPath, "utf8") === file.content);
-}
-function sha256Hex(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-/**
- * The refusal names what differs — planned versus existing content digest,
- * mode, or file kind — plus the plan digest, so the operator can tell a
- * mid-session profile swap from an agent-edited workspace file without
- * reproducing the workspace. Reads here are best-effort diagnosis inside an
- * already-failing path; an unreadable existing file is reported, not thrown
- * over.
- */
-function workspaceFileConflictMessage(file, existingFiles, planDigest) {
-    const prefix = `Refusing to replace existing workspace file: ${file.relPath}`;
-    if (existingFiles === "reject") {
-        return `${prefix} — the reject policy forbids any pre-existing plan path (plan ${planDigest})`;
-    }
-    const planned = `planned sha256:${sha256Hex(file.content)} mode ${file.mode.toString(8)}`;
-    let existing;
-    try {
-        const stats = lstatSync(file.absPath);
-        if (!stats.isFile()) {
-            existing = stats.isSymbolicLink()
-                ? "existing path is a symlink, not a regular file"
-                : "existing path is not a regular file";
-        }
-        else {
-            const mode = (stats.mode & 0o777).toString(8);
-            existing = `existing sha256:${sha256Hex(readFileSync(file.absPath))} mode ${mode}`;
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        existing = `existing file unreadable: ${message}`;
-    }
-    return `${prefix} — ${planned} != ${existing} (plan ${planDigest})`;
-}
-function prepareWorkspaceFile(workspaceRoot, file) {
-    assertNoSymlinkPathComponents(workspaceRoot, file.absPath);
-    const temporaryPath = join(dirname(file.absPath), `.agent-profile-${randomUUID()}.tmp`);
-    let descriptor;
-    try {
-        descriptor = openSync(temporaryPath, SAFE_WRITE_FLAGS, 0o600);
-        writeFileSync(descriptor, file.content, "utf8");
-        fchmodSync(descriptor, file.mode);
-        const stats = fstatSync(descriptor);
-        const descriptorToClose = descriptor;
-        descriptor = undefined;
-        closeSync(descriptorToClose);
-        return {
-            file,
-            temporaryPath,
-            identity: { device: stats.dev, inode: stats.ino },
-            published: false,
-        };
-    }
-    catch (error) {
-        const cleanupErrors = [];
-        if (descriptor !== undefined) {
-            try {
-                closeSync(descriptor);
-            }
-            catch (cleanupError) {
-                cleanupErrors.push(cleanupError);
-            }
-        }
-        try {
-            unlinkSync(temporaryPath);
-        }
-        catch (cleanupError) {
-            if (!isFsError(cleanupError, "ENOENT"))
-                cleanupErrors.push(cleanupError);
-        }
-        if (cleanupErrors.length > 0) {
-            throw new AggregateError([error, ...cleanupErrors], `Failed to prepare workspace file: ${file.relPath}`);
-        }
-        throw error;
-    }
-}
-function workspacePathHasIdentity(pathValue, identity) {
-    try {
-        const stats = lstatSync(pathValue);
-        return stats.dev === identity.device && stats.ino === identity.inode;
-    }
-    catch (error) {
-        if (isFsError(error, "ENOENT"))
-            return false;
-        throw error;
-    }
-}
-function resolveWorkspaceFilePath(workspaceRoot, relativePath) {
-    const targetPath = resolve(workspaceRoot, ...relativePath.split("/"));
-    const targetRelativePath = relative(workspaceRoot, targetPath);
-    if (!targetRelativePath ||
-        targetRelativePath === ".." ||
-        targetRelativePath.startsWith(`..${sep}`) ||
-        isAbsolute(targetRelativePath)) {
-        throw new Error(`Refusing to materialize profile file outside workspace: ${relativePath}`);
-    }
-    return targetPath;
-}
-function assertNoSymlinkPathComponents(workspaceRoot, targetPath) {
-    const targetRelativePath = relative(workspaceRoot, targetPath);
-    let currentPath = workspaceRoot;
-    const components = ["", ...targetRelativePath.split(sep)];
-    for (const [index, component] of components.entries()) {
-        if (component)
-            currentPath = join(currentPath, component);
-        let stats;
-        try {
-            stats = lstatSync(currentPath);
-        }
-        catch (error) {
-            if (isFsError(error, "ENOENT"))
-                return;
-            if (isFsError(error, "ELOOP")) {
-                throw new Error(`Refusing to materialize profile file through symlink path: ${targetRelativePath}`);
-            }
-            throw error;
-        }
-        if (stats.isSymbolicLink()) {
-            throw new Error(`Refusing to materialize profile file through symlink path: ${targetRelativePath}`);
-        }
-        const isTarget = index === components.length - 1;
-        if ((!isTarget && !stats.isDirectory()) || (isTarget && !stats.isFile())) {
-            throw new Error(`Refusing to materialize profile file through non-file path: ${targetRelativePath}`);
-        }
-    }
-}
-function isFsError(error, code) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        error.code === code);
-}
 export function safeWorkspacePlanReceipt(plan, written, workspacePlanDigest = hashWorkspacePlan(plan)) {
     return {
         workspacePlanDigest,
@@ -332,12 +200,12 @@ export function safeWorkspacePlanReceipt(plan, written, workspacePlanDigest = ha
         written: [...written],
     };
 }
-import { createHash, randomUUID } from "node:crypto";
-import { closeSync, fchmodSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { linkSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { isMaterializerOutput } from "./harness.js";
 import { hashWorkspacePlan } from "./plan-digest.js";
-import { normalizeWorkspacePlanArgument, } from "./plan-normalize.js";
+import { normalizePlanFiles, normalizeWorkspacePlanArgument, } from "./plan-normalize.js";
 import { promptIntentFields, samePromptIntentValue, systemPromptBindingField, } from "./plan-prompt.js";
 import { WorkspacePlanCleanupError } from "./plan-types.js";
-import { normalizeWorkspaceRelativePath, SAFE_WRITE_FLAGS, } from "./workspace-files.js";
+import { assertNoSymlinkPathComponents, isFsError, prepareWorkspaceFile, regularFileContent, resolveWorkspaceFilePath, validateWorkspaceOwnership, workspaceFileConflictMessage, workspaceFileExists, workspaceFileHasOwnership, workspaceFileMatches, workspacePathHasIdentity, } from "./workspace-apply-files.js";
+import { normalizeWorkspaceRelativePath } from "./workspace-files.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-profile-materialize",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "description": "Materialize an AgentProfile into the native per-harness workspace files (the one shared materializer for cli-bridge, agent-dev-container, and VB).",
   "type": "module",
   "main": "./dist/index.js",