@deftai/directive-core 0.87.0 → 0.89.0

package/dist/product-signal/consent.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { DEFAULT_PRODUCT_SIGNAL_SINK_REPO } from "../policy/product-signal.js";
 import { platformUserConfigDir } from "../user-config/resolve-user-md.js";
 export const PRODUCT_SIGNAL_CONSENT_FILENAME = "product-signal-consent.json";
@@ -142,8 +143,15 @@ export function grantProductSignalConsent(options = {}) {
         sinkRepo,
     };
     const path = resolveProductSignalConsentPath(options);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: resolve(dir),
+        target: basename(path),
+        data: `${JSON.stringify(record, null, 2)}\n`,
+        mode: "replace",
+    });
     return record;
 }
 /** Revoke consent by setting revokedAt (#2693 D2). */
@@ -167,7 +175,15 @@ export function revokeProductSignalConsent(options = {}) {
         ...existing,
         revokedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
     };
-    writeFileSync(path, `${JSON.stringify(revoked, null, 2)}\n`, "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    containedWrite({
+        root: resolve(dir),
+        target: basename(path),
+        data: `${JSON.stringify(revoked, null, 2)}\n`,
+        mode: "replace",
+    });
     return true;
 }
 //# sourceMappingURL=consent.js.map

package/dist/product-signal/submit.js

@@ -1,6 +1,7 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
+import { ContainedWriteError, containedWrite } from "../fs/contained-write.js";
+import { ProjectionContainmentError } from "../fs/projection-containment.js";
 import { enableProductSignal, formatProductSignalStatusLine, resolveProductSignal, } from "../policy/product-signal.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveActorName } from "./actor-name.js";
