@deftai/directive-core 0.107.0 → 0.108.0

package/dist/review-monitor/lease-comment.js

@@ -1,4 +1,4 @@
-import { DEFAULT_STALE_MINUTES, REVIEW_OWNER_MARKER_END, REVIEW_OWNER_MARKER_START, } from "./constants.js";
+import { DEFAULT_STALE_MINUTES, PASS_MARKER_KIND, REVIEW_OWNER_MARKER_END, REVIEW_OWNER_MARKER_START, } from "./constants.js";
 export function parseIso8601Utc(value) {
     if (typeof value !== "string" || value.length === 0) {
         return null;
@@ -17,7 +17,7 @@ export function parseIso8601Utc(value) {
     }
     return parsed;
 }
-const FIELD_RE = /^(owner|monitor_agent_id|head_sha|started_at|expires_at|platform_primitive|ended_at):\s*(.*)$/;
+const FIELD_RE = /^(kind|owner|monitor_agent_id|agent_id|pass_kind|ceiling|head_sha|started_at|expires_at|platform_primitive|ended_at):\s*(.*)$/;
 /** True when the comment body contains the review-owner marker block. */
 export function hasReviewOwnerMarker(body) {
     return body.includes(REVIEW_OWNER_MARKER_START);
@@ -42,8 +42,17 @@ function parseFieldBlock(body) {
     }
     return fields;
 }
+/** Marker `kind:` value, or "" when the block declares none (ownership-lease shape). */
+function markerKind(body) {
+    return parseFieldBlock(body).kind ?? "";
+}
 export function parseReviewOwnerLease(body) {
     const fields = parseFieldBlock(body);
+    // An advisory pass mark shares the marker but must never satisfy the
+    // review-monitor ownership gate (#3607).
+    if ((fields.kind ?? "") === PASS_MARKER_KIND) {
+        return null;
+    }
     const owner = fields.owner ?? "";
     const monitorAgentId = fields.monitor_agent_id ?? "";
     const startedAt = fields.started_at ?? "";
@@ -128,6 +137,11 @@ export function mapCommentEntry(entry) {
     if (!hasReviewOwnerMarker(rec.body)) {
         return null;
     }
+    // Pass marks are a disjoint population on the same marker; excluding them here
+    // keeps `registerReviewMonitor` from overwriting one as its lease anchor (#3607).
+    if (markerKind(rec.body) === PASS_MARKER_KIND) {
+        return null;
+    }
     return {
         id: rec.id,
         body: rec.body,
@@ -149,4 +163,91 @@ export function findActiveLeaseComment(comments, options = {}) {
     }
     return selectWinningReviewOwnerComment(active);
 }
+export function parsePassOpenMarker(body) {
+    if (!hasReviewOwnerMarker(body)) {
+        return null;
+    }
+    const fields = parseFieldBlock(body);
+    if ((fields.kind ?? "") !== PASS_MARKER_KIND) {
+        return null;
+    }
+    const owner = fields.owner ?? "";
+    const passKind = fields.pass_kind ?? "";
+    const startedAt = fields.started_at ?? "";
+    const expiresAt = fields.expires_at ?? "";
+    if (owner.length === 0 ||
+        passKind.length === 0 ||
+        startedAt.length === 0 ||
+        expiresAt.length === 0) {
+        return null;
+    }
+    const agentId = fields.agent_id ?? "";
+    const ceiling = fields.ceiling ?? "";
+    const endedAt = fields.ended_at ?? "";
+    return {
+        kind: PASS_MARKER_KIND,
+        pass_kind: passKind,
+        owner,
+        agent_id: agentId.length > 0 ? agentId : null,
+        ceiling: ceiling.length > 0 ? ceiling : null,
+        started_at: startedAt,
+        expires_at: expiresAt,
+        ended_at: endedAt.length > 0 ? endedAt : null,
+    };
+}
+export function renderPassOpenComment(marker) {
+    const optional = (name, value) => value !== null && value.length > 0 ? `${name}: ${value}\n` : "";
+    return (`${REVIEW_OWNER_MARKER_START}\n` +
+        `kind: ${PASS_MARKER_KIND}\n` +
+        `pass_kind: ${marker.pass_kind}\n` +
+        `owner: ${marker.owner}\n` +
+        optional("agent_id", marker.agent_id) +
+        optional("ceiling", marker.ceiling) +
+        `started_at: ${marker.started_at}\n` +
+        `expires_at: ${marker.expires_at}\n` +
+        optional("ended_at", marker.ended_at) +
+        `${REVIEW_OWNER_MARKER_END}`);
+}
+/** Expired or synthesis-cleared marks are ignored on read; a mark self-clears (#3607). */
+export function isPassMarkerActive(marker, now = new Date()) {
+    if (marker.ended_at !== null) {
+        return false;
+    }
+    const expires = parseIso8601Utc(marker.expires_at);
+    if (expires === null) {
+        return false;
+    }
+    return now.getTime() <= expires.getTime();
+}
+export function mapPassCommentEntry(entry) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        return null;
+    }
+    const rec = entry;
+    if (typeof rec.id !== "number" || typeof rec.body !== "string") {
+        return null;
+    }
+    const marker = parsePassOpenMarker(rec.body);
+    if (marker === null) {
+        return null;
+    }
+    return {
+        id: rec.id,
+        body: rec.body,
+        createdAt: typeof rec.created_at === "string" ? rec.created_at : "",
+        authorLogin: typeof rec.author_login === "string" ? rec.author_login : "",
+        marker,
+    };
+}
+/** Oldest comment id wins when two marks race, matching the lease (#2814 / #3607). */
+export function selectWinningPassComment(comments) {
+    if (comments.length === 0) {
+        return null;
+    }
+    return [...comments].sort((a, b) => a.id - b.id)[0] ?? null;
+}
+export function findActivePassComment(comments, options = {}) {
+    const active = comments.filter((comment) => comment.marker !== null && isPassMarkerActive(comment.marker, options.now));
+    return selectWinningPassComment(active);
+}
 //# sourceMappingURL=lease-comment.js.map

package/dist/scm/call.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { resolveCaptureFailureStderr, SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 import { resolveBinary } from "./binary.js";
 import { SUPPORTED_CALL_SOURCES } from "./constants.js";
 import { pyRepr } from "./py-format.js";
@@ -26,18 +27,26 @@ export function call(source, verb, args = null, options = {}) {
         input: options.input,
         encoding: (options.text ?? true) ? "utf8" : undefined,
         timeout: timeoutMs,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
         stdio: captureOutput ? ["pipe", "pipe", "pipe"] : "inherit",
     });
+    // A spawn-level failure (ENOBUFS past maxBuffer, timeout kill) yields a null
+    // status and empty stderr; surface error.message so callers never report a
+    // bare exit 1 with no reason (#1867 / #3903).
+    const stderr = resolveCaptureFailureStderr({
+        captured: typeof result.stderr === "string" ? result.stderr : "",
+        status: result.status,
+        message: result.error?.message,
+    });
     if (options.check && result.status !== 0) {
-        const message = typeof result.stderr === "string" ? result.stderr : "";
-        const error = new Error(message || `Process exited with code ${result.status}`);
+        const error = new Error(stderr || `Process exited with code ${result.status}`);
         throw error;
     }
     return {
         args: argv,
         returncode: result.status ?? 1,
         stdout: typeof result.stdout === "string" ? result.stdout : "",
-        stderr: typeof result.stderr === "string" ? result.stderr : "",
+        stderr,
     };
 }
 //# sourceMappingURL=call.js.map

