@deftai/directive-core 0.107.0 → 0.109.0

package/dist/pr-protected-issues/gh.js

@@ -1,24 +1,55 @@
 import { execFileSync } from "node:child_process";
-import { resolveBinary } from "../scm/binary.js";
+import { defaultWhich } from "../scm/binary.js";
+import { classifyScmArgv, resolveBinaryForArgv } from "../scm/call-shape.js";
+import { ghxSpawnFallbackBinary } from "../scm/spawn-status.js";
 import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 import { GH_TIMEOUT_S } from "./constants.js";
-/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
-export function defaultRunGh(cmd) {
+/**
+ * UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366).
+ * `binaryOverride` lets a caller pin the SCM binary (e.g. plain `gh` instead of
+ * the `ghx` cached proxy) when its guarantee depends on an uncached read (#3767).
+ */
+export function defaultRunGh(cmd, binaryOverride) {
     if (cmd.length === 0 || cmd[0] !== "gh") {
         return { returncode: -1, stdout: "", stderr: "expected gh as first argv element" };
     }
-    const binary = resolveBinary();
     const args = cmd.slice(1);
+    const binary = binaryOverride ?? resolveBinaryForArgv(args[0] ?? "", args.slice(1));
+    const execOpts = {
+        encoding: "utf8",
+        timeout: GH_TIMEOUT_S * 1000,
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+    };
+    const runOnce = (bin) => execFileSync(bin, args, execOpts);
     try {
-        const stdout = execFileSync(binary, args, {
-            encoding: "utf8",
-            timeout: GH_TIMEOUT_S * 1000,
-            stdio: ["ignore", "pipe", "pipe"],
-            maxBuffer: SUBPROCESS_MAX_BUFFER,
-        });
+        const stdout = runOnce(binary);
         return { returncode: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
     }
-    catch (err) {
+    catch (caught) {
+        let err = caught;
+        const first = err;
+        const retry = binaryOverride === undefined
+            ? ghxSpawnFallbackBinary(classifyScmArgv(args[0] ?? "", args.slice(1)), binary, defaultWhich, {
+                status: typeof first.status === "number" ? first.status : null,
+                error: first.code === "ENOENT" ||
+                    first.code === "ETIMEDOUT" ||
+                    typeof first.status !== "number"
+                    ? { code: first.code, message: first.message }
+                    : undefined,
+                stdout: typeof first.stdout === "string" ? first.stdout : "",
+                stderr: typeof first.stderr === "string" ? first.stderr : "",
+            })
+            : null;
+        if (retry !== null) {
+            try {
+                const stdout = runOnce(retry);
+                return { returncode: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
+            }
+            catch (retryErr) {
+                err = retryErr;
+            }
+        }
         const e = err;
         if (e.code === "ENOENT") {
             return { returncode: -1, stdout: "", stderr: "gh CLI not found. Install GitHub CLI." };

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

@@ -1,7 +1,7 @@
 import { type EnforceMergeApprovalHeadInput, type MergeApprovalHeadResult } from "../policy/merge-approval-head.js";
 import { type AgentMergeEvaluateResult } from "../policy/require-human-merge.js";
 import { type SemanticGreenFn } from "./semantic-green.js";
-import type { MergeFn, MonitorFn, ProtectedCheckFn, WaitMergeableResult } from "./types.js";
+import type { CloseoutAttestableFn, MergeFn, MonitorFn, ProtectedCheckFn, WaitMergeableResult } from "./types.js";
 /** Post-merge umbrella checklist + current-shape refresh (#1649). */
 export type UmbrellaReconcileFn = (projectRoot: string, repo: string) => void;
 export interface WaitMergeableOptions {
@@ -32,6 +32,14 @@ export interface WaitMergeableOptions {
     readonly skipMergeApprovalHeadGate?: boolean;
     /** Inject head-bound approval enforcer (unit tests). */
     readonly mergeApprovalHeadFn?: (input: EnforceMergeApprovalHeadInput) => MergeApprovalHeadResult;
+    /**
+     * When true, skip the merge-time closeout attestability gate (#3781).
+     * Default: same as skipHumanMergeGate, matching the head-gate convention —
+     * test harnesses that skip human-merge also skip this unless they opt in.
+     */
+    readonly skipCloseoutAttestableGate?: boolean;
+    /** Inject the closeout attestability gate (unit tests). */
+    readonly closeoutAttestableFn?: CloseoutAttestableFn;
     /** Inject PR HEAD fetch (unit tests; defaults to REST `pulls/<N>`). */
     readonly fetchPrHeadShaFn?: (prNumber: number, repo: string | null) => string | null;
     /**

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

@@ -6,7 +6,7 @@ import { classifyMonitorOutcome, parseMonitorPayload } from "./classify.js";
 import { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
 import { makeResult } from "./result.js";
 import { evaluateSemanticGreen } from "./semantic-green.js";
-import { runGhMerge, runMonitor, runProtectedCheck } from "./wrappers.js";
+import { runCloseoutAttestableCheck, runGhMerge, runMonitor, runProtectedCheck, } from "./wrappers.js";
 /** Node module-not-found / missing script — not a protected-issue overlap (#2667). */
 function isProtectedCheckConfigFailure(stderr) {
     const tail = stderr.trim();
@@ -228,6 +228,26 @@ export function waitMergeableAndMerge(prNumber, repo, options) {
             }
         }
     }
+    // #3781: last gate before the merge call. A PR may leave a brief unattested; it
+    // may not merge one whose issue it closes in the same act. Keyed on the PR's
+    // closing references, so it fires even when the brief is not in the branch diff.
+    const skipCloseoutGate = options.skipCloseoutAttestableGate === true ||
+        (options.skipCloseoutAttestableGate === undefined && options.skipHumanMergeGate === true);
+    if (!skipCloseoutGate) {
+        const closeoutFn = options.closeoutAttestableFn ?? runCloseoutAttestableCheck;
+        const [coRc, , coStderr] = closeoutFn(prNumber, repo, projectRoot);
+        if (coRc !== 0) {
+            return makeResult({
+                prNumber,
+                repo,
+                outcome: coRc === 1 ? "closeout-unattested" : "config-error",
+                exitCode: coRc === 1 ? EXIT_TIMEOUT_OR_ESCALATION : EXIT_CONFIG_ERROR,
+                monitorResult: monitorPayload,
+                protectedCheck: protectedCheckPayload,
+                error: coStderr.trim(),
+            });
+        }
+    }
     const [mergeRc, mergeStdout, mergeStderr] = mergeFn(prNumber, repo, {
         matchHeadCommit,
     });

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

@@ -18,4 +18,6 @@ export type MonitorFn = (prNumber: number, repo: string, capMinutes: number, opt
 export type MergeFn = (prNumber: number, repo: string | null, options?: {
     readonly matchHeadCommit?: string | null;
 }) => SubprocessTriple;
+/** Merge-time closeout attestability gate (#3781): 0 attestable / 1 unattested / 2 lookup. */
+export type CloseoutAttestableFn = (prNumber: number, repo: string | null, projectRoot: string) => SubprocessTriple;
 //# sourceMappingURL=types.d.ts.map

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

@@ -32,6 +32,12 @@ export interface RunProtectedCheckOptions {
 }
 /** Invoke pr-protected-issues CLI and return (returncode, stdout, stderr). */
 export declare function runProtectedCheck(prNumber: number, repo: string | null, protectedIssues: readonly number[], options?: RunProtectedCheckOptions): SubprocessTriple;
+/**
+ * Merge-time closeout attestability gate (#3781). In-process: the evaluator lives
+ * in this package, and a subprocess hop would only add a script-path failure mode
+ * to a gate that must fail closed.
+ */
+export declare function runCloseoutAttestableCheck(prNumber: number, repo: string | null, projectRoot: string): SubprocessTriple;
 export interface RunMonitorOptions {
     readonly nodeExecutable?: string;
     readonly timeout?: number;

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

@@ -3,7 +3,8 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveBinary } from "../scm/binary.js";
+import { evaluate as evaluateCloseoutAttestable } from "../pr-closeout-attestable/evaluate.js";
+import { resolveBinaryForArgv } from "../scm/call-shape.js";
 import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 /** UTF-8-safe subprocess capture via spawnSync (no shell) — mirrors #1366. */
 export function captureExec(executable, args, timeoutMs, options = {}) {
@@ -97,6 +98,16 @@ export function runProtectedCheck(prNumber, repo, protectedIssues, options = {})
     });
     return [result.returncode, result.stdout, result.stderr];
 }
+/**
+ * Merge-time closeout attestability gate (#3781). In-process: the evaluator lives
+ * in this package, and a subprocess hop would only add a script-path failure mode
+ * to a gate that must fail closed.
+ */
+export function runCloseoutAttestableCheck(prNumber, repo, projectRoot) {
+    const result = evaluateCloseoutAttestable(projectRoot, prNumber, { repo });
+    const text = result.message.length > 0 ? `${result.message}\n` : "";
+    return result.code === 0 ? [0, text, ""] : [result.code, "", text];
+}
 /** Invoke pr-monitor CLI with --json and return (returncode, stdout, stderr). */
 export function runMonitor(prNumber, repo, capMinutes, options = {}) {
     const scriptPath = cliScriptPath("pr-monitor");
@@ -129,14 +140,14 @@ export function runMonitor(prNumber, repo, capMinutes, options = {}) {
 /** Invoke ``gh pr merge --squash --delete-branch --admin`` [``--match-head-commit``]. */
 export function runGhMerge(prNumber, repo, options = {}) {
     const timeoutSec = options.timeout ?? 120;
+    const args = ["pr", "merge", String(prNumber), "--squash", "--delete-branch", "--admin"];
     let binary;
     try {
-        binary = resolveBinary();
+        binary = resolveBinaryForArgv("pr", args.slice(1));
     }
     catch {
         return [-1, "", "gh CLI not found. Install GitHub CLI."];
     }
-    const args = ["pr", "merge", String(prNumber), "--squash", "--delete-branch", "--admin"];
     if (repo) {
         args.push("--repo", repo);
     }

package/dist/preflight/evaluate.d.ts

@@ -6,6 +6,19 @@ export declare const ACTIVE_FOLDER = "active";
 export declare const ELIGIBLE_STATUS = "running";
 /** Actionable redirect appended to every reject path (#810 / #2449). */
 export declare const ACTIVATE_HINT = "Run `task scope:activate -- {path}` (or legacy `task vbrief:activate -- {path}`) before spawning an implementation agent.";
+/**
+ * Recovery for the origin-freshness reject (#3828).
+ *
+ * Freshness is only reached after the active/ + running checks pass, so
+ * `ACTIVATE_HINT` names a transition that cannot apply here: `activate` accepts
+ * `pending/` alone and fails with `Invalid transition: 'activate' requires file
+ * in pending/`. `block` -> `unblock` is in place (`targetFolder: null`), requires
+ * and restores `running`, and stamps `plan.updated` plus `xBRIEFInfo.updated`,
+ * the field this reject compares. It is interim: the pair also records a
+ * `blocked` -> `running` transition for a brief that was never blocked, a
+ * tradeoff accepted knowingly. #3857 owns the dedicated acknowledge verb.
+ */
+export declare const ORIGIN_FRESHNESS_HINT: string;
 /** Lifecycle folder names eligible for implementation (#810). */
 export declare const ELIGIBLE_LIFECYCLE_DIRS: readonly ["xbrief/active", "vbrief/active"];
 export declare const PREFLIGHT_USAGE_HINT = "Expected: `task xbrief:preflight -- xbrief/active/<story>.xbrief.json` (legacy: `task vbrief:preflight -- <path>`).";
@@ -32,6 +45,8 @@ export interface EvaluateOptions {
 }
 /** Substitute `{path}` without `$`-pattern expansion in user paths (#1721). */
 export declare function formatActivateHint(path: string): string;
+/** Substitute every `{path}` without `$`-pattern expansion in user paths (#1721). */
+export declare function formatOriginFreshnessHint(path: string): string;
 /**
  * Pure evaluator — returns `{ exitCode, message }`. Never throws; every error
  * path collapses to exit 1 with an actionable message. Faithful to

package/dist/preflight/evaluate.js

@@ -11,6 +11,26 @@ export const ACTIVE_FOLDER = "active";
 export const ELIGIBLE_STATUS = "running";
 /** Actionable redirect appended to every reject path (#810 / #2449). */
 export const ACTIVATE_HINT = "Run `task scope:activate -- {path}` (or legacy `task vbrief:activate -- {path}`) before spawning an implementation agent.";
+/**
+ * Recovery for the origin-freshness reject (#3828).
+ *
+ * Freshness is only reached after the active/ + running checks pass, so
+ * `ACTIVATE_HINT` names a transition that cannot apply here: `activate` accepts
+ * `pending/` alone and fails with `Invalid transition: 'activate' requires file
+ * in pending/`. `block` -> `unblock` is in place (`targetFolder: null`), requires
+ * and restores `running`, and stamps `plan.updated` plus `xBRIEFInfo.updated`,
+ * the field this reject compares. It is interim: the pair also records a
+ * `blocked` -> `running` transition for a brief that was never blocked, a
+ * tradeoff accepted knowingly. #3857 owns the dedicated acknowledge verb.
+ */
+export const ORIGIN_FRESHNESS_HINT = "Recovery: this xBRIEF is already in active/ at status running. " +
+    "Once you have re-read the origin delta, stamp xBRIEFInfo.updated in place with " +
+    "`task scope:block -- {path}` then `task scope:unblock -- {path}`. " +
+    "That pair is interim: it records a blocked -> running transition for a brief " +
+    "that was never blocked, and #3857 owns the verb that records the " +
+    "acknowledgement honestly. If the origin could not be fetched or compared, " +
+    "restore `gh` REST access to the origin repository first -- a stamp does not " +
+    "clear that.";
 /** Lifecycle folder names eligible for implementation (#810). */
 export const ELIGIBLE_LIFECYCLE_DIRS = ["xbrief/active", "vbrief/active"];
 export const PREFLIGHT_USAGE_HINT = "Expected: `task xbrief:preflight -- xbrief/active/<story>.xbrief.json` (legacy: `task vbrief:preflight -- <path>`).";
@@ -18,8 +38,12 @@ export const PREFLIGHT_USAGE_HINT = "Expected: `task xbrief:preflight -- xbrief/
 export function formatActivateHint(path) {
     return ACTIVATE_HINT.replace("{path}", () => path);
 }
-function buildReject(path, reason) {
-    return `${reason}\n  ${PREFLIGHT_USAGE_HINT}\n  ${formatActivateHint(path)}`;
+/** Substitute every `{path}` without `$`-pattern expansion in user paths (#1721). */
+export function formatOriginFreshnessHint(path) {
+    return ORIGIN_FRESHNESS_HINT.split("{path}").join(path);
+}
+function buildReject(path, reason, hint) {
+    return `${reason}\n  ${PREFLIGHT_USAGE_HINT}\n  ${hint ?? formatActivateHint(path)}`;
 }
 /** Map Node `JSON.parse` errors to CPython `json.JSONDecodeError.msg` for parity (#1721). */
 function nodeJsonErrorToPythonMsg(nodeMessage) {
@@ -167,7 +191,9 @@ export function evaluate(vbriefPath, options = {}) {
         return {
             exitCode: 1,
             parentLineage: lineage,
-            message: buildReject(path, originFreshness.message),
+            // #3828: the brief is active + running by this point, so the activate
+            // hint would name a transition that hard-errors from the printed state.
+            message: buildReject(path, originFreshness.message, formatOriginFreshnessHint(path)),
         };
     }
     // #3425: fail closed when an applicable project invariant has no disposition.

package/dist/product-first-done-gate/acceptance-resolver.d.ts

@@ -93,18 +93,30 @@ export declare function resolveAcceptanceVerdict(reading: AcceptanceReading): Ac
 /** One line naming the predicate and the value it read (#3497). */
 export declare function formatAcceptanceVerdict(verdictResult: AcceptanceVerdict): string;
 /**
- * Clause-walk composition (#3323 / #3497).
+ * Clause-walk composition (#3323 / #3497 / #3826).
  *
  * A clause the shipped artifact contradicts (`failed`) always blocks. A clause the
  * static walk cannot decide (`unverifiable`) is evidence of nothing — it blocks only
  * when nothing else verified the product. A green executable acceptance run IS that
  * something: the product-first oracle already ran. Before #3497 an all-unverifiable
  * clause set refused an artifact whose stated command had just exited 0.
+ *
+ * #3826 excused a set the walk has no oracle for at all: a clause with no bound
+ * artifact path can only ever come back `unverifiable`, so demanding a positive
+ * `verified` from a set of them cannot be satisfied by doing the work correctly.
+ * Where the walk has no oracle, `failed === 0` is the strongest verdict available
+ * and `evaluateAcceptanceEvidenceGate` adjudicates those criteria at `scope:complete`.
+ *
+ * #3835 makes that excusal per clause. As a *set* predicate, `verified > 0` was
+ * re-armed for every clause by any single bound one, so one verified binding
+ * covered siblings that had their own oracle and did not meet it.
+ * `adjudicableUnverified` counts exactly those siblings.
  */
 export declare function clauseWalkBlocks(input: {
     readonly failed: number;
-    readonly verified: number;
     readonly walked: number;
+    /** Clauses the walk had an oracle for and that did not come back `verified`. */
+    readonly adjudicableUnverified: number;
     readonly hasGreenExecutableRun: boolean;
 }): boolean;
 /** Which consumer is reading acceptance. Selects one shared option profile (#3497). */

package/dist/product-first-done-gate/acceptance-resolver.js

@@ -106,19 +106,30 @@ export function formatAcceptanceVerdict(verdictResult) {
     return `${lead}\n  remedy: ${verdictResult.remedy}`;
 }
 /**
- * Clause-walk composition (#3323 / #3497).
+ * Clause-walk composition (#3323 / #3497 / #3826).
  *
  * A clause the shipped artifact contradicts (`failed`) always blocks. A clause the
  * static walk cannot decide (`unverifiable`) is evidence of nothing — it blocks only
  * when nothing else verified the product. A green executable acceptance run IS that
  * something: the product-first oracle already ran. Before #3497 an all-unverifiable
  * clause set refused an artifact whose stated command had just exited 0.
+ *
+ * #3826 excused a set the walk has no oracle for at all: a clause with no bound
+ * artifact path can only ever come back `unverifiable`, so demanding a positive
+ * `verified` from a set of them cannot be satisfied by doing the work correctly.
+ * Where the walk has no oracle, `failed === 0` is the strongest verdict available
+ * and `evaluateAcceptanceEvidenceGate` adjudicates those criteria at `scope:complete`.
+ *
+ * #3835 makes that excusal per clause. As a *set* predicate, `verified > 0` was
+ * re-armed for every clause by any single bound one, so one verified binding
+ * covered siblings that had their own oracle and did not meet it.
+ * `adjudicableUnverified` counts exactly those siblings.
  */
 export function clauseWalkBlocks(input) {
     if (input.failed > 0) {
         return true;
     }
-    if (input.walked === 0 || input.verified > 0) {
+    if (input.walked === 0 || input.adjudicableUnverified === 0) {
         return false;
     }
     return !input.hasGreenExecutableRun;

package/dist/product-first-done-gate/evaluate.js

@@ -10,14 +10,14 @@
 import { existsSync, readFileSync } from "node:fs";
 import { basename, isAbsolute, relative, resolve } from "node:path";
 import { emitAcceptanceStampFromPlan, MISSING_AMBIGUITY_ATTESTATION_CAUSE, stampedAmbiguityAttestationError, } from "../intake/clause-derivation.js";
-import { appendLiteralAcceptanceAdvisory, evaluateLiteralAcceptanceFromPlan, isExecutableLiteralSource, isInlineProseMention, isNoopRefusalReason, readNotAcceptanceCommands, readStoredLiteralAcceptanceCommands, runLiteralAcceptanceCommands, stripLiteralAcceptanceAdvisory, } from "../literal-acceptance/index.js";
+import { appendLiteralAcceptanceAdvisory, evaluateLiteralAcceptanceFromPlan, isExecutableLiteralSource, isInlineProseMention, isNoopRefusalReason, isSafetyRefusalRun, readNotAcceptanceCommands, readStoredLiteralAcceptanceCommands, runLiteralAcceptanceCommands, stripLiteralAcceptanceAdvisory, } from "../literal-acceptance/index.js";
 import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter, } from "../run-summary/index.js";
 import { maybeBankOnAcPass } from "../session/ac-pass-banking.js";
 import { resolveAcReuse, resolveScopeIdForAcReuse, snapshotFromReuseFields, } from "../session/ac-pass-reuse.js";
 import { gitHead } from "../session/git.js";
 import { hashProductState } from "../session/product-state-hash.js";
 import { resolveVerifyAcSessionId, writeVerifyAcSessionCache, } from "../session/verify-ac-session-cache.js";
-import { formatClauseWalkMessage, walkAcceptanceClauses, } from "../verify-ac/clauses.js";
+import { countUnverifiedAdjudicableClauses, formatClauseWalkMessage, readDeclaredArtifactScope, walkAcceptanceClauses, } from "../verify-ac/clauses.js";
 import { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, } from "../verify-ac/evaluate.js";
 import { readPlanAcceptance, validatePlanAcceptance } from "./acceptance.js";
 import { clauseWalkBlocks, formatAcceptanceVerdict, resolveAcceptanceVerdict, } from "./acceptance-resolver.js";
@@ -475,21 +475,24 @@ export function emitVerifyAcTerminalOutcome(input) {
         resolvedCommandCount: 0,
     }, { projectRoot: input.projectRoot, env: input.env }, resolve(input.projectRoot));
 }
-function applyClauseWalk(result, options) {
+function applyClauseWalk(result, options, plan) {
     const clauses = result.acceptance.clauses ?? [];
     if (clauses.length === 0 || result.resolution === "config" || result.resolution === "skipped") {
         return result;
     }
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
-    const report = walkAcceptanceClauses(clauses, projectRoot);
+    // #3835: the walk reads files, so it reads only what this brief declared.
+    const report = walkAcceptanceClauses(clauses, projectRoot, {
+        declaredScope: readDeclaredArtifactScope(plan),
+    });
     const message = options.quiet ? result.message : formatClauseWalkMessage(report, result.message);
     // #3497: a clause the static walk cannot decide is evidence of nothing. It blocks
     // only when nothing else verified the product; a green executable acceptance run
     // already is the product-first oracle. Failed clauses still block unconditionally.
     const blocked = clauseWalkBlocks({
         failed: report.failed.length,
-        verified: report.verified.length,
         walked: report.clauses.length,
+        adjudicableUnverified: countUnverifiedAdjudicableClauses(report.clauses),
         hasGreenExecutableRun: result.ok && result.runs.length > 0 && result.runs.every((run) => run.ok),
     });
     const ok = result.ok && !blocked;
@@ -498,8 +501,10 @@ function applyClauseWalk(result, options) {
         ok,
         code: ok ? result.code : result.code === 2 ? 2 : 1,
         message,
+        // #3835: only a clause that actually verified may relabel an empty pass as
+        // verified. A walk that verified nothing has not verified anything.
         resolution: ok
-            ? result.resolution === "empty-pass"
+            ? result.resolution === "empty-pass" && report.verified.length > 0
                 ? "verified-pass"
                 : result.resolution
             : "fail",
@@ -549,8 +554,13 @@ function labelVerdict(result) {
 }
 function applyOracle(result, options, plan = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
-    const walked = applyClauseWalk(applyRejectedNoop(result), options);
-    const gated = walked.clauseWalked === true ? walked : applyEmptyFloorPolicy(walked, options);
+    const walked = applyClauseWalk(applyRejectedNoop(result), options, plan);
+    // #3835: the clause walk may stand in for the empty floor only when it actually
+    // verified something. A walk that verified nothing is not positive evidence, so
+    // an otherwise-empty acceptance still answers to the project floor rather than
+    // passing on the strength of a clause set nothing adjudicated.
+    const walkVerified = (walked.clauseOutcomes ?? []).some((row) => row.outcome === "verified");
+    const gated = walked.clauseWalked === true && walkVerified ? walked : applyEmptyFloorPolicy(walked, options);
     // Emit/read disk only when the caller supplied env (CLI passes process.env).
     // Tests stay isolated unless they opt in with env or runSummaryText.
     if (options.env !== undefined) {
@@ -624,6 +634,10 @@ function annotate(result, acceptance, quiet) {
         message = "";
     }
     const commandCount = Math.max(result.commands.length, acceptance.commands.length);
+    const executedRuns = result.runs.filter((run) => !isSafetyRefusalRun(run));
+    const refusedRuns = result.runs.filter(isSafetyRefusalRun);
+    const hasRefusal = refusedRuns.length > 0 || (result.rejected?.length ?? 0) > 0;
+    const servedFrom = executedRuns.length > 0 ? "executed" : hasRefusal ? "refused" : "executed";
     return {
         ...result,
         message,
@@ -638,7 +652,7 @@ function annotate(result, acceptance, quiet) {
             rejectedCount: result.rejected?.length ?? 0,
         }),
         resolvedCommandCount: result.runs.length > 0 ? result.runs.length : commandCount,
-        servedFrom: "executed",
+        servedFrom,
     };
 }
 /**

package/dist/product-first-done-gate/types.js

@@ -26,7 +26,9 @@ export const HYGIENE_GATE_ID_PREFIXES = [
     "verify:rule-ownership",
     "verify:biome-config",
     "verify:content-manifest",
+    "verify:deposit-closure",
     "verify:skill-external-fetch-gate",
+    "verify:semantic-single-source",
     "verify:cursor-tier1",
     "verify:openclaw-tier1",
     "verify:go-freeze",

package/dist/release/cli-drift-report.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Local-vs-released CLI drift report after a cut (#3753).
+ *
+ * Report-only: never runs `npm i -g`. Never fails the release. Polls all four
+ * workspace packages with `--prefer-online` so a lag-poisoned npm cache cannot
+ * masquerade as a missing publish.
+ */
+import { type ActiveCliCheckResult } from "../session/active-cli.js";
+import type { ReleaseConfig } from "./types.js";
+/** Workspace packages published by npm-publish.yml (sibling propagate is not atomic). */
+export declare const WORKSPACE_PACKAGES: readonly ["@deftai/directive-types", "@deftai/directive-core", "@deftai/directive-content", "@deftai/directive"];
+export type WorkspacePackageName = (typeof WORKSPACE_PACKAGES)[number];
+/** Observed sibling lag was ~7 minutes; Phase 7 wait sits under this ceiling. */
+export declare const CLI_DRIFT_POLL_TIMEOUT_MS: number;
+export declare const CLI_DRIFT_POLL_INTERVAL_MS = 30000;
+/** Pipeline completion is a single probe — Step 13 returns before npm-publish.yml is green. */
+export declare const CLI_DRIFT_PIPELINE_POLL_TIMEOUT_MS = 0;
+export type RegistryVisibility = "all-visible" | "still-propagating" | "publish-incomplete" | "skipped";
+export interface WorkspacePackageProbe {
+    readonly name: WorkspacePackageName;
+    readonly visible: boolean;
+    readonly version: string | null;
+}
+export interface CliDriftReport {
+    readonly releasedVersion: string;
+    readonly localVersion: string | null;
+    readonly localPath: string | null;
+    readonly match: boolean;
+    readonly shadowed: boolean;
+    readonly registry: RegistryVisibility;
+    readonly packages: readonly WorkspacePackageProbe[];
+    readonly remediation: string;
+    readonly lines: readonly string[];
+}
+export interface CliDriftReportSeams {
+    readonly checkActiveCli?: (targetVersion: string) => ActiveCliCheckResult;
+    readonly viewPackage?: (name: WorkspacePackageName, version: string) => WorkspacePackageProbe;
+    readonly nowMs?: () => number;
+    readonly sleepMs?: (ms: number) => void;
+}
+export declare function remediationCommand(version: string): string;
+export declare function npmViewArgs(name: WorkspacePackageName, version: string): string[];
+export declare function defaultViewWorkspacePackage(name: WorkspacePackageName, version: string): WorkspacePackageProbe;
+export declare function classifyRegistryVisibility(opts: {
+    readonly probes: readonly WorkspacePackageProbe[];
+    readonly waitExhausted: boolean;
+    readonly skipped: boolean;
+}): RegistryVisibility;
+export declare function pollWorkspacePackages(version: string, opts: {
+    readonly timeoutMs: number;
+    readonly intervalMs?: number;
+    readonly viewPackage: (name: WorkspacePackageName, version: string) => WorkspacePackageProbe;
+    readonly nowMs?: () => number;
+    readonly sleepMs?: (ms: number) => void;
+}): {
+    readonly probes: readonly WorkspacePackageProbe[];
+    readonly waitExhausted: boolean;
+};
+export declare function shouldSkipRegistryPoll(config: Pick<ReleaseConfig, "dryRun" | "skipTag" | "version">, env?: NodeJS.ProcessEnv): boolean;
+export declare function buildCliDriftReport(releasedVersion: string, opts?: {
+    readonly skipRegistryPoll: boolean;
+    readonly pollTimeoutMs?: number;
+    readonly pollIntervalMs?: number;
+} & CliDriftReportSeams): CliDriftReport;
+export declare function formatCliDriftReport(report: CliDriftReport): string;
+/** Best-effort wrapper — a report failure must never fail the cut. */
+export declare function emitCliDriftReportBestEffort(releasedVersion: string, opts: Parameters<typeof buildCliDriftReport>[1], write?: (text: string) => void): void;
+//# sourceMappingURL=cli-drift-report.d.ts.map