@@ -15,17 +16,26 @@ import { bootstrapProductSignalSink } from "./sink-bootstrap.js";
 export const PRODUCT_SIGNAL_LAST_SUBMIT_REL = join(".deft-cache", "product-signal-last-submit.json");
 function recordLastSubmit(projectRoot, outcome, url) {
     const path = resolve(projectRoot, PRODUCT_SIGNAL_LAST_SUBMIT_REL);
-    assertWriteTargetSafe(projectRoot, path);
     try {
-        mkdirSync(join(path, ".."), { recursive: true });
-        appendFileSync(path, `${JSON.stringify({
-            outcome,
-            issueUrl: url,
-            at: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
-        })}\n`, "utf8");
+        // #2980 wave D: product write sink routes through containedWrite.
+        const root = resolve(projectRoot);
+        containedWrite({
+            root,
+            target: path,
+            data: `${JSON.stringify({
+                outcome,
+                issueUrl: url,
+                at: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+            })}\n`,
+            mode: "append",
+        });
     }
-    catch {
-        // observability only
+    catch (err) {
+        // Containment refusals must fail closed (tests + product path) (#2807 / #2980).
+        if (err instanceof ContainedWriteError || err instanceof ProjectionContainmentError) {
+            throw err;
+        }
+        // other observability I/O failures only
     }
 }
 function readLastSubmitSummary(projectRoot) {
@@ -134,7 +144,7 @@ export async function submitProductSignal(options) {
             recordLastSubmit(root, result.outcome, result.issueUrl ?? null);
         }
         catch (err) {
-            if (err instanceof ProjectionContainmentError) {
+            if (err instanceof ProjectionContainmentError || err instanceof ContainedWriteError) {
                 return {
                     outcome: "error-config",
                     exitCode: 2,

package/dist/release/build-dist-runner.js

@@ -1,8 +1,10 @@
 /**
  * Subprocess entry for sync callers (release pipeline, task build).
  * Top-level await keeps the process alive until the archive is written.
+ * Progress ticks go to stderr so pipeline callers can still capture the
+ * archive path on stdout (#2953).
  */
-import { buildArchive, selectFormat } from "./build-dist.js";
+import { buildArchive, emitBuildProgress, selectFormat } from "./build-dist.js";
 const version = process.argv[2];
 const root = process.argv[3];
 if (!version || !root) {
@@ -11,7 +13,8 @@ if (!version || !root) {
 }
 const fmt = selectFormat(process.env.DEFT_BUILD_FORMAT);
 try {
-    const out = await buildArchive(root, version, fmt);
+    process.stderr.write(`build-dist-runner: start version=${version} format=${fmt}\n`);
+    const out = await buildArchive(root, version, fmt, { onProgress: emitBuildProgress });
     process.stdout.write(`${out}\n`);
 }
 catch (err) {

package/dist/release/build-dist.d.ts

@@ -8,7 +8,25 @@ export declare function iterSourceFiles(root: string, excludes?: ReadonlySet<str
 }>;
 export declare function selectFormat(arg: string | null | undefined): "tar" | "zip";
 export declare function outputPath(root: string, version: string, fmt: "tar" | "zip"): string;
-export declare function buildArchive(root: string, version: string, fmt: "tar" | "zip", extraExcludes?: readonly string[]): Promise<string>;
+export type BuildProgress = {
+    readonly stage: string;
+    readonly detail?: string;
+    readonly current?: number;
+    readonly total?: number;
+};
+export type BuildArchiveOptions = {
+    readonly extraExcludes?: readonly string[];
+    /** Progress sink; default silent so unit tests stay quiet (#2953). */
+    readonly onProgress?: (p: BuildProgress) => void;
+};
+/**
+ * Emit human-readable stage progress for long release packaging runs (#2953).
+ * Writes to stderr so stdout stays the archive path for pipeline capture.
+ */
+export declare function emitBuildProgress(progress: BuildProgress, stream?: {
+    write: (chunk: string) => unknown;
+}): void;
+export declare function buildArchive(root: string, version: string, fmt: "tar" | "zip", options?: readonly string[] | BuildArchiveOptions): Promise<string>;
 export declare function parseExtraExcludes(raw: string): string[];
 export declare function main(argv: readonly string[]): Promise<number>;
 //# sourceMappingURL=build-dist.d.ts.map

package/dist/release/build-dist.js

@@ -16,6 +16,9 @@ export const DEFAULT_EXCLUDES = new Set([
     ".ruff_cache",
     ".coverage",
     "coverage",
+    // Scratch worktrees are never shippable framework content (#2953).
+    ".deft-scratch",
+    "swarm-worktrees",
 ]);
 export const DEFAULT_EXCLUDED_PATH_PREFIXES = [
     "history/archive",
@@ -97,14 +100,46 @@ export function outputPath(root, version, fmt) {
     const suffix = fmt === "zip" ? "zip" : "tar.gz";
     return join(root, "dist", `deft-${version}.${suffix}`);
 }
-export async function buildArchive(root, version, fmt, extraExcludes = []) {
+/**
+ * Emit human-readable stage progress for long release packaging runs (#2953).
+ * Writes to stderr so stdout stays the archive path for pipeline capture.
+ */
+export function emitBuildProgress(progress, stream = process.stderr) {
+    const { stage, detail, current, total } = progress;
+    let line = `build-dist: ${stage}`;
+    if (typeof current === "number" && typeof total === "number" && total > 0) {
+        const pct = Math.min(100, Math.floor((current / total) * 100));
+        line += ` ${current}/${total} (${pct}%)`;
+    }
+    if (detail)
+        line += ` - ${detail}`;
+    stream.write(`${line}\n`);
+}
+function isExtraExcludesList(options) {
+    return Array.isArray(options);
+}
+function resolveBuildOptions(options = {}) {
+    // Backward-compatible: 4th arg may be a bare extra-excludes array (pre-#2953).
+    if (isExtraExcludesList(options)) {
+        return { extraExcludes: options, onProgress: () => { } };
+    }
+    return {
+        extraExcludes: options.extraExcludes ?? [],
+        onProgress: options.onProgress ?? (() => { }),
+    };
+}
+export async function buildArchive(root, version, fmt, options = {}) {
+    const { extraExcludes, onProgress } = resolveBuildOptions(options);
     const excludes = new Set([...DEFAULT_EXCLUDES, ...extraExcludes]);
     const output = outputPath(root, version, fmt);
     mkdirSync(dirname(output), { recursive: true });
     if (existsSync(output)) {
         unlinkSync(output);
     }
+    onProgress({ stage: "scan", detail: "enumerating source files" });
     const entries = iterSourceFiles(root, excludes);
+    const total = entries.length;
+    onProgress({ stage: "scan", detail: `found ${total} files`, current: total, total });
     await new Promise((resolvePromise, reject) => {
         const out = createWriteStream(output);
         const archive = fmt === "zip"
@@ -114,11 +149,21 @@ export async function buildArchive(root, version, fmt, extraExcludes = []) {
         out.on("error", (err) => reject(err));
         archive.on("error", (err) => reject(err));
         archive.pipe(out);
+        onProgress({ stage: "pack", detail: `format=${fmt}`, current: 0, total });
+        // Progress ticks every ~5% (or every 250 files) so long packs do not look hung.
+        const tickEvery = Math.max(1, Math.min(250, Math.ceil(total / 20)));
+        let i = 0;
         for (const { absPath, archiveRel } of entries) {
             archive.file(absPath, { name: `${ARCHIVE_ROOT}/${archiveRel}` });
+            i += 1;
+            if (i === total || i % tickEvery === 0) {
+                onProgress({ stage: "pack", current: i, total });
+            }
         }
+        onProgress({ stage: "finalize", detail: output });
         void archive.finalize();
     });
+    onProgress({ stage: "done", detail: output, current: total, total });
     return output;
 }
 export function parseExtraExcludes(raw) {
@@ -159,7 +204,10 @@ export async function main(argv) {
     }
     const fmt = selectFormat(fmtArg);
     try {
-        const out = await buildArchive(projectRoot, version, fmt, parseExtraExcludes(extra));
+        const out = await buildArchive(projectRoot, version, fmt, {
+            extraExcludes: parseExtraExcludes(extra),
+            onProgress: emitBuildProgress,
+        });
         const printable = relative(projectRoot, out) || out;
         process.stdout.write(`Created ${printable}\n`);
         return 0;

package/dist/release/native-steps.js

@@ -79,16 +79,21 @@ export function runBuildNative(projectRoot, version, _seams = {}) {
         return [false, "build requires a release version"];
     }
     const env = { ...process.env, DEFT_RELEASE_VERSION: version };
+    // Inherit stderr so build-dist-runner progress ticks stream live during
+    // release Step 8; capture stdout only for the archive path (#2953).
     const result = spawnSync(process.execPath, [BUILD_DIST_RUNNER, version, projectRoot], {
         cwd: projectRoot,
         encoding: "utf8",
         env,
+        stdio: ["ignore", "pipe", "inherit"],
     });
     if (result.status !== 0) {
-        const msg = (result.stderr ?? result.stdout ?? "").trim() || `exit ${result.status ?? 1}`;
+        const captured = (typeof result.stderr === "string" ? result.stderr : "") ||
+            (typeof result.stdout === "string" ? result.stdout : "");
+        const msg = captured.trim() || `exit ${result.status ?? 1}`;
         return [false, `build failed: ${msg}`];
     }
-    const out = (result.stdout ?? "").trim();
+    const out = (typeof result.stdout === "string" ? result.stdout : "").trim();
     return [true, `build ran clean (DEFT_RELEASE_VERSION=${version}) -> ${out}`];
 }
 //# sourceMappingURL=native-steps.js.map

package/dist/release-publish/pipeline.d.ts

@@ -1,4 +1,17 @@
+import { type EnvMap } from "../authz/closed-verb.js";
+import type { ClosedVerbDecision, HumanOriginGrant } from "../authz/types.js";
 import type { PublishConfig, ReleasePublishSeams } from "./types.js";
 export declare function emit(label: string, status: string): void;
+/**
+ * Fail-closed gate before draft→public (#1095 Wave 4).
+ * Allow only DEFT_ALLOW_RELEASE_PUBLISH=1 or a matching human-origin grant.
+ * Loads conventions/verb-classification.json from projectRoot when present.
+ * Test seam: pass grants / env via optional overrides on seams when present.
+ */
+export declare function evaluateReleasePublishGate(version: string, projectRoot: string, options?: {
+    readonly grants?: readonly HumanOriginGrant[];
+    readonly env?: EnvMap;
+    readonly repo?: string | null;
+}): ClosedVerbDecision;
 export declare function runPublish(config: PublishConfig, seams?: ReleasePublishSeams): number;
 //# sourceMappingURL=pipeline.d.ts.map

package/dist/release-publish/pipeline.js

@@ -1,10 +1,34 @@
+import { closedVerbEnvBypassKey, evaluateClosedVerb } from "../authz/closed-verb.js";
+import { listActiveHumanGrants, loadAuthzState, markGrantUsed } from "../authz/store.js";
+import { loadVerbClassification } from "../authz/verb-classification.js";
 import { EXIT_OK, EXIT_VIOLATION } from "../release/constants.js";
 import { editReleasePublish, viewRelease } from "./gh-api.js";
 export function emit(label, status) {
     process.stderr.write(`[publish] ${label}... ${status}\n`);
 }
+/**
+ * Fail-closed gate before draft→public (#1095 Wave 4).
+ * Allow only DEFT_ALLOW_RELEASE_PUBLISH=1 or a matching human-origin grant.
+ * Loads conventions/verb-classification.json from projectRoot when present.
+ * Test seam: pass grants / env via optional overrides on seams when present.
+ */
+export function evaluateReleasePublishGate(version, projectRoot, options = {}) {
+    // Production load of classification SoT (conventions/verb-classification.json).
+    const classification = loadVerbClassification(projectRoot);
+    const state = loadAuthzState(projectRoot);
+    const grants = options.grants ?? listActiveHumanGrants(projectRoot, state);
+    return evaluateClosedVerb({
+        verb: "release-publish",
+        target: version,
+        grants,
+        env: options.env ?? process.env,
+        projectRoot,
+        repo: options.repo ?? null,
+        classification,
+    });
+}
 export function runPublish(config, seams = {}) {
-    const { version, repo, dryRun } = config;
+    const { version, repo, dryRun, projectRoot } = config;
     const tag = `v${version}`;
     const viewLabel = `View ${tag} on ${repo}`;
     if (dryRun) {
@@ -26,6 +50,23 @@ export function runPublish(config, seams = {}) {
         return EXIT_OK;
     }
     emit(viewLabel, `OK (draft found at ${payload?.url ?? "<no url>"})`);
+    // Closed-verb gate: refuse draft→public without grant or env bypass (#1095).
+    const gateSeams = seams;
+    const gate = evaluateReleasePublishGate(version, projectRoot, {
+        grants: gateSeams.closedVerbGrants,
+        env: gateSeams.closedVerbEnv,
+        repo,
+    });
+    if (!gate.allowed) {
+        const bypassKey = gate.envBypassKey ??
+            closedVerbEnvBypassKey("release-publish", projectRoot) ??
+            "DEFT_ALLOW_RELEASE_PUBLISH";
+        emit(`Closed-verb gate release-publish ${tag}`, `FAIL (${gate.code}: ${gate.reason})`);
+        process.stderr.write(`[publish] denied code=${gate.code} — set ${bypassKey}=1 or ` +
+            `mint \`deft authz:grant -- --template release-publish --target ${version}\`\n`);
+        return EXIT_VIOLATION;
+    }
+    emit(`Closed-verb gate release-publish ${tag}`, `OK (${gate.code}${gate.humanApprovalRef !== null ? ` grant=${gate.humanApprovalRef}` : ""})`);
     const editLabel = `Edit ${tag} (--draft=false)`;
     const [ok, editReason] = editReleasePublish(version, repo, payload?.id ?? undefined, seams);
     if (!ok) {
@@ -40,6 +81,10 @@ export function runPublish(config, seams = {}) {
         return EXIT_VIOLATION;
     }
     emit(verifyLabel, `OK (${tag} is now public)`);
+    // Consume single-use grant after successful draft→public (#1095).
+    if (gate.humanApprovalRef !== null && gate.code === "closed-verb-allow") {
+        markGrantUsed(projectRoot, gate.humanApprovalRef);
+    }
     process.stderr.write(`Release ${tag} published successfully on ${repo}.\n`);
     return EXIT_OK;
 }

package/dist/scope/audit-log.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveTriageCachePath } from "../triage/cache-path.js";
 import { utcNowIso } from "./vbrief-json.js";
 export class ScopeAuditLogError extends Error {
@@ -28,6 +29,12 @@ const DEMOTE_META_REQUIRED = [
     "demoted_from",
 ];
 let threadLock = false;
+/** Ensure parent exists and return it as the containment root for log writes. */
+function containmentRootForLog(logPath) {
+    const parent = dirname(logPath);
+    mkdirSync(parent, { recursive: true });
+    return resolve(parent);
+}
 function replacerSortKeys(_key, value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         const sorted = {};
@@ -97,34 +104,16 @@ export function canonicalLogPath(projectRoot) {
     // Layout-aware (#1703): triage working-set under `.triage-cache/`.
     return resolveTriageCachePath(resolve(projectRoot), "scope-lifecycle.jsonl");
 }
-function withAppendLock(logPath, fn) {
-    const lockPath = `${logPath}.lock`;
-    mkdirSync(dirname(logPath), { recursive: true });
+function withAppendLock(fn) {
     while (threadLock) {
         /* spin-wait for in-process serialization */
     }
     threadLock = true;
-    let fd = null;
     try {
-        fd = openSync(lockPath, "a+");
-        if (readFileSync(lockPath).length === 0) {
-            writeSync(fd, "\0");
-        }
         fn();
     }
     finally {
         threadLock = false;
-        if (fd !== null) {
-            closeSync(fd);
-        }
-        try {
-            if (existsSync(lockPath)) {
-                unlinkSync(lockPath);
-            }
-        }
-        catch {
-            /* best-effort lock cleanup */
-        }
     }
 }
 /** Validate and append an audit entry; returns decision_id. */
@@ -134,10 +123,16 @@ export function append(entry, logPath) {
     }
     validateEntry(entry);
     const logFile = resolve(logPath);
-    mkdirSync(join(logFile, ".."), { recursive: true });
+    const root = containmentRootForLog(logFile);
     const line = JSON.stringify(entry, replacerSortKeys);
-    withAppendLock(logFile, () => {
-        writeFileSync(logFile, `${line}\n`, { encoding: "utf8", flag: "a" });
+    // #2980 wave B: product write sink routes through containedWrite.
+    withAppendLock(() => {
+        containedWrite({
+            root,
+            target: logFile,
+            data: `${line}\n`,
+            mode: "append",
+        });
     });
     return String(entry.decision_id);
 }

package/dist/scope/decompose.js

@@ -6,10 +6,11 @@
  * A caller supplies a draft with child story definitions; this module validates
  * that draft, writes the child story vBRIEFs, and updates the parent scope references.
  */
-import { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
-import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
+import { containedWrite } from "../fs/contained-write.js";
+import { ProjectionContainmentError } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, resolveLifecycleRoot, } from "../layout/resolve.js";
 import { referenceWithDefaultTrust, slugify } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
@@ -54,9 +55,13 @@ function loadJson(path) {
     return data;
 }
 function writeJson(projectRoot, path, data) {
-    assertWriteTargetSafe(projectRoot, path);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, formatBriefJson(data), "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    containedWrite({
+        root: resolve(projectRoot),
+        target: path,
+        data: formatBriefJson(data),
+        mode: "replace",
+    });
 }
 // ---------------------------------------------------------------------------
 // Story quality helpers (ported from _vbrief_story_quality.py)

package/dist/scope/decomposed-refs.js

@@ -1,6 +1,7 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
+import { containedWrite } from "../fs/contained-write.js";
 import { formatBriefJson } from "./vbrief-json.js";
 import { collectChildUris, collectPlanRefs, resolveVbriefRef } from "./vbrief-ref.js";
 function rewriteOnePlanRef(value, oldParentResolved, newParentRel, vbriefDir) {
@@ -53,7 +54,14 @@ function rewriteParentChildReference(parentPath, oldChildResolved, newChildRel,
     }
     if (changed) {
         try {
-            writeFileSync(parentPath, formatBriefJson(parentData), "utf8");
+            // #2980 wave D: product write sink routes through containedWrite.
+            const dir = dirname(parentPath);
+            containedWrite({
+                root: resolve(dir),
+                target: parentPath,
+                data: formatBriefJson(parentData),
+                mode: "replace",
+            });
         }
         catch {
             return false;
@@ -127,7 +135,14 @@ function rewriteChildParentReference(childPath, oldParentResolved, newParentRel,
     }
     if (changed) {
         try {
-            writeFileSync(childPath, formatBriefJson(childData), "utf8");
+            // #2980 wave D: product write sink routes through containedWrite.
+            const dir = dirname(childPath);
+            containedWrite({
+                root: resolve(dir),
+                target: childPath,
+                data: formatBriefJson(childData),
+                mode: "replace",
+            });
         }
         catch {
             return false;

package/dist/scope/demote.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { hasArtifactSuffix, resolveLifecycleFolder } from "../layout/resolve.js";
 import { stripTrailingPathSeparators } from "../text/redos-safe.js";
@@ -85,7 +86,13 @@ export function demoteOne(filePath, projectRoot, reason, options = {}) {
     const timestamp = utcNowIso(now);
     planObj.status = TARGET_STATUS;
     planObj.updated = timestamp;
-    writeFileSync(resolved, formatBriefJson(data), "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    containedWrite({
+        root: resolve(projectRoot),
+        target: resolved,
+        data: formatBriefJson(data),
+        mode: "replace",
+    });
     const vbriefRoot = dirname(dirname(resolved));
     const targetDir = join(vbriefRoot, TARGET_FOLDER);
     mkdirSync(targetDir, { recursive: true });

package/dist/scope/undo.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/projection-containment.js";
 import { resolveLifecycleRoot } from "../layout/resolve.js";
 import { append, canonicalLogPath, newDecisionId, readAll } from "./audit-log.js";
@@ -185,7 +186,13 @@ function moveAndFlip(srcFile, destFolder, newStatus, timestamp, projectRoot) {
     const planObj = plan;
     planObj.status = newStatus;
     planObj.updated = timestamp;
-    writeFileSync(srcFile, formatBriefJson(data), "utf8");
+    // #2980 wave D: product write sink routes through containedWrite.
+    containedWrite({
+        root: resolve(projectRoot),
+        target: srcFile,
+        data: formatBriefJson(data),
+        mode: "replace",
+    });
     mkdirSync(destFolder, { recursive: true });
     const destPath = join(destFolder, basename(srcFile));
     renameSync(srcFile, destPath);

package/dist/session/release-availability.js

@@ -1,9 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import { locateManifest, parseInstallManifest } from "../doctor/manifest.js";
 import { runningInsideDeftRepo } from "../doctor/paths.js";
 import { evaluateReleaseAvailability } from "../doctor/release-availability.js";
+import { containedWrite } from "../fs/contained-write.js";
 import { resolveTriageCachePath } from "../triage/cache-path.js";
 const THROTTLE_MS = 24 * 60 * 60 * 1000;
 const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org/";
@@ -56,10 +57,29 @@ function isThrottled(state, latestVersion, now) {
     return Number.isFinite(notifiedAt) && now.getTime() - notifiedAt < THROTTLE_MS;
 }
 function defaultWriteState(path, content) {
-    mkdirSync(dirname(path), { recursive: true });
-    const temporary = `${path}.${process.pid}.tmp`;
-    writeFileSync(temporary, content, "utf8");
-    renameSync(temporary, path);
+    const dir = dirname(path);
+    mkdirSync(dir, { recursive: true });
+    const tmpBase = `${basename(path)}.${process.pid}.tmp`;
+    const temporary = join(dir, tmpBase);
+    try {
+        // #2980 wave D: product write sink routes through containedWrite.
+        containedWrite({
+            root: resolve(dir),
+            target: tmpBase,
+            data: content,
+            mode: "create",
+        });
+        renameSync(temporary, path);
+    }
+    catch (err) {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
 }
 /**
  * Probe the public npm registry separately from doctor. Doctor stays offline

package/dist/session/ritual-sentinel.js

@@ -1,5 +1,6 @@
-import { closeSync, existsSync, fdatasyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, writeSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
 import { join, relative, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
 import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, } from "../layout/resolve.js";
 import { stableJson } from "./json.js";
 import { RITUAL_STATE_CONTRACT } from "./posture.js";
@@ -92,24 +93,30 @@ function validateSteps(raw, key) {
     return [steps, null];
 }
 function atomicWriteJson(targetPath, payload, prefix) {
-    mkdirSync(join(targetPath, ".."), { recursive: true });
     const dir = join(targetPath, "..");
-    const tmpName = join(dir, `${prefix}${process.pid}.json.tmp`);
-    const fd = openSync(tmpName, "w");
+    mkdirSync(dir, { recursive: true });
+    const tmpBase = `${prefix}${process.pid}.json.tmp`;
+    const tmpName = join(dir, tmpBase);
+    const text = `${stableJson(payload, 2)}\n`;
     try {
-        const text = `${stableJson(payload, 2)}\n`;
-        writeSync(fd, text, undefined, "utf8");
+        // #2980 wave D: ritual-state product write routes through containedWrite.
+        containedWrite({
+            root: resolve(dir),
+            target: tmpBase,
+            data: text,
+            mode: "create",
+        });
+        renameSync(tmpName, targetPath);
+    }
+    catch (err) {
         try {
-            fdatasyncSync(fd);
+            rmSync(tmpName, { force: true });
         }
         catch {
-            // best-effort
+            /* best-effort cleanup */
         }
+        throw err;
     }
-    finally {
-        closeSync(fd);
-    }
-    renameSync(tmpName, targetPath);
 }
 export function readRitualState(projectRoot) {
     const stateFile = ritualStatePath(projectRoot);