@aiwg/cli 2026.10.6 → 2026.10.8

package/dist/src/smiths/context-pipeline/context-file-safety.js

@@ -1,18 +1,339 @@
-import { lstat } from 'node:fs/promises';
-import { basename } from 'node:path';
-/** Never read or update a provider instruction file through a filesystem link. */
-export async function assertSafeContextFile(filePath) {
-    let stat;
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { trackTemporaryDirectory } from '../../utils/temporary-directory.js';
+const JOURNAL_ENV = 'AIWG_CONTEXT_WRITE_JOURNAL';
+export const CONTEXT_STAGE_ENV = 'AIWG_CONTEXT_STAGE_LOG';
+const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const identity = (stat) => ({ dev: String(stat.dev), ino: String(stat.ino) });
+const sameIdentity = (a, b) => a.dev === b.dev && a.ino === b.ino;
+const sameAncestors = (a, b) => a.length === b.length && a.every((identity, index) => sameIdentity(identity, b[index]));
+// Optional flags are absent on some supported hosts (notably Windows).
+function flags(...names) {
+    return names.reduce((value, name) => {
+        const flag = fs.constants[name];
+        return typeof flag === 'number' ? value | flag : value;
+    }, 0);
+}
+// Identity is dev/ino/size/mtime. A replacement that recycles the freed inode
+// number with the same size inside one coarse timestamp tick is
+// indistinguishable by metadata; the content hash still has to match deploy
+// output, so restoring over such a file loses nothing the deploy wrote.
+const version = (stat) => ({ ...identity(stat), size: String(stat.size), mtime: String(stat.mtimeNs) });
+const sameVersion = (a, b) => sameIdentity(a, b) && a.size === b.size && a.mtime === b.mtime;
+/** Probe child traversal, not just the descriptor link itself. /dev/fd on macOS
+ * can expose a descriptor without supporting directory-relative child opens. */
+function descriptorRoot(root) {
+    if (process.platform !== 'linux')
+        return null;
+    let fd;
+    try {
+        fd = fs.openSync(root, flags('O_RDONLY', 'O_DIRECTORY', 'O_NOFOLLOW'));
+        const child = `/proc/self/fd/${fd}/.`;
+        return sameIdentity(identity(fs.statSync(child, { bigint: true })), identity(fs.fstatSync(fd, { bigint: true }))) ? '/proc/self/fd' : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/** Pin directories on Linux when descriptor-relative child traversal works.
+ * Elsewhere lstat every ancestor and recheck paths around each mutation. The
+ * portable fallback has a residual check-then-write race: only descriptor
+ * anchoring closes the interval between the last path check and the write. */
+function withParent(file, create, action) {
+    const absolute = path.resolve(file);
+    const root = path.parse(absolute).root;
+    const parts = path.relative(root, absolute).split(path.sep);
+    const descriptors = [];
+    const identities = [];
+    const fdRoot = descriptorRoot(root);
+    try {
+        let directory = root;
+        for (const part of ['', ...parts.slice(0, -1)]) {
+            const next = part ? path.join(directory, part) : directory;
+            // Drive roots already exist; mkdir on a Windows drive root can be EPERM.
+            if (create && part) {
+                try {
+                    fs.mkdirSync(next);
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            const checked = fs.lstatSync(next, { bigint: true });
+            if (checked.isSymbolicLink() || !checked.isDirectory())
+                throw new Error('Context ancestor changed');
+            identities.push(identity(checked));
+            directory = next;
+            if (fdRoot) {
+                const fd = fs.openSync(next, flags('O_RDONLY', 'O_DIRECTORY', 'O_NOFOLLOW'));
+                descriptors.push(fd);
+                if (!sameIdentity(identity(fs.fstatSync(fd, { bigint: true })), identity(checked)))
+                    throw new Error('Context ancestor changed');
+                directory = `${fdRoot}/${fd}`;
+            }
+        }
+        const verify = () => {
+            let current = root;
+            for (let i = 0; i < identities.length; i++) {
+                if (i)
+                    current = path.join(current, parts[i - 1]);
+                const stat = fs.lstatSync(current, { bigint: true });
+                if (!stat.isDirectory() || stat.isSymbolicLink() || !sameIdentity(identity(stat), identities[i]))
+                    throw new Error('Context ancestor changed');
+            }
+        };
+        verify();
+        return action(path.join(directory, parts[parts.length - 1]), identities, verify);
+    }
+    finally {
+        for (const fd of descriptors.reverse())
+            fs.closeSync(fd);
+    }
+}
+function checkedVersion(stat) {
+    if (stat.isSymbolicLink() || !stat.isFile() || !(stat.mode & 292n) || !(stat.mode & 146n) || stat.nlink !== 1n)
+        throw new Error('Refusing unreadable, unwritable, linked or non-file context target');
+    return version(stat);
+}
+function verifyTarget(file, expected) {
+    if (!sameVersion(checkedVersion(fs.lstatSync(file, { bigint: true })), expected))
+        throw new Error('Context identity changed');
+}
+function state(fd) {
+    const stat = fs.fstatSync(fd, { bigint: true });
+    const before = checkedVersion(stat);
+    const bytes = Buffer.alloc(Number(stat.size));
+    let offset = 0;
+    while (offset < bytes.length) {
+        const count = fs.readSync(fd, bytes, offset, bytes.length - offset, offset);
+        if (!count)
+            throw new Error('Context changed while reading');
+        offset += count;
+    }
+    if (!sameVersion(checkedVersion(fs.fstatSync(fd, { bigint: true })), before))
+        throw new Error('Context changed while reading');
+    return { ...before, mode: Number(stat.mode & 4095n), bytes: bytes.toString('base64'), hash: digest(bytes) };
+}
+function readState(file) {
+    let checked;
     try {
-        stat = await lstat(filePath);
+        checked = checkedVersion(fs.lstatSync(file, { bigint: true }));
     }
     catch (error) {
         if (error.code === 'ENOENT')
-            return;
+            return null;
         throw error;
     }
-    if (stat.isSymbolicLink() || !stat.isFile()) {
-        throw new Error(`Refusing unsafe ${basename(filePath)} target: ${filePath}`);
+    const fd = fs.openSync(file, flags('O_RDONLY', 'O_NOFOLLOW', 'O_NONBLOCK'));
+    try {
+        const result = state(fd);
+        if (!sameVersion(result, checked))
+            throw new Error('Context identity changed');
+        verifyTarget(file, result);
+        return result;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function matches(a, b) {
+    return sameVersion(a, b) && a.hash === b.hash && a.mode === b.mode;
+}
+function entries() {
+    const file = process.env[JOURNAL_ENV];
+    return file ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line)) : [];
+}
+/** Every context writer uses this boundary, including staged provider writers.
+ * Record immediately after the mutation, before returning to a fallible step. */
+export function writeContextFileSync(file, content, _encoding) {
+    const absolute = path.resolve(file);
+    const stageLog = process.env[CONTEXT_STAGE_ENV];
+    const priorEntries = stageLog ? [] : entries();
+    withParent(absolute, true, (anchored, ancestors, verify) => {
+        const prior = readState(anchored);
+        const previous = priorEntries.reverse().find(entry => entry.path === absolute);
+        if (previous && (!prior || !matches(prior, previous.result) || !sameAncestors(ancestors, previous.ancestors)))
+            throw new Error(`Context changed during deployment: ${absolute}`);
+        verify();
+        const fd = fs.openSync(anchored, flags('O_RDWR', 'O_NOFOLLOW', 'O_NONBLOCK', ...(prior ? [] : ['O_CREAT', 'O_EXCL'])), prior?.mode ?? 0o666);
+        try {
+            verify();
+            if (prior && !matches(state(fd), prior))
+                throw new Error(`Context identity changed: ${absolute}`);
+            verify();
+            verifyTarget(anchored, prior ?? checkedVersion(fs.fstatSync(fd, { bigint: true })));
+            const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+            const opened = fs.fstatSync(fd, { bigint: true });
+            const priorBytes = prior ? Buffer.from(prior.bytes, 'base64') : Buffer.alloc(0);
+            const expected = Buffer.alloc(Math.max(buffer.length, priorBytes.length));
+            priorBytes.copy(expected);
+            let length = priorBytes.length;
+            try {
+                let offset = 0;
+                while (offset < buffer.length) {
+                    const count = fs.writeSync(fd, buffer, offset, buffer.length - offset, offset);
+                    if (!count)
+                        throw new Error('Context write made no progress');
+                    buffer.copy(expected, offset, offset, offset + count);
+                    offset += count;
+                    length = Math.max(length, offset);
+                }
+                fs.ftruncateSync(fd, buffer.length);
+                length = buffer.length;
+            }
+            finally {
+                // Hash the bytes this writer produced, never a later read that could
+                // accidentally claim an operator's concurrent edit as deploy-owned.
+                const completed = fs.fstatSync(fd, { bigint: true });
+                const result = { ...version(completed), ...identity(opened), size: String(length), mode: Number(opened.mode & 4095n), hash: digest(expected.subarray(0, length)) };
+                if (stageLog)
+                    fs.appendFileSync(stageLog, `${JSON.stringify(absolute)}\n`);
+                else if (process.env[JOURNAL_ENV])
+                    fs.appendFileSync(process.env[JOURNAL_ENV], `${JSON.stringify({ path: absolute, prior, result, ancestors })}\n`);
+                verify();
+                verifyTarget(anchored, result);
+                if (!matches(state(fd), result))
+                    throw new Error(`Context changed during write: ${absolute}`);
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    });
+}
+/** Verify before reading provider startup files as well as at the write boundary. */
+export async function assertSafeContextFile(file) {
+    try {
+        withParent(file, false, anchored => { readState(anchored); });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw new Error(`Refusing unsafe ${path.basename(file)} target: ${file}`, { cause: error });
+    }
+}
+/** Owned by the outer use invocation; the private log also crosses subprocesses. */
+export class ContextWriteJournal {
+    directory = fs.mkdtempSync(path.join(tmpdir(), 'aiwg-context-writes-'));
+    removeDirectory = trackTemporaryDirectory(this.directory);
+    previous = process.env[JOURNAL_ENV];
+    constructor() {
+        fs.chmodSync(this.directory, 0o700);
+        const file = path.join(this.directory, 'writes.jsonl');
+        fs.writeFileSync(file, '', { mode: 0o600, flag: 'wx' });
+        process.env[JOURNAL_ENV] = file;
+    }
+    rollback() {
+        const result = { restored: [], conflicts: [] };
+        const blocked = new Set();
+        // Restoring a later pass changes mtime. Carry that verified version back
+        // through earlier entries rather than treating our own restore as an edit.
+        const restoredVersions = new Map();
+        for (const entry of entries().reverse()) {
+            if (blocked.has(entry.path))
+                continue;
+            try {
+                withParent(entry.path, false, (anchored, ancestors, verify) => {
+                    if (!sameAncestors(ancestors, entry.ancestors))
+                        throw new Error('Context ancestor identity changed');
+                    const checked = checkedVersion(fs.lstatSync(anchored, { bigint: true }));
+                    const fd = fs.openSync(anchored, flags('O_RDWR', 'O_NOFOLLOW', 'O_NONBLOCK'));
+                    try {
+                        verify();
+                        const current = state(fd);
+                        if (!sameVersion(current, checked))
+                            throw new Error('Context identity changed');
+                        if (!matches(current, restoredVersions.get(entry.path) ?? entry.result))
+                            throw new Error('Context changed since deployment wrote it');
+                        verify();
+                        verifyTarget(anchored, current);
+                        if (!matches(state(fd), current))
+                            throw new Error('Context changed before restore');
+                        if (entry.prior) {
+                            const bytes = Buffer.from(entry.prior.bytes, 'base64');
+                            let offset = 0;
+                            while (offset < bytes.length) {
+                                const count = fs.writeSync(fd, bytes, offset, bytes.length - offset, offset);
+                                if (!count)
+                                    throw new Error('Context restore made no progress');
+                                offset += count;
+                            }
+                            fs.ftruncateSync(fd, bytes.length);
+                            fs.fchmodSync(fd, entry.prior.mode);
+                            verify();
+                            const restored = state(fd);
+                            if (!sameIdentity(restored, current) || restored.hash !== entry.prior.hash || restored.mode !== entry.prior.mode)
+                                throw new Error('Context changed during restore');
+                            verifyTarget(anchored, restored);
+                            restoredVersions.set(entry.path, restored);
+                        }
+                        else {
+                            // Quarantine before deleting: a final-component swap between the
+                            // identity check and rename must be kept, never silently unlinked.
+                            const quarantine = fs.mkdtempSync(path.join(path.dirname(anchored), '.aiwg-context-rollback-'));
+                            const retained = path.join(quarantine, 'context');
+                            try {
+                                fs.renameSync(anchored, retained);
+                                try {
+                                    const moved = readState(retained);
+                                    if (!moved || !matches(moved, current))
+                                        throw new Error('Context changed during removal');
+                                    verify();
+                                    fs.unlinkSync(retained);
+                                }
+                                catch (error) {
+                                    try {
+                                        fs.linkSync(retained, anchored);
+                                        fs.unlinkSync(retained);
+                                    }
+                                    catch {
+                                        const saved = path.join(path.dirname(entry.path), path.basename(quarantine), 'context');
+                                        throw new Error(`Context changed during removal; preserved at ${saved}`, { cause: error });
+                                    }
+                                    throw error;
+                                }
+                                verify();
+                                if (fs.existsSync(anchored))
+                                    throw new Error('Context path replaced during rollback');
+                            }
+                            finally {
+                                try {
+                                    fs.rmdirSync(quarantine);
+                                }
+                                catch (error) {
+                                    if (error.code !== 'ENOTEMPTY')
+                                        throw error;
+                                }
+                            }
+                        }
+                    }
+                    finally {
+                        fs.closeSync(fd);
+                    }
+                });
+                if (!result.restored.includes(entry.path))
+                    result.restored.push(entry.path);
+            }
+            catch (error) {
+                blocked.add(entry.path);
+                result.conflicts.push({ path: entry.path, reason: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        return result;
+    }
+    dispose() {
+        if (this.previous === undefined)
+            delete process.env[JOURNAL_ENV];
+        else
+            process.env[JOURNAL_ENV] = this.previous;
+        this.removeDirectory();
     }
 }
 //# sourceMappingURL=context-file-safety.js.map

package/dist/src/smiths/context-pipeline/finalization.js

@@ -1,3 +1,4 @@
+import { writeContextFileSync } from './context-file-safety.js';
 /**
  * Context-finalization pass for generated provider context files.
  *
@@ -132,13 +133,13 @@ export async function writeNormalizedAiwgMd(projectPath) {
     const content = await buildNormalizedAiwgMd(projectPath, existing);
     await fs.mkdir(path.dirname(targetPath), { recursive: true });
     const normalizedContent = content.endsWith('\n') ? content : `${content}\n`;
-    await fs.writeFile(targetPath, normalizedContent, 'utf8');
+    writeContextFileSync(targetPath, normalizedContent, 'utf8');
     const artifactRoot = resolveProjectAiwgDir(projectPath);
     const artifactPath = projectAiwgPath(projectPath, 'AIWG.md');
     if (artifactPath !== targetPath) {
         try {
             await fs.access(artifactRoot);
-            await fs.writeFile(artifactPath, normalizedContent, 'utf8');
+            writeContextFileSync(artifactPath, normalizedContent, 'utf8');
         }
         catch (error) {
             if (error.code !== 'ENOENT')

package/dist/src/smiths/context-pipeline/generator.js

@@ -20,7 +20,7 @@ import { writeNormalizedAiwgMd } from './finalization.js';
 import { shouldEmitAgentsMd, shouldEmitAiwgMd, shouldEmitClaudeMdHook } from './provider-policy.js';
 import { ensureClaudeMdHook } from './claude-hook.js';
 import { ensureManagedHook } from './managed-hook.js';
-import { assertSafeContextFile } from './context-file-safety.js';
+import { assertSafeContextFile, writeContextFileSync } from './context-file-safety.js';
 import { buildProviderBootstrapBlock, ensureWorkspaceContext, registerProviderContext, } from './workspace-context.js';
 import { projectControlPath } from '../../config/project-artifacts.js';
 const SECTION_TITLES = {
@@ -195,9 +195,8 @@ export async function isOverwriteSafe(filePath) {
     }
 }
 /**
- * Atomically write a file via tmpfile + rename.
- *
- * Per ADR-4 §4 atomic write requirement; on failure no partial state is persisted.
+ * Preserve rule-owned blocks, then write through the safe context boundary.
+ * The deploy journal retains the preimage even if a later step fails.
  */
 async function atomicWrite(filePath, content, provider) {
     // Rule delivery owns this block. Context regeneration runs after deployment
@@ -217,18 +216,7 @@ async function atomicWrite(filePath, content, provider) {
     if (provider === 'hermes' && ['AGENTS.md', '.hermes.md'].includes(path.basename(filePath)) && content.length > 19000) {
         throw new Error(`Hermes ${path.basename(filePath)} exceeds hard cap of 19000 characters`);
     }
-    const dir = path.dirname(filePath);
-    const tmp = path.join(dir, `.${path.basename(filePath)}.tmp.${process.pid}`);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(tmp, content, 'utf8');
-    try {
-        await fs.rename(tmp, filePath);
-    }
-    catch (err) {
-        // Best-effort cleanup of tmpfile on rename failure.
-        await fs.unlink(tmp).catch(() => undefined);
-        throw err;
-    }
+    writeContextFileSync(filePath, content);
     return bytes;
 }
 /**
@@ -312,7 +300,7 @@ async function writeTwinFiles(provider, projectPath, agentsMdContent, opts, resu
                 const original = await fs.readFile(twinPath, 'utf8');
                 if (!original.includes(AIWG_SIGNATURE_COMMENT) && !/Generated by\s+(AIWG|aiwg)/i.test(original.split('\n').slice(0, 4).join('\n'))) {
                     const backupPath = `${twinPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
-                    await fs.writeFile(backupPath, original, 'utf8');
+                    writeContextFileSync(backupPath, original, 'utf8');
                     result.backupPaths.push(backupPath);
                 }
             }
@@ -412,7 +400,7 @@ export async function generate(opts) {
                 const original = await fs.readFile(agentsMdPath, 'utf8');
                 if (!original.includes(AIWG_SIGNATURE_COMMENT)) {
                     const backupPath = `${agentsMdPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
-                    await fs.writeFile(backupPath, original, 'utf8');
+                    writeContextFileSync(backupPath, original, 'utf8');
                     result.backupPaths.push(backupPath);
                 }
             }
@@ -463,7 +451,7 @@ export async function generate(opts) {
                 const original = await fs.readFile(aiwgMdPath, 'utf8');
                 if (!original.includes(AIWG_SIGNATURE_COMMENT)) {
                     const backupPath = `${aiwgMdPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
-                    await fs.writeFile(backupPath, original, 'utf8');
+                    writeContextFileSync(backupPath, original, 'utf8');
                     result.backupPaths.push(backupPath);
                 }
             }

package/dist/src/smiths/context-pipeline/legacy-inject.js

@@ -1,3 +1,4 @@
+import { writeContextFileSync } from './context-file-safety.js';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { getProviderDefinition } from '../../providers/provider-definitions.js';
@@ -60,15 +61,7 @@ async function readOptional(file) {
 }
 async function atomicWrite(file, content) {
     await fs.mkdir(path.dirname(file), { recursive: true });
-    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.tmp.${process.pid}`);
-    await fs.writeFile(temporary, content, 'utf8');
-    try {
-        await fs.rename(temporary, file);
-    }
-    catch (error) {
-        await fs.rm(temporary, { force: true });
-        throw error;
-    }
+    writeContextFileSync(file, content);
 }
 export async function injectLegacyContext(provider, projectPath, frameworkContent, options = {}) {
     const definition = getProviderDefinition(provider);
@@ -93,7 +86,7 @@ export async function injectLegacyContext(provider, projectPath, frameworkConten
         if (existing !== null) {
             const backup = `${target}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
             await fs.mkdir(path.dirname(backup), { recursive: true });
-            await fs.writeFile(backup, existing, 'utf8');
+            writeContextFileSync(backup, existing, 'utf8');
             backups.push(backup);
         }
         await atomicWrite(target, output);

package/dist/src/smiths/context-pipeline/managed-hook.js

@@ -15,7 +15,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { buildProviderBootstrapBlock } from './workspace-context.js';
 import { dominantLineEnding, withLineEnding } from './line-endings.js';
-import { assertSafeContextFile } from './context-file-safety.js';
+import { assertSafeContextFile, writeContextFileSync } from './context-file-safety.js';
 export const CONTEXT_HOOK_START = '<!-- AIWG:context-hook:start -->';
 export const CONTEXT_HOOK_END = '<!-- AIWG:context-hook:end -->';
 /** The managed block — loads canonical workspace context before framework context. */
@@ -53,7 +53,7 @@ export async function ensureManagedHook(filePath, opts = {}) {
     }
     catch (err) {
         if (err.code === 'ENOENT') {
-            await fs.writeFile(filePath, `${block}\n`, 'utf8');
+            writeContextFileSync(filePath, `${block}\n`, 'utf8');
             result.action = 'created';
             return result;
         }
@@ -71,7 +71,7 @@ export async function ensureManagedHook(filePath, opts = {}) {
     // No managed block — append it to the end, preserving everything above.
     if (s === -1 && e === -1) {
         const trimmed = existing.replace(/(?:\r?\n)+$/, lineEnding);
-        await fs.writeFile(filePath, `${trimmed}${lineEnding}${block}${lineEnding}`, 'utf8');
+        writeContextFileSync(filePath, `${trimmed}${lineEnding}${block}${lineEnding}`, 'utf8');
         result.action = 'inserted';
         return result;
     }
@@ -79,7 +79,7 @@ export async function ensureManagedHook(filePath, opts = {}) {
     if (s === -1 || e === -1) {
         if (opts.force) {
             const trimmed = existing.replace(/(?:\r?\n)+$/, lineEnding);
-            await fs.writeFile(filePath, `${trimmed}${lineEnding}${block}${lineEnding}`, 'utf8');
+            writeContextFileSync(filePath, `${trimmed}${lineEnding}${block}${lineEnding}`, 'utf8');
             result.action = 'inserted';
             return result;
         }
@@ -93,7 +93,7 @@ export async function ensureManagedHook(filePath, opts = {}) {
         result.action = 'unchanged';
         return result;
     }
-    await fs.writeFile(filePath, existing.substring(0, s) + block + existing.substring(endOff), 'utf8');
+    writeContextFileSync(filePath, existing.substring(0, s) + block + existing.substring(endOff), 'utf8');
     result.action = 'updated';
     return result;
 }

package/dist/src/smiths/context-pipeline/workspace-context.js

@@ -1,3 +1,4 @@
+import { writeContextFileSync } from './context-file-safety.js';
 /**
  * Canonical cross-provider workspace context graph (#1811).
  *
@@ -71,16 +72,7 @@ async function readOptional(filePath) {
     }
 }
 async function atomicWrite(filePath, content) {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    const temporary = path.join(path.dirname(filePath), `.${path.basename(filePath)}.tmp.${process.pid}`);
-    await fs.writeFile(temporary, content, 'utf8');
-    try {
-        await fs.rename(temporary, filePath);
-    }
-    catch (error) {
-        await fs.rm(temporary, { force: true }).catch(() => undefined);
-        throw error;
-    }
+    writeContextFileSync(filePath, content);
 }
 function resolveProjectRelative(projectPath, relativePath) {
     if (path.isAbsolute(relativePath))
@@ -513,7 +505,7 @@ export async function ensureWorkspaceContext(projectPath, options = {}) {
         return { path: workspacePath, action: 'preserved', warnings };
     }
     const backupPath = `${workspacePath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
-    await fs.writeFile(backupPath, existing, 'utf8');
+    writeContextFileSync(backupPath, existing, 'utf8');
     await atomicWrite(workspacePath, buildWorkspaceDocument(projectPath, existing, providerFiles, residentMemory));
     return { path: workspacePath, action: 'updated', backupPath, warnings };
 }
@@ -1122,7 +1114,7 @@ export async function migrateWorkspaceContext(projectPath, options = {}) {
         let preimage = null;
         if (existing !== null) {
             preimage = path.relative(projectPath, path.join(preimageDir, safePreimageName(relativePath))).replace(/\\/g, '/');
-            await fs.writeFile(path.join(projectPath, preimage), existing, 'utf8');
+            writeContextFileSync(path.join(projectPath, preimage), existing, 'utf8');
             backups.push(preimage);
         }
         manifest.files.push({ path: relativePath, existed: existing !== null, preimage, outputChecksum: sha256(content) });