@deftai/directive-core 0.107.0 → 0.108.0

package/dist/vbrief-validate/conformance.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { GitCommandError, GitNotFoundError, gitStagedFiles, gitTrackedFiles, } from "../encoding/git.js";
 import { fnmatchCase } from "../encoding/text.js";
@@ -71,8 +71,21 @@ export const ITEM_CORE = new Set([
     // (accepted via EXTENSION_PREFIXES). Bare evidence/disposition fail #1620.
 ]);
 export const EXTENSION_PREFIXES = ["x-directive/", "x-vbrief/", "x-xbrief/"];
+const SAFE_FINDING_KEY = /^[A-Za-z][A-Za-z0-9._/-]{0,63}$/;
+const SENSITIVE_FINDING_KEY = /(?:auth|credential|password|private|secret|token|api.?key)/i;
+/**
+ * Bounded presentation of a raw finding key (#3796). `finding.key` stays exact
+ * for machine consumers; only this rendered form is sanitised, so a hostile or
+ * sensitive key cannot ride a stderr diagnostic out of the process.
+ */
+function renderFindingKey(key) {
+    return SAFE_FINDING_KEY.test(key) && !SENSITIVE_FINDING_KEY.test(key)
+        ? key
+        : `<redacted-key length=${[...key].length}>`;
+}
 export function renderFinding(finding) {
-    return `  ${finding.path} [${finding.level}] bare key '${finding.key}' at ${finding.location}`;
+    return (`  ${finding.path} [${finding.level}] bare key ` +
+        `'${renderFindingKey(finding.key)}' at ${finding.location}`);
 }
 function isConformant(key, core) {
     if (core.has(key)) {
@@ -244,21 +257,85 @@ export function evaluateConformance(projectRoot, options = {}) {
     }
     const candidates = relPaths
         .map((p) => p.replace(/\\/g, "/"))
-        .filter((posix) => isVbriefPath(posix) && !isAllowListed(posix, customGlobs));
+        .filter((posix) => isVbriefPath(posix) && !isAllowListed(posix, customGlobs))
+        .map((posix) => ({ displayPath: posix, fullPath: join(root, posix), configured: false }));
+    const configuredPath = options.projectDefinitionPath?.trim();
+    if (configuredPath) {
+        const lexicalPath = resolve(root, configuredPath);
+        if (!existsSync(lexicalPath)) {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: "❌ verify_vbrief_conformance: configured PROJECT-DEFINITION does not exist.\n" +
+                    "  Recovery: fix or unset DEFT_PROJECT_PATH, then rerun conformance.",
+            };
+        }
+        let fullPath;
+        try {
+            fullPath = realpathSync(lexicalPath);
+        }
+        catch {
+            return {
+                exitCode: 2,
+                findings: [],
+                message: "❌ verify_vbrief_conformance: configured PROJECT-DEFINITION is unreadable.\n" +
+                    "  Recovery: fix its permissions or DEFT_PROJECT_PATH, then rerun conformance.",
+            };
+        }
+        const existing = candidates.find((candidate) => {
+            try {
+                return realpathSync(candidate.fullPath) === fullPath;
+            }
+            catch {
+                return resolve(candidate.fullPath) === fullPath;
+            }
+        });
+        if (existing === undefined) {
+            candidates.push({
+                displayPath: "<configured PROJECT-DEFINITION>",
+                fullPath,
+                configured: true,
+            });
+        }
+        else {
+            existing.displayPath = "<configured PROJECT-DEFINITION>";
+            existing.fullPath = fullPath;
+            existing.configured = true;
+        }
+    }
     const findings = [];
-    for (const posix of candidates) {
-        const full = join(root, posix);
+    for (const candidate of candidates) {
         let text;
         try {
-            text = readFileSync(full, "utf8");
+            text = readFileSync(candidate.fullPath, "utf8");
         }
         catch {
+            if (candidate.configured) {
+                return {
+                    exitCode: 2,
+                    findings,
+                    message: "❌ verify_vbrief_conformance: configured PROJECT-DEFINITION is unreadable.\n" +
+                        "  Recovery: fix its permissions or DEFT_PROJECT_PATH, then rerun conformance.",
+                };
+            }
             continue;
         }
+        let data;
         try {
-            findings.push(...scanVbrief(posix, JSON.parse(text)));
+            data = JSON.parse(text);
+        }
+        catch {
+            if (candidate.configured) {
+                return {
+                    exitCode: 2,
+                    findings,
+                    message: "❌ verify_vbrief_conformance: configured PROJECT-DEFINITION is not valid JSON.\n" +
+                        "  Recovery: repair the JSON, then rerun conformance.",
+                };
+            }
+            continue;
         }
-        catch { }
+        findings.push(...scanVbrief(candidate.displayPath, data));
     }
     if (findings.length > 0) {
         const uniquePaths = new Set(findings.map((f) => f.path));

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/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