@deftai/directive-core 0.107.0 → 0.109.0

package/dist/vbrief-validate/main.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { resolveLifecycleLayout } from "../layout/resolve.js";
+import { ENV_PROJECT_PATH } from "../vbrief-build/project-definition-io.js";
 import { evaluateConformance } from "./conformance.js";
 import { USAGE } from "./constants.js";
 import { validateAll } from "./validate-all.js";
@@ -130,6 +131,7 @@ export function runConformance(argv) {
     const { exitCode, message } = evaluateConformance(resolve(projectRoot), {
         mode,
         allowListPath,
+        projectDefinitionPath: process.env[ENV_PROJECT_PATH] ?? null,
     });
     if (exitCode === 0) {
         if (!quiet) {

package/dist/vbrief-validate/precutover.js

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { resolveLifecycleLayout, resolveLifecycleRoot, resolveSpecArtifactPath, } from "../layout/resolve.js";
-import { contentHasGeneratedSpecSource, GENERATED_SPEC_PURPOSE, } from "../spec-authority/constants.js";
-import { isFullSpecState, isGreenfieldSpecExport } from "../spec-authority/resolver.js";
+import { resolveLifecycleLayout, resolveLifecycleRoot } from "../layout/resolve.js";
+import { GENERATED_SPEC_PURPOSE } from "../spec-authority/constants.js";
+import { contentHasResolvedSpecSource, isFullSpecState, isGreenfieldSpecExport, } from "../spec-authority/resolver.js";
 import { DEPRECATION_SENTINEL } from "../vbrief-build/constants.js";
 export { DEPRECATION_SENTINEL as DEPRECATED_REDIRECT_SENTINEL };
 const DEPRECATION_REDIRECT_PURPOSE = "<!-- Purpose: deprecation redirect -->";
@@ -27,15 +27,10 @@ export function isDeprecationRedirect(content) {
 }
 /** Full-spec generated export (layout-resolved specification artifact source line). */
 export function isGeneratedSpecificationExport(projectRoot, content) {
-    if (!content.includes(GENERATED_SPEC_PURPOSE) || !contentHasGeneratedSpecSource(content)) {
-        return false;
-    }
-    try {
-        return existsSync(resolveSpecArtifactPath(projectRoot));
-    }
-    catch {
+    if (!content.includes(GENERATED_SPEC_PURPOSE)) {
         return false;
     }
+    return contentHasResolvedSpecSource(projectRoot, content);
 }
 /** Return true for a fully current generated spec export (full-spec or greenfield). */
 export function isCurrentGeneratedSpecification(projectRoot, content) {

package/dist/verify-ac/clauses.d.ts

@@ -21,6 +21,24 @@ export interface ClauseWalkResult {
     readonly artifact_path: string | null;
     readonly outcome: ClauseOutcome;
     readonly detail: string;
+    /**
+     * True when the walk had an oracle for this clause — a path the brief declared
+     * on `plan.metadata.swarm.file_scope`. An unbound or undeclared clause can only
+     * ever come back `unverifiable`, so it carries no weight either way (#3835).
+     */
+    readonly adjudicable: boolean;
+}
+/** Read-scope for the walk. Empty means nothing is read (#3835). */
+export interface ClauseWalkOptions {
+    /**
+     * The brief's declared artifact surface: `plan.metadata.swarm.file_scope`,
+     * which carries the #3145 approved-scope digest and `humanApproval` gate.
+     *
+     * Required rather than optional, and fail-closed when empty: the walk reads
+     * files, and a caller that forgets to pass a scope must read nothing rather
+     * than fall back to whatever path a clause happens to carry.
+     */
+    readonly declaredScope: readonly string[];
 }
 export interface ClauseWalkReport {
     readonly clauses: readonly ClauseWalkResult[];
@@ -30,8 +48,24 @@ export interface ClauseWalkReport {
     readonly ok: boolean;
     readonly message: string;
 }
+/**
+ * Acceptance lines declared on `plan.items` (#3826).
+ *
+ * Prefers `item.narrative.Acceptance`, then `item.title` — criteria routinely live
+ * in the title with an empty `narrative`, which is how a declared acceptance
+ * surface stayed invisible to derivation on #3794 and #3819.
+ */
+export declare function collectPlanItemAcceptanceSurface(plan: Record<string, unknown>): string[];
+export interface ClauseDerivationSources {
+    /**
+     * Declared acceptance lines from `plan.items`. When non-empty this IS the
+     * derived clause set; the statement extractors below are the path for a brief
+     * that declares no items (#3826).
+     */
+    readonly itemSurface?: readonly string[];
+}
 /** Numbered independently testable clauses from the task statement (#3323). */
-export declare function deriveAcceptanceClauses(taskStatement: string): AcceptanceClause[];
+export declare function deriveAcceptanceClauses(taskStatement: string, sources?: ClauseDerivationSources): AcceptanceClause[];
 export declare function readAcceptanceClauses(acceptance: unknown): AcceptanceClause[];
 export declare function serializeAcceptanceClauses(clauses: readonly AcceptanceClause[]): Record<string, unknown>[];
 /**
@@ -43,7 +77,33 @@ export declare function stampDerivedClausesOnAcceptance(plan: Record<string, unk
     readonly clauses: readonly AcceptanceClause[];
 };
 export declare function isScratchArtifactPath(artifactPath: string): boolean;
-export declare function walkAcceptanceClauses(clauses: readonly AcceptanceClause[], projectRoot: string): ClauseWalkReport;
+/**
+ * The declared artifact surface for a brief: `plan.metadata.swarm.file_scope`.
+ *
+ * This is the only surface the walk reads from (#3835). It sits inside the
+ * xBRIEF, so a GitHub commenter cannot write it, and it is already gated by the
+ * #3145 approved-scope digest and `humanApproval` stamp.
+ */
+export declare function readDeclaredArtifactScope(plan: unknown): string[];
+/** True when the clause binding is a declared entry or sits under a declared directory. */
+export declare function isDeclaredArtifactPath(artifactPath: string, declaredScope: readonly string[]): boolean;
+/**
+ * Clauses the walk had an oracle for — bound to a declared artifact path.
+ *
+ * A clause with no oracle can only ever be `unverifiable`, so requiring a positive
+ * `verified` from a set of them is unsatisfiable by correct work rather than a
+ * quality bar (#3826).
+ */
+export declare function countAdjudicableClauses(rows: readonly ClauseWalkResult[]): number;
+/**
+ * Adjudicable clauses the walk did not verify.
+ *
+ * #3826 made `verified > 0` a *set* predicate excused by an empty oracle set, so
+ * one bound-and-verified clause re-armed the whole set and covered siblings with
+ * their own unmet oracle. Counting per clause is what removes that seam (#3835).
+ */
+export declare function countUnverifiedAdjudicableClauses(rows: readonly ClauseWalkResult[]): number;
+export declare function walkAcceptanceClauses(clauses: readonly AcceptanceClause[], projectRoot: string, options: ClauseWalkOptions): ClauseWalkReport;
 /** Done reports lead with failed/unverifiable; unverifiable is never dropped. */
 export declare function formatClauseWalkMessage(report: Omit<ClauseWalkReport, "message"> & {
     readonly message?: string;

package/dist/verify-ac/clauses.js

@@ -133,14 +133,44 @@ function collectPathBearingLines(text) {
     }
     return items;
 }
-/** Numbered independently testable clauses from the task statement (#3323). */
-export function deriveAcceptanceClauses(taskStatement) {
-    const text = taskStatement.trim();
-    if (text.length === 0) {
+/**
+ * Acceptance lines declared on `plan.items` (#3826).
+ *
+ * Prefers `item.narrative.Acceptance`, then `item.title` — criteria routinely live
+ * in the title with an empty `narrative`, which is how a declared acceptance
+ * surface stayed invisible to derivation on #3794 and #3819.
+ */
+export function collectPlanItemAcceptanceSurface(plan) {
+    if (!Array.isArray(plan.items)) {
         return [];
     }
-    const acHeading = findAcHeading(text);
+    const lines = [];
+    const seen = new Set();
+    for (const entry of plan.items) {
+        const item = asRecord(entry);
+        if (item === null) {
+            continue;
+        }
+        const narrative = asRecord(item.narrative);
+        const declared = narrative === null ? undefined : narrative.Acceptance;
+        const source = isNonEmptyString(declared) ? declared : item.title;
+        if (!isNonEmptyString(source)) {
+            continue;
+        }
+        const line = normalizeClauseText(source.replace(/\*\*/g, ""));
+        const key = line.toLowerCase();
+        if (line.length === 0 || isMetaClause(line) || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        lines.push(line);
+    }
+    return lines;
+}
+/** Acceptance lines the statement itself declares, in extractor precedence order. */
+function collectStatementSurface(text) {
     const raw = [];
+    const acHeading = findAcHeading(text);
     if (acHeading !== null) {
         raw.push(...parseListItems(sliceAcSection(text, acHeading))
             .map((item) => normalizeClauseText(item.title.replace(/\*\*/g, "")))
@@ -151,6 +181,22 @@ export function deriveAcceptanceClauses(taskStatement) {
     if (raw.length === 0) {
         raw.push(...collectPathBearingLines(text));
     }
+    return raw;
+}
+/** Numbered independently testable clauses from the task statement (#3323). */
+export function deriveAcceptanceClauses(taskStatement, sources = {}) {
+    const text = taskStatement.trim();
+    const itemSurface = (sources.itemSurface ?? [])
+        .map((line) => normalizeClauseText(line))
+        .filter((line) => line.length > 0 && !isMetaClause(line));
+    // #3826: `plan.items` is a declared, body-scoped acceptance surface, while the
+    // statement carries the whole untrusted issue comment thread. Preferring the
+    // declared surface is what keeps an acceptance-shaped heading buried in that
+    // thread from becoming the gate — the #3794 and #3819 mechanism.
+    let raw = itemSurface;
+    if (raw.length === 0) {
+        raw = text.length > 0 ? collectStatementSurface(text) : [];
+    }
     const seen = new Set();
     const clauses = [];
     for (const line of raw) {
@@ -163,28 +209,20 @@ export function deriveAcceptanceClauses(taskStatement) {
     }
     return clauses;
 }
+/**
+ * Clause text is untrusted: the statement is the issue body plus its whole
+ * comment thread, and anyone can comment on a public issue. Lifting a path out
+ * of it chose both the file `walkOne` read and the needle it matched, so a
+ * third-party comment could ask the gate a question about any in-root file and
+ * read the answer off the report (#3835).
+ *
+ * Derivation therefore binds no path at all. `walkOne` binds only what the brief
+ * declares on `plan.metadata.swarm.file_scope`. Measured across the six live
+ * briefs at filing, prose extraction bound two paths and verified zero clauses,
+ * so this costs no verification capability.
+ */
 function buildClause(id, text) {
-    const paths = extractPathTokens(text);
-    if (paths.length <= 1) {
-        return {
-            id,
-            text,
-            artifact_path: paths[0] ?? null,
-            ambiguous: false,
-        };
-    }
-    const readings = paths.map((artifact_path) => ({
-        text: `${text} [reading: ${artifact_path}]`,
-        artifact_path,
-    }));
-    return {
-        id,
-        text,
-        artifact_path: paths[0] ?? null,
-        ambiguous: true,
-        readings,
-        chosen_reading: 0,
-    };
+    return { id, text, artifact_path: null, ambiguous: false };
 }
 export function readAcceptanceClauses(acceptance) {
     const rec = asRecord(acceptance);
@@ -273,7 +311,9 @@ export function stampDerivedClausesOnAcceptance(plan, taskStatement) {
     if (Array.isArray(commands) && commands.length > 0) {
         return { plan, clauses: [] };
     }
-    const clauses = deriveAcceptanceClauses(taskStatement);
+    const clauses = deriveAcceptanceClauses(taskStatement, {
+        itemSurface: collectPlanItemAcceptanceSurface(plan),
+    });
     if (clauses.length === 0) {
         return { plan, clauses: [] };
     }
@@ -295,6 +335,57 @@ export function isScratchArtifactPath(artifactPath) {
     const unified = artifactPath.replace(/\\/g, "/").toLowerCase();
     return unified.split("/").some((seg) => SCRATCH_SEGMENTS.has(seg));
 }
+/**
+ * Repo-relative comparison form: forward slashes, no `./` prefix, no trailing slash.
+ *
+ * Segment-split rather than regex-replaced: the inputs include clause text a
+ * commenter wrote, and the anchored slash-run patterns this replaced backtrack
+ * quadratically on a long run of separators (`js/polynomial-redos`).
+ */
+function normalizeScopePath(value) {
+    const unified = value.trim().split("\\").join("/");
+    const rooted = unified.startsWith("/") ? "/" : "";
+    const segments = unified.split("/").filter((segment) => segment.length > 0);
+    if (rooted.length === 0 && segments[0] === ".") {
+        segments.shift();
+    }
+    return rooted + segments.join("/");
+}
+/**
+ * The declared artifact surface for a brief: `plan.metadata.swarm.file_scope`.
+ *
+ * This is the only surface the walk reads from (#3835). It sits inside the
+ * xBRIEF, so a GitHub commenter cannot write it, and it is already gated by the
+ * #3145 approved-scope digest and `humanApproval` stamp.
+ */
+export function readDeclaredArtifactScope(plan) {
+    const swarm = asRecord(asRecord(asRecord(plan)?.metadata)?.swarm);
+    if (swarm === null || !Array.isArray(swarm.file_scope)) {
+        return [];
+    }
+    const declared = new Set();
+    for (const entry of swarm.file_scope) {
+        if (!isNonEmptyString(entry)) {
+            continue;
+        }
+        const normalized = normalizeScopePath(entry);
+        if (normalized.length > 0) {
+            declared.add(normalized);
+        }
+    }
+    return [...declared];
+}
+/** True when the clause binding is a declared entry or sits under a declared directory. */
+export function isDeclaredArtifactPath(artifactPath, declaredScope) {
+    const candidate = normalizeScopePath(artifactPath);
+    if (candidate.length === 0 || candidate === ".." || candidate.startsWith("../")) {
+        return false;
+    }
+    return declaredScope.some((raw) => {
+        const entry = normalizeScopePath(raw);
+        return entry.length > 0 && (candidate === entry || candidate.startsWith(`${entry}/`));
+    });
+}
 function isContained(root, child) {
     const rel = relative(resolve(root), resolve(child));
     return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
@@ -318,7 +409,7 @@ function extractExpectedTokens(clause) {
     }
     return tokens;
 }
-function walkOne(clause, projectRoot) {
+function walkOne(clause, projectRoot, declaredScope) {
     const artifactPath = clause.artifact_path;
     if (artifactPath === null || artifactPath.trim().length === 0) {
         return {
@@ -327,73 +418,64 @@ function walkOne(clause, projectRoot) {
             artifact_path: artifactPath,
             outcome: "unverifiable",
             detail: "no artifact path bound",
+            adjudicable: false,
         };
     }
-    if (isScratchArtifactPath(artifactPath)) {
+    // #3835: every filesystem touch below this line — existence, stat, and the
+    // token read — is gated here. A path the brief did not declare is refused
+    // before the walk learns anything about it, and the refusal detail is a
+    // function of the path alone, so a rejected clause reports the same thing
+    // whatever needle it carries. Filtering the shape of the path upstream was
+    // measured to narrow this by zero; this is the line that closes it.
+    if (!isDeclaredArtifactPath(artifactPath, declaredScope)) {
         return {
             id: clause.id,
             text: clause.text,
             artifact_path: artifactPath,
-            outcome: "failed",
-            detail: "artifact path is a buffer/scratch copy, not the shipped path",
+            outcome: "unverifiable",
+            detail: `artifact path is not declared on plan.metadata.swarm.file_scope, so nothing ` +
+                `was read: ${artifactPath} (#3835)`,
+            adjudicable: false,
         };
     }
+    // Past the declared-scope gate the walk has an oracle, so every outcome below
+    // counts toward the `ok` predicate.
+    const bound = (outcome, detail) => ({
+        id: clause.id,
+        text: clause.text,
+        artifact_path: artifactPath,
+        outcome,
+        detail,
+        adjudicable: true,
+    });
+    if (isScratchArtifactPath(artifactPath)) {
+        return bound("failed", "artifact path is a buffer/scratch copy, not the shipped path");
+    }
     const abs = resolve(projectRoot, artifactPath);
     if (!isContained(projectRoot, abs)) {
-        return {
-            id: clause.id,
-            text: clause.text,
-            artifact_path: artifactPath,
-            outcome: "failed",
-            detail: "artifact path escaped the project root",
-        };
+        return bound("failed", "artifact path escaped the project root");
     }
     if (!existsSync(abs)) {
         if (NEGATED_EXISTENCE.test(clause.text)) {
-            return {
-                id: clause.id,
-                text: clause.text,
-                artifact_path: artifactPath,
-                outcome: "verified",
-                detail: `artifact correctly absent at ${artifactPath}`,
-            };
+            // #3826: absence is not evidence. The negation phrase is matched against the
+            // whole clause text, so on a derived clause it routinely refers to something
+            // other than the bound path — a bare `git.ts` in analysis prose passed here
+            // and was the sole `verified` row propping up the `ok` predicate on #3794.
+            return bound("unverifiable", `artifact absent at ${artifactPath}; a prose negation is not evidence ` +
+                `the clause requires this path to be absent (#3826)`);
         }
-        return {
-            id: clause.id,
-            text: clause.text,
-            artifact_path: artifactPath,
-            outcome: "failed",
-            detail: `artifact missing at stated path ${artifactPath}`,
-        };
+        return bound("failed", `artifact missing at stated path ${artifactPath}`);
     }
     try {
         if (!statSync(abs).isFile()) {
-            return {
-                id: clause.id,
-                text: clause.text,
-                artifact_path: artifactPath,
-                outcome: "failed",
-                detail: `stated path is not a shipped file: ${artifactPath}`,
-            };
+            return bound("failed", `stated path is not a shipped file: ${artifactPath}`);
         }
     }
     catch {
-        return {
-            id: clause.id,
-            text: clause.text,
-            artifact_path: artifactPath,
-            outcome: "failed",
-            detail: `artifact unreadable at stated path ${artifactPath}`,
-        };
+        return bound("failed", `artifact unreadable at stated path ${artifactPath}`);
     }
     if (NEGATED_EXISTENCE.test(clause.text)) {
-        return {
-            id: clause.id,
-            text: clause.text,
-            artifact_path: artifactPath,
-            outcome: "failed",
-            detail: `artifact exists at ${artifactPath} but the clause requires absence`,
-        };
+        return bound("failed", `artifact exists at ${artifactPath} but the clause requires absence`);
     }
     const expected = extractExpectedTokens(clause);
     if (expected.length > 0) {
@@ -402,55 +484,45 @@ function walkOne(clause, projectRoot) {
             body = readFileSync(abs, "utf8");
         }
         catch {
-            return {
-                id: clause.id,
-                text: clause.text,
-                artifact_path: artifactPath,
-                outcome: "failed",
-                detail: `artifact unreadable at stated path ${artifactPath}`,
-            };
+            return bound("failed", `artifact unreadable at stated path ${artifactPath}`);
         }
         const missing = expected.filter((token) => !body.includes(token));
         if (missing.length > 0) {
-            return {
-                id: clause.id,
-                text: clause.text,
-                artifact_path: artifactPath,
-                outcome: "failed",
-                detail: `expected token(s) missing from ${artifactPath}: ${missing.join(", ")}`,
-            };
+            return bound("failed", `expected token(s) missing from ${artifactPath}: ${missing.join(", ")}`);
         }
-        return {
-            id: clause.id,
-            text: clause.text,
-            artifact_path: artifactPath,
-            outcome: "verified",
-            detail: `tokens present in shipped artifact ${artifactPath}`,
-        };
+        return bound("verified", `tokens present in shipped artifact ${artifactPath}`);
     }
     if (EXISTENCE_CLAIM.test(clause.text)) {
-        return {
-            id: clause.id,
-            text: clause.text,
-            artifact_path: artifactPath,
-            outcome: "verified",
-            detail: `shipped artifact exists at ${artifactPath}`,
-        };
+        return bound("verified", `shipped artifact exists at ${artifactPath}`);
     }
-    return {
-        id: clause.id,
-        text: clause.text,
-        artifact_path: artifactPath,
-        outcome: "unverifiable",
-        detail: `cannot evaluate behavioral claim against shipped artifact ${artifactPath}`,
-    };
+    return bound("unverifiable", `cannot evaluate behavioral claim against shipped artifact ${artifactPath}`);
+}
+/**
+ * Clauses the walk had an oracle for — bound to a declared artifact path.
+ *
+ * A clause with no oracle can only ever be `unverifiable`, so requiring a positive
+ * `verified` from a set of them is unsatisfiable by correct work rather than a
+ * quality bar (#3826).
+ */
+export function countAdjudicableClauses(rows) {
+    return rows.filter((row) => row.adjudicable).length;
+}
+/**
+ * Adjudicable clauses the walk did not verify.
+ *
+ * #3826 made `verified > 0` a *set* predicate excused by an empty oracle set, so
+ * one bound-and-verified clause re-armed the whole set and covered siblings with
+ * their own unmet oracle. Counting per clause is what removes that seam (#3835).
+ */
+export function countUnverifiedAdjudicableClauses(rows) {
+    return rows.filter((row) => row.adjudicable && row.outcome !== "verified").length;
 }
-export function walkAcceptanceClauses(clauses, projectRoot) {
-    const walked = clauses.map((clause) => walkOne(clause, projectRoot));
+export function walkAcceptanceClauses(clauses, projectRoot, options) {
+    const walked = clauses.map((clause) => walkOne(clause, projectRoot, options.declaredScope));
     const failed = walked.filter((row) => row.outcome === "failed");
     const unverifiable = walked.filter((row) => row.outcome === "unverifiable");
     const verified = walked.filter((row) => row.outcome === "verified");
-    const ok = failed.length === 0 && (verified.length > 0 || walked.length === 0);
+    const ok = failed.length === 0 && countUnverifiedAdjudicableClauses(walked) === 0;
     return {
         clauses: walked,
         failed,

package/dist/verify-ac/evaluate.d.ts

@@ -44,6 +44,15 @@ export declare const VERIFY_AC_CHECK_ID_PREFIX = "verify:ac";
 export declare function verifyAcCheckId(scopeKey?: string | null): string;
 /** Test seam: isolate stdout-dest buffer across cases. */
 export declare function resetInProcessVerificationBuffer(): void;
+/**
+ * Product-oracle outcome for one acceptance walk (#3615).
+ *
+ * A safety refusal is not a measurement. All-refused walks emit nothing.
+ * Mixed refused + executed-pass walks emit nothing (filtering refusals then
+ * classifying the remainder would be a false green). Any executed fail still
+ * emits fail. flag.ts is unchanged.
+ */
+export declare function productOracleOutcomeForWalk(runs: readonly LiteralAcceptanceRunResult[]): "pass" | "fail" | null;
 /**
  * Record one walk-level verification event for the executed command set (#3322 / #3397).
  * Fail and pass use the same method_fingerprint shape (command list + cwd hash).

package/dist/verify-ac/evaluate.js

@@ -10,6 +10,7 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { isSafetyRefusalRun } from "../literal-acceptance/run.js";
 import { parseRunSummaryJsonl, RunSummaryEmitter, resolveRunSummaryDestination, } from "../run-summary/index.js";
 import { flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
 function formatUnresolved(flag) {
@@ -57,6 +58,25 @@ function inProcessVerificationText() {
     }
     return inProcessVerificationLines.join("\n");
 }
+/**
+ * Product-oracle outcome for one acceptance walk (#3615).
+ *
+ * A safety refusal is not a measurement. All-refused walks emit nothing.
+ * Mixed refused + executed-pass walks emit nothing (filtering refusals then
+ * classifying the remainder would be a false green). Any executed fail still
+ * emits fail. flag.ts is unchanged.
+ */
+export function productOracleOutcomeForWalk(runs) {
+    const refused = runs.filter(isSafetyRefusalRun);
+    const executed = runs.filter((run) => !isSafetyRefusalRun(run));
+    if (executed.length === 0) {
+        return null;
+    }
+    if (refused.length > 0 && executed.every((run) => run.ok)) {
+        return null;
+    }
+    return executed.every((run) => run.ok) ? "pass" : "fail";
+}
 /**
  * Record one walk-level verification event for the executed command set (#3322 / #3397).
  * Fail and pass use the same method_fingerprint shape (command list + cwd hash).
@@ -69,6 +89,10 @@ export function emitVerifyAcAttempts(options) {
     if (options.runs.length === 0) {
         return;
     }
+    const outcome = productOracleOutcomeForWalk(options.runs);
+    if (outcome === null) {
+        return;
+    }
     try {
         const env = options.env ?? process.env;
         const projectRoot = resolve(options.projectRoot);
@@ -85,16 +109,15 @@ export function emitVerifyAcAttempts(options) {
             component: "verify-ac",
             writeStdout: options.writeStdout,
         });
-        // One walk-level event: the method is the command set, not each command.
-        // Per-command emit was blind to a shrinking list that kept the first command (#3397).
-        const commands = options.runs.map((run) => run.command);
-        const firstCwd = options.runs[0]?.cwd ?? "";
-        // Hash the cwd key (joined only when cwds differ) so cwd paths never enter
-        // the fingerprint; commandCountFromFingerprint can still count commands.
-        const cwdKey = options.runs.every((run) => run.cwd === firstCwd)
+        // Method identity is the executed command set. Refused rows are not
+        // measurements; including them would make a later same-command product
+        // fix look like a method change (#3615 Greptile P1).
+        const executed = options.runs.filter((run) => !isSafetyRefusalRun(run));
+        const commands = executed.map((run) => run.command);
+        const firstCwd = executed[0]?.cwd ?? "";
+        const cwdKey = executed.every((run) => run.cwd === firstCwd)
             ? firstCwd
-            : options.runs.map((run) => run.cwd).join("\0");
-        const outcome = options.runs.every((run) => run.ok) ? "pass" : "fail";
+            : executed.map((run) => run.cwd).join("\0");
         const emitted = emitter.emitVerification({
             check_id: checkId,
             method_fingerprint: methodFingerprintForWalk(commands, cwdKey),

package/dist/verify-ac/index.d.ts

@@ -4,7 +4,7 @@
  * Extends #3156: a red product verification may not be self-adjudicated
  * by editing the comparison. Deterministic surface is the flagged event.
  */
-export { type AcceptanceClause, type AcceptanceClauseReading, type ClauseOutcome, type ClauseWalkReport, type ClauseWalkResult, deriveAcceptanceClauses, formatClauseWalkMessage, isScratchArtifactPath, readAcceptanceClauses, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
+export { type AcceptanceClause, type AcceptanceClauseReading, type ClauseDerivationSources, type ClauseOutcome, type ClauseWalkOptions, type ClauseWalkReport, type ClauseWalkResult, collectPlanItemAcceptanceSurface, countAdjudicableClauses, countUnverifiedAdjudicableClauses, deriveAcceptanceClauses, formatClauseWalkMessage, isDeclaredArtifactPath, isScratchArtifactPath, readAcceptanceClauses, readDeclaredArtifactScope, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
 export { type EvaluateProductOracleIntegrityOptions, emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, methodFingerprintForWalk, type OracleIntegrityResultFields, type ProductOracleIntegrityVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
 export { commandCountFromFingerprint, type FlaggedMethodChangePass, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, type VerificationAttempt, } from "./flag.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/verify-ac/index.js

@@ -4,7 +4,7 @@
  * Extends #3156: a red product verification may not be self-adjudicated
  * by editing the comparison. Deterministic surface is the flagged event.
  */
-export { deriveAcceptanceClauses, formatClauseWalkMessage, isScratchArtifactPath, readAcceptanceClauses, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
+export { collectPlanItemAcceptanceSurface, countAdjudicableClauses, countUnverifiedAdjudicableClauses, deriveAcceptanceClauses, formatClauseWalkMessage, isDeclaredArtifactPath, isScratchArtifactPath, readAcceptanceClauses, readDeclaredArtifactScope, serializeAcceptanceClauses, stampDerivedClausesOnAcceptance, walkAcceptanceClauses, } from "./clauses.js";
 export { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, methodFingerprintForWalk, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
 export { commandCountFromFingerprint, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
 //# sourceMappingURL=index.js.map

package/dist/verify-env/node-runtime.d.ts

@@ -1,6 +1,10 @@
-/** Node/pnpm presence contract for TS-backed consumer gates (#1828 / #1530). */
-export declare const NODE_RUNTIME_TOOL_NAMES: readonly ["node", "pnpm"];
+/** Node/package-manager presence contract for TS-backed consumer gates. */
+import type { PackageManager } from "../resolution/package-manager.js";
+/** All supported Node/package-manager tool names across consumer projects. */
+export declare const NODE_RUNTIME_TOOL_NAMES: readonly ["node", "npm", "pnpm"];
 export declare const NODE_RUNTIME_REMEDIATION = "Node.js and pnpm are required for TS-backed deft gates. Install Node 20+ (see .nvmrc), then run: corepack enable && corepack prepare pnpm@latest --activate. See UPGRADING.md \u00A7 Node runtime.";
-/** Append remediation lines when node or pnpm is among the missing tools. */
-export declare function nodeRuntimeRemediationLines(failed: readonly string[]): readonly string[];
+/** npm ships with the supported Node distribution; Corepack/pnpm is not required. */
+export declare const NPM_RUNTIME_REMEDIATION = "Node.js and npm are required for TS-backed deft gates. Install or repair Node 20+ (see .nvmrc; npm is bundled), then re-run the consumer check. See UPGRADING.md \u00A7 Node runtime.";
+/** Append remediation lines for node or the package manager selected by the project. */
+export declare function nodeRuntimeRemediationLines(failed: readonly string[], packageManager?: PackageManager): readonly string[];
 //# sourceMappingURL=node-runtime.d.ts.map