package/dist/scm/design-critique-chip.d.ts

@@ -7,6 +7,7 @@
 import { type DesignCritiqueCatalogChip } from "../design-critique/exclusive-chip.js";
 import type { LabelClient } from "../vbrief-reconcile/types.js";
 export declare const DESIGN_CRITIQUE_CHIP_VERB: "design-critique-chip";
+export declare const CHIP_APPLY_MISS_TOKEN = "chip apply missed (non-blocking convenience)";
 export declare const DESIGN_CRITIQUE_CHIP_USAGE: string;
 export interface DesignCritiqueChipArgs {
     readonly issue: number;

package/dist/scm/design-critique-chip.js

@@ -7,14 +7,16 @@
 import { spawnSync } from "node:child_process";
 import { applyDesignCritiqueCatalogChip, } from "../design-critique/exclusive-chip.js";
 import { parseGithubOwnerRepo } from "../policy/sync-default.js";
-import { ScmLabelClient, ScmLabelError } from "../vbrief-reconcile/labels.js";
+import { ScmLabelClient } from "../vbrief-reconcile/labels.js";
 import { extractFlag, extractValueFlag } from "./argv.js";
 import { InvalidRepoError, splitRepo } from "./gh-rest.js";
 import { pyRepr } from "./py-format.js";
 export const DESIGN_CRITIQUE_CHIP_VERB = "design-critique-chip";
+export const CHIP_APPLY_MISS_TOKEN = "chip apply missed (non-blocking convenience)";
 export const DESIGN_CRITIQUE_CHIP_USAGE = "usage: scm issue design-critique-chip --issue N --chip triage-ready|mechanism-shaped [--repo OWNER/NAME] [--json]\n" +
     "       Parent attach of design-critique:triage-ready / recut mechanism-shaped.\n" +
-    "       Closed catalog remaining-set replace. One write. Other facets stay.\n";
+    "       Closed catalog remaining-set replace. One write. Other facets stay.\n" +
+    "       Apply miss is non-blocking convenience; ingest is not blocked.\n";
 const CHIP_ALIASES = {
     "triage-ready": "design-critique:triage-ready",
     "mechanism-shaped": "design-critique:mechanism-shaped",
@@ -161,11 +163,25 @@ export function runDesignCritiqueChip(extra, seams = {}) {
         };
     }
     catch (err) {
-        if (err instanceof ScmLabelError) {
-            return { exitCode: 1, stdout: "", stderr: `error: ${err.message}\n` };
-        }
         const message = err instanceof Error ? err.message : String(err);
-        return { exitCode: 1, stdout: "", stderr: `error: ${message}\n` };
+        const payload = {
+            repo,
+            issue: args.issue,
+            chip: args.chip,
+            applied: false,
+            miss: true,
+            blocking: false,
+            error: message,
+        };
+        if (args.json) {
+            return { exitCode: 0, stdout: `${JSON.stringify(payload)}\n`, stderr: "" };
+        }
+        return {
+            exitCode: 0,
+            stdout: "",
+            stderr: `${CHIP_APPLY_MISS_TOKEN}: ${message}\n` +
+                "ingest is not blocked; remaining-set hygiene is optional for a write-capable identity\n",
+        };
     }
 }
 //# sourceMappingURL=design-critique-chip.js.map

