@deftai/directive-core 0.81.0 → 0.82.0

package/dist/pr-wait-mergeable/result.js

@@ -11,6 +11,9 @@ export function toResultDict(result) {
     if (Object.keys(result.protectedCheck).length > 0) {
         payload.protected_check = result.protectedCheck;
     }
+    if (Object.keys(result.semanticGreen).length > 0) {
+        payload.semantic_green = result.semanticGreen;
+    }
     if (result.mergeStdout.length > 0) {
         payload.merge_stdout = result.mergeStdout;
     }
@@ -26,6 +29,7 @@ export function makeResult(fields) {
     return {
         monitorResult: fields.monitorResult ?? {},
         protectedCheck: fields.protectedCheck ?? {},
+        semanticGreen: fields.semanticGreen ?? {},
         mergeStdout: fields.mergeStdout ?? "",
         mergeStderr: fields.mergeStderr ?? "",
         prNumber: fields.prNumber,

package/dist/pr-wait-mergeable/semantic-green.d.ts

@@ -0,0 +1,27 @@
+import type { RunGhFn } from "../pr-merge-readiness/types.js";
+export interface SemanticGreenOptions {
+    /** Enable merge-cascade semantic-green checks (#2385). */
+    readonly cascadeMode?: boolean;
+    /** After a prior cascade merge, require target-branch CI green at HEAD before the next merge. */
+    readonly requireMasterCiGreen?: boolean;
+    /** Target branch for stale-base comparison (defaults to PR base.ref). */
+    readonly baseBranch?: string | null;
+    readonly runGh?: RunGhFn;
+}
+export interface SemanticGreenPayload {
+    readonly pr_base_sha: string | null;
+    readonly target_branch: string | null;
+    readonly target_head_sha: string | null;
+    readonly master_ci: Record<string, unknown>;
+}
+export interface SemanticGreenResult {
+    readonly ok: boolean;
+    readonly outcome: string | null;
+    readonly exitCode: number | null;
+    readonly error: string | null;
+    readonly payload: SemanticGreenPayload;
+}
+/** Pre-merge semantic-green gate for merge cascades (#2385). */
+export declare function evaluateSemanticGreen(prNumber: number, repo: string, options?: SemanticGreenOptions): SemanticGreenResult;
+export type SemanticGreenFn = typeof evaluateSemanticGreen;
+//# sourceMappingURL=semantic-green.d.ts.map

package/dist/pr-wait-mergeable/semantic-green.js

@@ -0,0 +1,202 @@
+import { buildCiSummaryLine, evaluateCiGate } from "../pr-merge-readiness/ci-gate.js";
+import { defaultRunGh, fetchCheckRunsRest } from "../pr-merge-readiness/gh.js";
+import { EXIT_CONFIG_ERROR, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
+function emptyPayload() {
+    return {
+        pr_base_sha: null,
+        target_branch: null,
+        target_head_sha: null,
+        master_ci: {},
+    };
+}
+function fetchPrBase(prNumber, repo, runGh) {
+    const rc = runGh(["gh", "api", `repos/${repo}/pulls/${prNumber}`]);
+    if (rc.returncode !== 0) {
+        return {
+            baseRef: null,
+            baseSha: null,
+            error: `gh api /pulls/${prNumber} failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { baseRef: null, baseSha: null, error: "empty body from gh api /pulls/<N>" };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { baseRef: null, baseSha: null, error: `could not parse PR JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return { baseRef: null, baseSha: null, error: "unexpected PR JSON shape (not a dict)" };
+    }
+    const base = payload.base;
+    if (base === null || typeof base !== "object" || Array.isArray(base)) {
+        return { baseRef: null, baseSha: null, error: "PR JSON missing base object" };
+    }
+    const baseRecord = base;
+    const baseRef = typeof baseRecord.ref === "string" && baseRecord.ref.length > 0 ? baseRecord.ref : null;
+    const baseSha = typeof baseRecord.sha === "string" && baseRecord.sha.length > 0 ? baseRecord.sha : null;
+    if (baseRef === null || baseSha === null) {
+        return { baseRef, baseSha, error: "PR JSON missing base.ref or base.sha" };
+    }
+    return { baseRef, baseSha, error: null };
+}
+function fetchBranchHeadSha(repo, branch, runGh) {
+    const encoded = branch.split("/").map(encodeURIComponent).join("/");
+    const rc = runGh(["gh", "api", `repos/${repo}/git/ref/heads/${encoded}`]);
+    if (rc.returncode !== 0) {
+        return {
+            sha: null,
+            error: `gh api /git/ref/heads/${branch} failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { sha: null, error: `empty body from gh api /git/ref/heads/${branch}` };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { sha: null, error: `could not parse branch ref JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return { sha: null, error: "unexpected branch ref JSON shape (not a dict)" };
+    }
+    const object = payload.object;
+    if (object === null || typeof object !== "object" || Array.isArray(object)) {
+        return { sha: null, error: "branch ref JSON missing object.sha" };
+    }
+    const sha = object.sha;
+    if (typeof sha !== "string" || sha.length === 0) {
+        return { sha: null, error: "branch ref JSON missing object.sha" };
+    }
+    return { sha, error: null };
+}
+function evaluateTargetBranchCi(repo, headSha, runGh) {
+    const check = fetchCheckRunsRest(headSha, repo, runGh);
+    if (check.error.length > 0) {
+        return {
+            ok: false,
+            error: "Required CI check-runs on target branch HEAD could not be fetched; " +
+                `fail closed (#2385). ${check.error}`,
+            masterCi: { ready_state: "blocked", error: check.error },
+        };
+    }
+    const ciResult = evaluateCiGate(check.checkRuns);
+    const masterCi = {
+        ...ciResult.summary,
+        summary_line: buildCiSummaryLine(ciResult.summary),
+    };
+    if (ciResult.summary.ready_state !== "ready") {
+        const detail = ciResult.failures.length > 0
+            ? ciResult.failures.join(" ")
+            : `target branch CI ready_state=${ciResult.summary.ready_state}`;
+        return {
+            ok: false,
+            error: "Target branch CI is not green at current HEAD; block cascade merge until master is green (#2385). " +
+                detail,
+            masterCi,
+        };
+    }
+    return { ok: true, error: null, masterCi };
+}
+/** Pre-merge semantic-green gate for merge cascades (#2385). */
+export function evaluateSemanticGreen(prNumber, repo, options = {}) {
+    if (options.cascadeMode !== true) {
+        return { ok: true, outcome: null, exitCode: null, error: null, payload: emptyPayload() };
+    }
+    const runGh = options.runGh ?? defaultRunGh;
+    const prBase = fetchPrBase(prNumber, repo, runGh);
+    if (prBase.error !== null) {
+        return {
+            ok: false,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            error: prBase.error,
+            payload: {
+                ...emptyPayload(),
+                pr_base_sha: prBase.baseSha,
+                target_branch: prBase.baseRef,
+            },
+        };
+    }
+    const targetBranch = options.baseBranch ?? prBase.baseRef;
+    if (targetBranch === null || targetBranch.length === 0) {
+        return {
+            ok: false,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            error: "Could not resolve target branch for semantic-green gate (--base-branch or PR base.ref).",
+            payload: {
+                pr_base_sha: prBase.baseSha,
+                target_branch: null,
+                target_head_sha: null,
+                master_ci: {},
+            },
+        };
+    }
+    const branchHead = fetchBranchHeadSha(repo, targetBranch, runGh);
+    if (branchHead.error !== null) {
+        return {
+            ok: false,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            error: branchHead.error,
+            payload: {
+                pr_base_sha: prBase.baseSha,
+                target_branch: targetBranch,
+                target_head_sha: null,
+                master_ci: {},
+            },
+        };
+    }
+    const payload = {
+        pr_base_sha: prBase.baseSha,
+        target_branch: targetBranch,
+        target_head_sha: branchHead.sha,
+        master_ci: {},
+    };
+    if (prBase.baseSha !== branchHead.sha) {
+        return {
+            ok: false,
+            outcome: "semantic-stale-base",
+            exitCode: EXIT_TIMEOUT_OR_ESCALATION,
+            error: "PR base SHA is behind the current target branch HEAD (merge-tree-clean but semantically stale). " +
+                `Rebase/update-branch onto ${targetBranch} at ${branchHead.sha} and wait for fresh green CI before cascade merge (#2385). ` +
+                `pr_base=${prBase.baseSha} target_head=${branchHead.sha}`,
+            payload,
+        };
+    }
+    if (options.requireMasterCiGreen === true) {
+        const ci = evaluateTargetBranchCi(repo, branchHead.sha, runGh);
+        if (!ci.ok) {
+            return {
+                ok: false,
+                outcome: "master-ci-not-green",
+                exitCode: EXIT_TIMEOUT_OR_ESCALATION,
+                error: ci.error,
+                payload: {
+                    ...payload,
+                    master_ci: ci.masterCi,
+                },
+            };
+        }
+        return {
+            ok: true,
+            outcome: null,
+            exitCode: null,
+            error: null,
+            payload: {
+                ...payload,
+                master_ci: ci.masterCi,
+            },
+        };
+    }
+    return { ok: true, outcome: null, exitCode: null, error: null, payload };
+}
+//# sourceMappingURL=semantic-green.js.map

package/dist/pr-wait-mergeable/types.d.ts

@@ -5,6 +5,7 @@ export interface WaitMergeableResult {
     readonly exitCode: number;
     readonly monitorResult: Record<string, unknown>;
     readonly protectedCheck: Record<string, unknown>;
+    readonly semanticGreen: Record<string, unknown>;
     readonly mergeStdout: string;
     readonly mergeStderr: string;
     readonly error: string | null;

package/dist/pr-watch/constants.d.ts

@@ -39,10 +39,10 @@ export declare const DEFAULT_POLL_SECONDS = 90;
  */
 export declare const WATCH_HELP: string;
 /**
- * Consecutive polls with a review PRESENT but stuck on a stale (non-HEAD)
- * commit before the loop surfaces STALL instead of waiting the full cap. Keeps
- * a Greptile review that never re-reviews the new HEAD from silently eating the
- * whole 30-minute budget (#1039 STALL terminal).
+ * Consecutive polls where the CLEAN gate is wedged on HEAD (!has_blocking &&
+ * !is_clean with a holdout other than sha_match) before STALL (#1039). Stale-SHA
+ * reads (sha_match holdout) do NOT advance this counter — re-review in flight
+ * waits until max-wait cap (#2313 / #1259 INCOMPLETE_BUT_RATED).
  */
 export declare const DEFAULT_STALL_THRESHOLD = 3;
 /**

package/dist/pr-watch/constants.js

@@ -61,10 +61,10 @@ export const WATCH_HELP = "usage: task pr:watch -- <pr_number> [options]\n" +
     "  1  NEW_P0_P1   Blocking findings on the current (SHA-matched) review\n" +
     "  2  ERRORED | STALL | TIMEOUT | CI_BLOCKED | RUNNER_CAPACITY_STALL | config / usage error\n";
 /**
- * Consecutive polls with a review PRESENT but stuck on a stale (non-HEAD)
- * commit before the loop surfaces STALL instead of waiting the full cap. Keeps
- * a Greptile review that never re-reviews the new HEAD from silently eating the
- * whole 30-minute budget (#1039 STALL terminal).
+ * Consecutive polls where the CLEAN gate is wedged on HEAD (!has_blocking &&
+ * !is_clean with a holdout other than sha_match) before STALL (#1039). Stale-SHA
+ * reads (sha_match holdout) do NOT advance this counter — re-review in flight
+ * waits until max-wait cap (#2313 / #1259 INCOMPLETE_BUT_RATED).
  */
 export const DEFAULT_STALL_THRESHOLD = 3;
 /**

package/dist/pr-watch/watch.js

@@ -99,9 +99,11 @@ export function watch(prNumber, repo, options = {}) {
         if (!oneShot && ciBlockedStreak >= DEFAULT_CI_BLOCKED_THRESHOLD) {
             return build(VERDICT_CI_BLOCKED, EXIT_TERMINAL_ERROR, probe, poll);
         }
-        // Stall = a review IS present but stuck on a non-HEAD commit; surface it
-        // rather than burning the whole cap waiting for a re-review that isn't coming.
-        if (probe.found && !probe.shaMatch) {
+        // STALL (#1039): wedged CLEAN-gate on HEAD — !has_blocking && !is_clean for N
+        // consecutive polls with a holdout OTHER than sha_match. Stale-SHA reads
+        // (clean_gate_holdout=sha_match) are INCOMPLETE for HEAD per #1259 / #2313 —
+        // keep polling until cap, not early STALL while re-review is in flight.
+        if (!probe.hasBlocking && !probe.isClean && probe.cleanGateHoldout !== "sha_match") {
             stallStreak += 1;
         }
         else {

package/dist/release/native-steps.js

@@ -6,7 +6,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { isTerminalLifecyclePath, reconcile, scanVbriefDir } from "../intake/reconcile-issues.js";
+import { buildLifecycleReport, isTerminalLifecyclePath, scanLifecycleAnchors, } from "../intake/reconcile-issues.js";
 import { LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, resolveLifecycleFolder, resolveLifecycleRoot, } from "../layout/resolve.js";
 import { renderRoadmap } from "../render/roadmap-render.js";
 import { fetchIssueStatesForRelease } from "./issue-state-fetch.js";
@@ -35,15 +35,22 @@ export function checkVbriefLifecycleSyncNative(projectRoot, repo) {
         vbriefDir = join(projectRoot, MIGRATED_ARTIFACT_DIR);
     }
     try {
-        const issueToVbriefs = scanVbriefDir(vbriefDir);
-        const fetchResult = fetchIssueStatesForRelease(repo, new Set(issueToVbriefs.keys()), {
+        const anchors = scanLifecycleAnchors(vbriefDir);
+        const anchorIssueNumbers = new Set();
+        for (const anchor of anchors) {
+            const num = anchor.issue_number;
+            if (num !== null) {
+                anchorIssueNumbers.add(num);
+            }
+        }
+        const fetchResult = fetchIssueStatesForRelease(repo, anchorIssueNumbers, {
             cwd: projectRoot,
         });
         if (!fetchResult.ok) {
             return [false, -1, fetchResult.reason];
         }
         const issueStateMap = fetchResult.states;
-        const report = reconcile(issueToVbriefs, issueStateMap);
+        const report = buildLifecycleReport(anchors, issueStateMap, false);
         const mismatches = [];
         for (const entry of report.no_open_issue) {
             const files = (entry.vbrief_files ?? []);

package/dist/render/framework-commands.js

@@ -82,6 +82,9 @@ export const COMMANDS = {
     "verify:wip-cap": spec("verify:wip-cap", "preflight_wip_cap:main", {
         projectRootArg: "--project-root",
     }),
+    "verify:orphan-active": spec("verify:orphan-active", "verify_orphan_active:main", {
+        projectRootArg: "--project-root",
+    }),
     "verify:pack-drift": spec("verify:pack-drift", "pack_render:main", {
         defaultArgs: ["--check"],
         cwd: "framework",
@@ -102,6 +105,7 @@ export const COMMANDS = {
         "verify:branch",
         "verify:cache-fresh",
         "verify:wip-cap",
+        "verify:orphan-active",
         "vbrief:validate",
         "verify-strategy-output",
     ]),
@@ -120,6 +124,7 @@ export const COMMANDS = {
         "verify:cache-fresh",
         "verify:pack-drift",
         "verify:wip-cap",
+        "verify:orphan-active",
         "vbrief:validate",
         "verify-strategy-output",
     ]),
@@ -293,6 +298,7 @@ const ENTRYPOINT_VERB = {
     "verify_no_task_runtime:main": "verify-no-task-runtime",
     "preflight_cache:main": "preflight-cache",
     "preflight_wip_cap:main": "verify-wip-cap",
+    "verify_orphan_active:main": "verify-orphan-active",
     "pack_render:main": "pack-render",
     "validate_strategy_output:main": "validate-strategy-output",
     "vbrief_validate:main": "vbrief-validate",

package/dist/scope/brief-io.d.ts

@@ -0,0 +1,26 @@
+import type { JsonObject } from "../vbrief-build/types.js";
+export declare class BriefIOError extends Error {
+    constructor(message: string);
+}
+/** Canonical brief serialization (single source of truth with vbrief-build). */
+export declare function formatBriefJson(data: unknown): string;
+export type ReadBriefResult = {
+    readonly ok: true;
+    readonly data: JsonObject;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/** Read a scope brief for in-memory mutation (parse only; no validation gate on read). */
+export declare function readBriefForMutation(filePath: string): ReadBriefResult;
+/** Fail-closed schema + folder/status validation before persist. */
+export declare function validateBriefForPersist(filePath: string, data: JsonObject, vbriefRoot: string): string | null;
+export type AtomicWriteBriefResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/** Validate then atomically persist a brief (temp file + rename). */
+export declare function atomicWriteBrief(filePath: string, data: JsonObject, vbriefRoot: string): AtomicWriteBriefResult;
+//# sourceMappingURL=brief-io.d.ts.map

package/dist/scope/brief-io.js

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { atomicWriteText } from "../cache/io.js";
+import { hasArtifactSuffix } from "../layout/resolve.js";
+import { pythonJsonPretty } from "../vbrief-build/json.js";
+import { validateFolderStatus } from "../vbrief-validate/folder-status.js";
+import { validateVbriefSchema } from "../vbrief-validate/schema.js";
+export class BriefIOError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BriefIOError";
+    }
+}
+/** Canonical brief serialization (single source of truth with vbrief-build). */
+export function formatBriefJson(data) {
+    return pythonJsonPretty(data);
+}
+/** Read a scope brief for in-memory mutation (parse only; no validation gate on read). */
+export function readBriefForMutation(filePath) {
+    const resolvedPath = resolve(filePath);
+    if (!existsSync(resolvedPath)) {
+        return { ok: false, message: `File not found: ${resolvedPath}` };
+    }
+    const basename = resolvedPath.split(/[/\\]/).pop() ?? "";
+    if (!hasArtifactSuffix(basename)) {
+        return {
+            ok: false,
+            message: `Not a vBRIEF file (expected .vbrief.json or .xbrief.json): ${basename}`,
+        };
+    }
+    let raw;
+    try {
+        raw = readFileSync(resolvedPath, "utf8");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, message: `Could not read ${resolvedPath}: ${msg}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return { ok: false, message: `Invalid JSON in ${resolvedPath}: ${String(err)}` };
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return { ok: false, message: `Top-level value in ${resolvedPath} is not a JSON object` };
+    }
+    return { ok: true, data: parsed };
+}
+/** Fail-closed schema + folder/status validation before persist. */
+export function validateBriefForPersist(filePath, data, vbriefRoot) {
+    const errors = [
+        ...validateVbriefSchema(data, filePath),
+        ...validateFolderStatus(filePath, data, vbriefRoot),
+    ];
+    if (errors.length === 0) {
+        return null;
+    }
+    return errors.join("; ");
+}
+/** Validate then atomically persist a brief (temp file + rename). */
+export function atomicWriteBrief(filePath, data, vbriefRoot) {
+    const validationError = validateBriefForPersist(filePath, data, vbriefRoot);
+    if (validationError !== null) {
+        return { ok: false, message: validationError };
+    }
+    try {
+        atomicWriteText(filePath, formatBriefJson(data));
+        return { ok: true };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, message: `Failed to write ${filePath}: ${msg}` };
+    }
+}
+//# sourceMappingURL=brief-io.js.map

package/dist/scope/decompose.js

@@ -12,7 +12,7 @@ import { referenceTypeMatches } from "@deftai/directive-types";
 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";
-import { formatVbriefJson } from "./vbrief-json.js";
+import { formatBriefJson } from "./vbrief-json.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -54,7 +54,7 @@ function loadJson(path) {
 }
 function writeJson(path, data) {
     mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, formatVbriefJson(data), "utf8");
+    writeFileSync(path, formatBriefJson(data), "utf8");
 }
 // ---------------------------------------------------------------------------
 // Story quality helpers (ported from _vbrief_story_quality.py)

package/dist/scope/decomposed-refs.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
-import { formatVbriefJson } from "./vbrief-json.js";
+import { formatBriefJson } from "./vbrief-json.js";
 import { collectChildUris, collectPlanRefs, resolveVbriefRef } from "./vbrief-ref.js";
 function rewriteOnePlanRef(value, oldParentResolved, newParentRel, vbriefDir) {
     if (typeof value !== "string" || value.length === 0) {
@@ -53,7 +53,7 @@ function rewriteParentChildReference(parentPath, oldChildResolved, newChildRel,
     }
     if (changed) {
         try {
-            writeFileSync(parentPath, formatVbriefJson(parentData), "utf8");
+            writeFileSync(parentPath, formatBriefJson(parentData), "utf8");
         }
         catch {
             return false;
@@ -127,7 +127,7 @@ function rewriteChildParentReference(childPath, oldParentResolved, newParentRel,
     }
     if (changed) {
         try {
-            writeFileSync(childPath, formatVbriefJson(childData), "utf8");
+            writeFileSync(childPath, formatBriefJson(childData), "utf8");
         }
         catch {
             return false;

package/dist/scope/demote.js

@@ -5,7 +5,7 @@ import { hasArtifactSuffix, resolveLifecycleFolder } from "../layout/resolve.js"
 import { stripTrailingPathSeparators } from "../text/redos-safe.js";
 import { append, canonicalLogPath, latestForPath, newDecisionId } from "./audit-log.js";
 import { resolveProjectRoot } from "./project-context.js";
-import { formatVbriefJson, utcNowIso } from "./vbrief-json.js";
+import { formatBriefJson, utcNowIso } from "./vbrief-json.js";
 import { canonicalRelpath } from "./vbrief-ref.js";
 export const DEFAULT_OLDER_THAN_DAYS = 45;
 export const SOURCE_FOLDER = "pending";
@@ -85,7 +85,7 @@ export function demoteOne(filePath, projectRoot, reason, options = {}) {
     const timestamp = utcNowIso(now);
     planObj.status = TARGET_STATUS;
     planObj.updated = timestamp;
-    writeFileSync(resolved, formatVbriefJson(data), "utf8");
+    writeFileSync(resolved, formatBriefJson(data), "utf8");
     const vbriefRoot = dirname(dirname(resolved));
     const targetDir = join(vbriefRoot, TARGET_FOLDER);
     mkdirSync(targetDir, { recursive: true });

package/dist/scope/project-definition-sync.d.ts

@@ -1,3 +1,3 @@
-/** Best-effort sync of PROJECT-DEFINITION after a lifecycle move (#1527). */
-export declare function syncProjectDefinitionAfterScopeMove(scopeData: Record<string, unknown>, oldPath: string, newPath: string, vbriefRoot: string, targetStatus: string): void;
+/** Fail-closed sync of PROJECT-DEFINITION after a lifecycle move (#1527 / #2131). */
+export declare function syncProjectDefinitionAfterScopeMove(scopeData: Record<string, unknown>, oldPath: string, newPath: string, vbriefRoot: string, targetStatus: string): string | null;
 //# sourceMappingURL=project-definition-sync.d.ts.map

package/dist/scope/project-definition-sync.js

@@ -1,10 +1,22 @@
 import { dirname, resolve } from "node:path";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { atomicWriteProjectDefinition, loadProjectDefinitionForMutation, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
 import { syncRegistryArtifactAfterScopeMove } from "./registry-artifact-sync.js";
-/** Best-effort sync of PROJECT-DEFINITION after a lifecycle move (#1527). */
+/** Fail-closed sync of PROJECT-DEFINITION after a lifecycle move (#1527 / #2131). */
 export function syncProjectDefinitionAfterScopeMove(scopeData, oldPath, newPath, vbriefRoot, targetStatus) {
     const projectRoot = dirname(resolve(vbriefRoot));
-    const projectDefPath = resolveProjectDefinitionPath(projectRoot);
-    syncRegistryArtifactAfterScopeMove(projectDefPath, scopeData, oldPath, newPath, vbriefRoot, targetStatus);
+    try {
+        projectDefinitionMutationLock(projectRoot, () => {
+            const projectDefPath = resolveProjectDefinitionPath(projectRoot);
+            syncRegistryArtifactAfterScopeMove(projectDefPath, scopeData, oldPath, newPath, vbriefRoot, targetStatus, {
+                loadForMutation: () => loadProjectDefinitionForMutation(projectRoot),
+                persist: (path, data) => atomicWriteProjectDefinition(path, data),
+            });
+        });
+        return null;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
 }
 //# sourceMappingURL=project-definition-sync.js.map

package/dist/scope/registry-artifact-sync.d.ts

@@ -1,3 +1,8 @@
+import type { JsonObject } from "../vbrief-build/types.js";
+export interface RegistryArtifactPersistHooks {
+    readonly loadForMutation?: () => [JsonObject, string];
+    readonly persist?: (path: string, data: JsonObject) => void;
+}
 /** Best-effort sync of a registry artifact (PROJECT-DEFINITION, specification, etc.) after a lifecycle move. */
-export declare function syncRegistryArtifactAfterScopeMove(registryPath: string, scopeData: Record<string, unknown>, oldPath: string, newPath: string, vbriefRoot: string, targetStatus: string): void;
+export declare function syncRegistryArtifactAfterScopeMove(registryPath: string, scopeData: Record<string, unknown>, oldPath: string, newPath: string, vbriefRoot: string, targetStatus: string, hooks?: RegistryArtifactPersistHooks): void;
 //# sourceMappingURL=registry-artifact-sync.d.ts.map