package/dist/scm/gh-rest.d.ts

@@ -53,7 +53,7 @@ export interface RestIssueListOptions {
 export declare function restIssueList(repo: string, options?: RestIssueListOptions, seams?: GhRestSeams): Record<string, unknown>[];
 export declare const REST_MAX_PER_PAGE = 100;
 export declare const REST_PAGINATION_MAX_PAGES = 100;
-export declare const PUBLIC_HELPERS: readonly ["restCreateIssue", "restPostComment", "restUpdateComment", "restDeleteComment", "restGetUser", "restUpdateIssue", "restCreateLabel", "restCloseIssue", "restOpenPr", "restMergePr", "restIssueView", "restPrView", "restIssueList", "restIssueListPaginated"];
+export declare const PUBLIC_HELPERS: readonly ["restCreateIssue", "restPostComment", "restUpdateComment", "restDeleteComment", "restGetUser", "restUpdateIssue", "restCreateLabel", "restCloseIssue", "restOpenPr", "restMergePr", "restIssueView", "restPrView", "restIssueList", "restIssueListPaginated", "restIssueListOpenInventory"];
 export declare function restCreateIssue(repo: string, title: string, body: string, labels?: readonly string[], seams?: GhRestSeams): Record<string, unknown>;
 export declare function restPostComment(repo: string, n: number, body: string, seams?: GhRestSeams): Record<string, unknown>;
 /** `PATCH /repos/{owner}/{repo}/issues/comments/{id}` -- edit a PR/issue comment in place. */
@@ -78,5 +78,13 @@ export interface RestIssueListPaginatedOptions extends RestIssueListOptions {
     readonly limit?: number | null;
     readonly excludePulls?: boolean;
 }
+/** Flatten `gh api --paginate --slurp` issue-list output (pages or single page). */
+export declare function flattenOpenInventoryPayload(parsed: unknown[], endpoint: string): Record<string, unknown>[];
+/**
+ * Complete open-issue inventory in one `gh api --paginate --slurp` subprocess (#3752).
+ * Fail-closed on command failure, non-array JSON, buffer exhaustion, or cap hit.
+ * Pull-request rows are excluded.
+ */
+export declare function restIssueListOpenInventory(repo: string, seams?: GhRestSeams): Record<string, unknown>[];
 export declare function restIssueListPaginated(repo: string, options?: RestIssueListPaginatedOptions, seams?: GhRestSeams): Record<string, unknown>[];
 //# sourceMappingURL=gh-rest.d.ts.map

package/dist/scm/gh-rest.js

@@ -183,6 +183,7 @@ export const PUBLIC_HELPERS = [
     "restPrView",
     "restIssueList",
     "restIssueListPaginated",
+    "restIssueListOpenInventory",
 ];
 function writeJsonPayload(payload) {
     const dir = mkdtempSync(join(tmpdir(), "gh_rest_payload_"));
@@ -331,6 +332,108 @@ export function restPrView(repo, n, seams = {}) {
         whichFn: seams.whichFn,
     });
 }
+const OPEN_INVENTORY_MAX_ISSUES = REST_PAGINATION_MAX_PAGES * REST_MAX_PER_PAGE;
+function issueRowOrThrow(item, endpoint) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+        throw new GhRestError({
+            stderr: "open-issue inventory row is not an object",
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "REST issue list rows must be objects",
+        });
+    }
+    return item;
+}
+/** Flatten `gh api --paginate --slurp` issue-list output (pages or single page). */
+export function flattenOpenInventoryPayload(parsed, endpoint) {
+    if (parsed.length === 0) {
+        return [];
+    }
+    const out = [];
+    const allPages = parsed.every((item) => Array.isArray(item));
+    if (allPages) {
+        for (const page of parsed) {
+            if (!Array.isArray(page)) {
+                continue;
+            }
+            for (const item of page) {
+                const row = issueRowOrThrow(item, endpoint);
+                if ("pull_request" in row) {
+                    continue;
+                }
+                out.push(row);
+            }
+        }
+        return out;
+    }
+    for (const item of parsed) {
+        const row = issueRowOrThrow(item, endpoint);
+        if ("pull_request" in row) {
+            continue;
+        }
+        out.push(row);
+    }
+    return out;
+}
+/**
+ * Complete open-issue inventory in one `gh api --paginate --slurp` subprocess (#3752).
+ * Fail-closed on command failure, non-array JSON, buffer exhaustion, or cap hit.
+ * Pull-request rows are excluded.
+ */
+export function restIssueListOpenInventory(repo, seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues?state=open&per_page=${REST_MAX_PER_PAGE}`;
+    const runner = seams.runGhApiFn ?? runGhApi;
+    const result = runner(["--paginate", "--slurp", endpoint], { timeout: 120 });
+    if (result.returncode !== 0) {
+        throw new GhRestError({
+            stderr: result.stderr.trim(),
+            exitCode: result.returncode,
+            endpoint,
+            payload: null,
+            hint: "verify gh auth and core REST quota; open-issue inventory must be complete",
+        });
+    }
+    const stdout = result.stdout.trim();
+    if (stdout.length === 0) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        throw new GhRestError({
+            stderr: `non-JSON open-issue inventory: ${message}`,
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "gh api --paginate --slurp must return a JSON array",
+        });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new GhRestError({
+            stderr: `unexpected top-level type ${typeof parsed}`,
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "open-issue inventory must be a JSON array",
+        });
+    }
+    const out = flattenOpenInventoryPayload(parsed, endpoint);
+    if (out.length >= OPEN_INVENTORY_MAX_ISSUES) {
+        throw new GhRestError({
+            stderr: `open-issue inventory reached cap ${OPEN_INVENTORY_MAX_ISSUES}; pagination may be incomplete`,
+            exitCode: 0,
+            endpoint,
+            payload: null,
+            hint: "repo may exceed supported open-issue count; fail closed rather than truncate",
+        });
+    }
+    return out;
+}
 export function restIssueListPaginated(repo, options = {}, seams = {}) {
     const cappedPerPage = Math.min(Math.max(1, options.perPage ?? REST_MAX_PER_PAGE), REST_MAX_PER_PAGE);
     const [owner, name] = splitRepo(repo);

package/dist/scm/readiness.d.ts

@@ -41,6 +41,8 @@ export interface ScmReadinessReport {
     readonly githubAuthMode: string;
     /** Runtime mode from the #1557a probe. */
     readonly runtimeMode: string;
+    /** Stable id naming why the runtime was classified that way (#3859). */
+    readonly runtimeModeReason: string | null;
     /** Whether an injected token env var is present (value never reported). */
     readonly injectedTokenPresent: boolean;
     /** Probe depth used for this report. */

package/dist/scm/readiness.js

@@ -21,6 +21,7 @@
 import { spawnSync } from "node:child_process";
 import { findInjectedToken, GITHUB_AUTH_MODE_HOST_GH, GITHUB_AUTH_MODE_INJECTED_TOKEN, inferGithubAuthMode, validateGithubAuthForWorker, } from "../intake/github-auth-modes.js";
 import { getPlatformCapabilities, probeRuntimeCapabilities, } from "../intake/platform-capabilities.js";
+import { EXPLICIT_SELECTION_REMEDIATION, GITHUB_AUTH_MODE_ENV, RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS, } from "../platform/cursor-managed-runtime.js";
 import { defaultWhich } from "./binary.js";
 import { BINARY_PREFERENCE } from "./constants.js";
 import { ScmStubError } from "./errors.js";
@@ -138,6 +139,7 @@ export function probeScmReadiness(options = {}) {
             authState: "binary-absent",
             githubAuthMode,
             runtimeMode: runtimeReport.runtimeMode,
+            runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
             injectedTokenPresent,
             depth,
             detail,
@@ -149,9 +151,11 @@ export function probeScmReadiness(options = {}) {
     }
     // Injected-token mode without a token is a hard not-ready even before auth status.
     if (githubAuthMode === GITHUB_AUTH_MODE_INJECTED_TOKEN && !injectedTokenPresent) {
+        const ambiguousRuntime = runtimeReport.runtimeModeReason === RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS;
         const detail = "injected-token mode requires GH_TOKEN, GITHUB_TOKEN, or GH_ENTERPRISE_TOKEN; " +
             `binary=${binary} present but SCM-dependent gates skipped ` +
-            `(runtime_mode=${runtimeReport.runtimeMode})`;
+            `(runtime_mode=${runtimeReport.runtimeMode}` +
+            `${runtimeReport.runtimeModeReason ? `, reason=${runtimeReport.runtimeModeReason}` : ""})`;
         return {
             ready: false,
             binary,
@@ -159,10 +163,15 @@ export function probeScmReadiness(options = {}) {
             authState: "missing-token",
             githubAuthMode,
             runtimeMode: runtimeReport.runtimeMode,
+            runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
             injectedTokenPresent: false,
             depth,
             detail,
-            remediation: REMEDIATION_MISSING_TOKEN,
+            // An ambiguous Cursor runtime is the #3859 case: name the explicit opt-in
+            // here, because this is where the operator actually meets the block.
+            remediation: ambiguousRuntime
+                ? `${EXPLICIT_SELECTION_REMEDIATION}\n\n${REMEDIATION_MISSING_TOKEN}`
+                : REMEDIATION_MISSING_TOKEN,
             skippedGates: [...SCM_DEPENDENT_GATES],
             login: null,
             failureKind: "missing_injected_token",
@@ -209,6 +218,7 @@ export function probeScmReadiness(options = {}) {
                 authState: "authenticated",
                 githubAuthMode: deep.githubAuthMode,
                 runtimeMode: runtimeReport.runtimeMode,
+                runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
                 injectedTokenPresent,
                 depth,
                 detail: `SCM ready: ${binary} present, ${deep.githubAuthMode} authenticated${loginPart} (deep)`,
@@ -226,6 +236,7 @@ export function probeScmReadiness(options = {}) {
             authState,
             githubAuthMode: deep.githubAuthMode,
             runtimeMode: runtimeReport.runtimeMode,
+            runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
             injectedTokenPresent,
             depth,
             detail: `SCM not ready: ${deep.detail}`,
@@ -247,6 +258,7 @@ export function probeScmReadiness(options = {}) {
             authState: "unknown",
             githubAuthMode,
             runtimeMode: runtimeReport.runtimeMode,
+            runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
             injectedTokenPresent,
             depth,
             detail,
@@ -268,6 +280,7 @@ export function probeScmReadiness(options = {}) {
             authState: "unauthenticated",
             githubAuthMode,
             runtimeMode: runtimeReport.runtimeMode,
+            runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
             injectedTokenPresent,
             depth,
             detail,
@@ -284,6 +297,7 @@ export function probeScmReadiness(options = {}) {
         authState: "authenticated",
         githubAuthMode,
         runtimeMode: runtimeReport.runtimeMode,
+        runtimeModeReason: runtimeReport.runtimeModeReason ?? null,
         injectedTokenPresent,
         depth,
         detail: `SCM ready: ${binary} present, ${githubAuthMode} authenticated (shallow)`,
@@ -302,6 +316,7 @@ export function scmReadinessToDict(report) {
         auth_state: report.authState,
         github_auth_mode: report.githubAuthMode,
         runtime_mode: report.runtimeMode,
+        runtime_mode_reason: report.runtimeModeReason,
         injected_token_present: report.injectedTokenPresent,
         depth: report.depth,
         detail: report.detail,
@@ -324,7 +339,14 @@ export function formatScmReadinessLines(report) {
     }
     lines.push(`[deft scm] ${report.detail}`);
     if (report.skippedGates.length > 0) {
-        lines.push(`[deft scm] skipped gates: ${report.skippedGates.join(", ")}`);
+        // Name the classification reason next to the skip: a silent skip is what
+        // makes this failure costly, because work-selection surfaces go dark (#3859).
+        const reason = report.runtimeModeReason ? ` (reason: ${report.runtimeModeReason})` : "";
+        lines.push(`[deft scm] skipped gates: ${report.skippedGates.join(", ")}${reason}`);
+        if (report.runtimeModeReason === RUNTIME_REASON_CURSOR_MARKER_AMBIGUOUS) {
+            lines.push(`[deft scm] runtime is ambiguous; set ${GITHUB_AUTH_MODE_ENV}=host-gh to authorize ` +
+                "the host gh credential store on a machine you control (#3859)");
+        }
     }
     lines.push("[deft scm] run SCM-dependent gates only after auth is ready, or from a matched env; " +
         "see content/scm/github.md § Mismatched/headless SCM readiness (#2275)");
@@ -387,13 +409,15 @@ export function requireScmReady(options = {}) {
     if (hermeticAuthSkip) {
         // Production path uses assertScmBinaryPresent (not test-only).
         const binary = assertScmBinaryPresent(options.whichFn);
+        const hermeticRuntime = options.runtimeReport ?? getPlatformCapabilities();
         const report = {
             ready: true,
             binary,
             binaryPath: options.whichFn?.(binary) ?? null,
             authState: "unknown",
             githubAuthMode: GITHUB_AUTH_MODE_HOST_GH,
-            runtimeMode: (options.runtimeReport ?? getPlatformCapabilities()).runtimeMode,
+            runtimeMode: hermeticRuntime.runtimeMode,
+            runtimeModeReason: hermeticRuntime.runtimeModeReason ?? null,
             injectedTokenPresent: findInjectedToken(options.env ?? process.env) !== null,
             depth: "shallow",
             detail: `SCM binary present (${binary}); auth status not checked (hermetic)`,

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

@@ -1,16 +1,23 @@
 import { dirname, resolve } from "node:path";
-import { resolveProjectDefinitionPath } from "../layout/resolve.js";
-import { atomicWriteProjectDefinition, loadProjectDefinitionForMutation, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
+import { withProjectDefinitionMutation } from "../vbrief-build/project-definition-mutation.js";
 import { syncRegistryArtifactAfterScopeMove } from "./registry-artifact-sync.js";
 /** 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));
     try {
-        projectDefinitionMutationLock(projectRoot, () => {
-            const projectDefPath = resolveProjectDefinitionPath(projectRoot);
-            syncRegistryArtifactAfterScopeMove(projectDefPath, scopeData, oldPath, newPath, vbriefRoot, targetStatus, {
-                loadForMutation: () => loadProjectDefinitionForMutation(projectRoot),
-                persist: (path, data) => atomicWriteProjectDefinition(path, data),
+        withProjectDefinitionMutation(projectRoot, (mutation) => {
+            syncRegistryArtifactAfterScopeMove(
+            // The artifact the lock captured, not an independent re-resolution (#3796).
+            mutation.artifactPath, scopeData, oldPath, newPath, vbriefRoot, targetStatus, {
+                loadForMutation: () => [mutation.load(), mutation.artifactPath],
+                persist: (path, data) => {
+                    // The registry sync echoes back the path it was handed, so a
+                    // mismatch means something re-resolved the artifact mid-section.
+                    if (resolve(path) !== resolve(mutation.artifactPath)) {
+                        throw new Error("refusing to persist PROJECT-DEFINITION to a path other than the locked artifact");
+                    }
+                    mutation.persist(data);
+                },
             });
         });
         return null;

package/dist/session/git.d.ts

@@ -5,11 +5,35 @@ export interface GitRunResult {
 }
 export type GitRunner = (projectRoot: string, args: readonly string[]) => GitRunResult;
 export declare const defaultGitRunner: GitRunner;
+/**
+ * Serve a dispatch's repeated ref reads from one `git` child (#3736).
+ *
+ * The host mutation gate resolved HEAD, the worktree root, and the branch with
+ * a separate spawn each, twice over; on a loaded Windows box a spawn measured a
+ * 2.2s p50, so every concurrent agent's hook slowed every other agent's hook.
+ * The probe is lazy on purpose: it only fires for a read it can actually
+ * answer, so a caller that never asks for context never pays for it.
+ */
+export declare function memoizeGitRunner(runGit?: GitRunner): GitRunner;
 export declare function gitHead(projectRoot: string, runGit?: GitRunner): {
     head: string | null;
     error: string | null;
 };
 export declare function worktreePath(projectRoot: string, runGit?: GitRunner): string;
+/**
+ * Walk from `targetPath` to the nearest existing directory. A write that
+ * creates a missing nested file is the common case; git cannot use a
+ * nonexistent cwd.
+ */
+export declare function existingAncestorDir(targetPath: string): string | null;
+/**
+ * Failure-expressing sibling of {@link worktreePath}. Returns null instead of
+ * falling back to `startDir` so a missing git tree is distinguishable from
+ * success (#3794).
+ */
+export declare function worktreePathOrNull(startDir: string, runGit?: GitRunner): string | null;
+/** Absolute `--git-common-dir` for `projectRoot`, or null on failure. */
+export declare function gitCommonDir(projectRoot: string, runGit?: GitRunner): string | null;
 /** True when `ancestor` is reachable from `descendant` (same commit counts). */
 export declare function gitIsAncestor(projectRoot: string, ancestor: string, descendant: string, runGit?: GitRunner): boolean | null;
 /**