@deftai/directive-core 0.104.0 → 0.105.0

package/dist/vbrief-reconcile/umbrellas.js

@@ -5,6 +5,8 @@ import { createIssueComment, editIssueBody, editIssueCommentBody, fetchIssueBody
 import { fetchIssueStates, IssueState } from "../intake/reconcile-issues.js";
 import { hasArtifactSuffix, resolveLifecycleRoot, stripArtifactSuffix } from "../layout/resolve.js";
 import { call } from "../scm/call.js";
+import { restCloseIssue } from "../scm/gh-rest.js";
+import { readAll } from "../slice/record.js";
 import { extractIssueRef, parseGithubIssueUri } from "../triage/reconcile/parse-uri.js";
 import { isRepoMutationAllowed } from "./repo-guard.js";
 export const OPEN_FOLDERS = ["proposed", "pending", "active"];
@@ -307,33 +309,43 @@ export function classifyPassType(prevTotal, total) {
 function hasCurrentShape(body) {
     return HEADER_RE.test(body);
 }
+function parseCommentPage(data) {
+    if (!Array.isArray(data))
+        return [];
+    const comments = [];
+    for (const entry of data) {
+        if (typeof entry === "object" &&
+            entry !== null &&
+            !Array.isArray(entry) &&
+            typeof entry.id === "number" &&
+            typeof entry.body === "string") {
+            const rec = entry;
+            comments.push({ id: rec.id, body: rec.body });
+        }
+    }
+    return comments;
+}
 export class ScmUmbrellaClient {
     fetchComments(repo, issueNumber) {
-        const proc = call(SCM_SOURCE, "api", [
-            `repos/${repo}/issues/${issueNumber}/comments?per_page=100`,
-        ]);
-        if (proc.returncode !== 0) {
-            throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) failed: ${(proc.stderr || "").trim()}`);
-        }
-        let data;
-        try {
-            data = JSON.parse(proc.stdout || "[]");
-        }
-        catch (exc) {
-            throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`);
-        }
-        if (!Array.isArray(data))
-            return [];
         const comments = [];
-        for (const entry of data) {
-            if (typeof entry === "object" &&
-                entry !== null &&
-                !Array.isArray(entry) &&
-                typeof entry.id === "number" &&
-                typeof entry.body === "string") {
-                const rec = entry;
-                comments.push({ id: rec.id, body: rec.body });
+        for (let page = 1; page <= 50; page += 1) {
+            const proc = call(SCM_SOURCE, "api", [
+                `repos/${repo}/issues/${issueNumber}/comments?per_page=100&page=${page}`,
+            ]);
+            if (proc.returncode !== 0) {
+                throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) failed: ${(proc.stderr || "").trim()}`);
+            }
+            let data;
+            try {
+                data = JSON.parse(proc.stdout || "[]");
+            }
+            catch (exc) {
+                throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`);
             }
+            const batch = parseCommentPage(data);
+            comments.push(...batch);
+            if (batch.length < 100)
+                break;
         }
         return comments;
     }
@@ -394,6 +406,15 @@ export class ScmUmbrellaClient {
             throw new UmbrellaScmError(`edit issue body #${issueNumber} (${repo}) failed: ${message}`);
         }
     }
+    closeIssue(repo, issueNumber) {
+        try {
+            restCloseIssue(repo, issueNumber, "completed");
+        }
+        catch (exc) {
+            const message = exc instanceof Error ? exc.message : String(exc);
+            throw new UmbrellaScmError(`close issue #${issueNumber} (${repo}) failed: ${message}`);
+        }
+    }
 }
 function planShape(epicData, index, options = {}) {
     const children = computeChildren(epicData, index, {
@@ -545,6 +566,147 @@ function reconcileOneEpic(epicData, index, options) {
 export function nowIso(date = new Date()) {
     return date.toISOString().replace(/\.\d{3}Z$/, "Z");
 }
+const ALL_CHILDREN_MERGED = "all-children-merged";
+/** Children listed on a slices.jsonl row (#3428). Last write of a duplicate `n` wins. */
+export function childrenFromSliceRecord(record) {
+    const raw = record.children;
+    if (!Array.isArray(raw))
+        return [];
+    const byNumber = new Map();
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            continue;
+        const rec = entry;
+        const n = rec.n;
+        if (typeof n !== "number" || !Number.isInteger(n) || n < 1)
+            continue;
+        byNumber.set(n, {
+            story_id: `#${n}`,
+            title: `#${n}`,
+            kind: "story",
+            folder: UNKNOWN_FOLDER,
+            depends_on: [],
+            issue_number: n,
+        });
+    }
+    return [...byNumber.values()];
+}
+/**
+ * Close only when the slice signal is all-children-merged, the umbrella is
+ * still open, and every child has forge state closed (#3428).
+ */
+export function shouldCloseOnAllChildrenMerged(options) {
+    if (options.signal !== ALL_CHILDREN_MERGED)
+        return false;
+    if (options.umbrellaState !== "open")
+        return false;
+    if (options.children.length === 0)
+        return false;
+    if (options.forgeStates == null)
+        return false;
+    return options.children.every((c) => typeof c.issue_number === "number" && options.forgeStates?.get(c.issue_number) === "closed");
+}
+export function formatCloseComment(signal, children) {
+    const nums = children
+        .map((c) => c.issue_number)
+        .filter((n) => typeof n === "number")
+        .sort((a, b) => a - b)
+        .map((n) => `#${n}`);
+    return `expected_close_signal=${signal}; children: ${nums.join(", ")}`;
+}
+function loadLatestSliceRecords(vbriefDir) {
+    const logPath = join(vbriefDir, ".triage-cache", "slices.jsonl");
+    if (!existsSync(logPath))
+        return [];
+    const latest = new Map();
+    for (const rec of readAll({ path: logPath })) {
+        const n = rec.umbrella;
+        if (typeof n !== "number" || !Number.isInteger(n) || n < 1)
+            continue;
+        const [urlRepo] = parseGithubIssueUri(rec.umbrella_url);
+        latest.set(`${urlRepo ?? ""}:${n}`, rec);
+    }
+    return [...latest.values()];
+}
+function epicDataFromSlice(repo, number, children) {
+    const refs = [
+        { type: "x-xbrief/github-issue", uri: `https://github.com/${repo}/issues/${number}` },
+        ...children.map((c) => ({
+            type: "x-xbrief/github-issue",
+            uri: `https://github.com/${repo}/issues/${c.issue_number}`,
+            title: c.title,
+        })),
+    ];
+    return {
+        plan: {
+            id: `slice-umbrella-${number}`,
+            metadata: { kind: "epic" },
+            references: refs,
+        },
+    };
+}
+function maybeCloseSliceUmbrella(options) {
+    if (typeof options.client.closeIssue !== "function")
+        return "skipped";
+    if (typeof options.client.fetchIssueStates !== "function")
+        return "skipped";
+    const mutateGate = isRepoMutationAllowed(options.repo, options.projectRoot, {
+        allowCrossRepo: options.allowCrossRepo,
+        allowlist: options.repoAllowlist,
+        explicitRepo: options.explicitRepo ?? null,
+    });
+    if (!mutateGate.allowed) {
+        throw new Error(mutateGate.reason ?? `refusing cross-repo mutation on ${options.repo}`);
+    }
+    const childNumbers = options.children
+        .map((c) => c.issue_number)
+        .filter((n) => typeof n === "number");
+    const states = options.client.fetchIssueStates(options.repo, [...childNumbers, options.number]);
+    const umbrellaState = states.get(options.number) ?? null;
+    if (!shouldCloseOnAllChildrenMerged({
+        signal: options.signal,
+        children: options.children,
+        forgeStates: states,
+        umbrellaState,
+    })) {
+        return options.signal === ALL_CHILDREN_MERGED && umbrellaState === "closed"
+            ? "unchanged"
+            : "skipped";
+    }
+    const closeBody = formatCloseComment(ALL_CHILDREN_MERGED, options.children);
+    if (!options.dryRun) {
+        const alreadyCommented = options.client
+            .fetchComments(options.repo, options.number)
+            .some((c) => c.body.trim() === closeBody);
+        if (!alreadyCommented) {
+            options.client.createComment(options.repo, options.number, closeBody);
+        }
+        options.client.closeIssue(options.repo, options.number);
+    }
+    return "closed";
+}
+function pushUmbrellaChange(outcome, change) {
+    if (change.action === "unchanged" && change.close_action !== "closed") {
+        outcome.unchanged.push(change);
+    }
+    else {
+        outcome.changed.push(change);
+    }
+}
+function replaceCloseAction(outcome, repo, issueNumber, closeAction) {
+    const match = (c) => c.repo === repo && c.issue_number === issueNumber;
+    for (const list of [outcome.changed, outcome.unchanged]) {
+        const idx = list.findIndex(match);
+        if (idx < 0)
+            continue;
+        const prev = list[idx];
+        if (prev === undefined)
+            return;
+        list.splice(idx, 1);
+        pushUmbrellaChange(outcome, { ...prev, close_action: closeAction });
+        return;
+    }
+}
 export function reconcileUmbrellas(projectRoot, options = {}) {
     const root = resolve(projectRoot);
     let vbriefDir;
@@ -616,7 +778,6 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
             const key = `${effectiveRepo}:${number}`;
             if (seenIssues.has(key))
                 continue;
-            seenIssues.add(key);
             try {
                 const change = reconcileOneEpic(data, index, {
                     storyId,
@@ -630,6 +791,7 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
                     repoAllowlist: options.repoAllowlist,
                     explicitRepo: options.repo ?? null,
                 });
+                seenIssues.add(key);
                 if (change.action === "unchanged")
                     outcome.unchanged.push(change);
                 else
@@ -643,6 +805,71 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
             }
         }
     }
+    // slices.jsonl umbrellas have no epic xBRIEF (#3428). Last row per umbrella wins.
+    for (const record of loadLatestSliceRecords(vbriefDir)) {
+        const number = record.umbrella;
+        if (typeof number !== "number")
+            continue;
+        const [urlRepo] = parseGithubIssueUri(record.umbrella_url);
+        const effectiveRepo = urlRepo ?? options.repo ?? null;
+        if (effectiveRepo === null) {
+            outcome.skipped_no_ref.push(`slice-umbrella-${number}`);
+            continue;
+        }
+        const key = `${effectiveRepo}:${number}`;
+        const children = childrenFromSliceRecord(record);
+        const storyId = `slice-umbrella-${number}`;
+        try {
+            if (seenIssues.has(key)) {
+                const closeAction = maybeCloseSliceUmbrella({
+                    signal: record.expected_close_signal,
+                    children,
+                    repo: effectiveRepo,
+                    number,
+                    client,
+                    dryRun: options.dryRun ?? false,
+                    projectRoot: root,
+                    allowCrossRepo: options.allowCrossRepo ?? false,
+                    repoAllowlist: options.repoAllowlist,
+                    explicitRepo: options.repo ?? null,
+                });
+                replaceCloseAction(outcome, effectiveRepo, number, closeAction);
+                continue;
+            }
+            const change = reconcileOneEpic(epicDataFromSlice(effectiveRepo, number, children), index, {
+                storyId,
+                repo: effectiveRepo,
+                number,
+                client,
+                dryRun: options.dryRun ?? false,
+                now,
+                projectRoot: root,
+                allowCrossRepo: options.allowCrossRepo ?? false,
+                repoAllowlist: options.repoAllowlist,
+                explicitRepo: options.repo ?? null,
+            });
+            seenIssues.add(key);
+            const closeAction = maybeCloseSliceUmbrella({
+                signal: record.expected_close_signal,
+                children,
+                repo: effectiveRepo,
+                number,
+                client,
+                dryRun: options.dryRun ?? false,
+                projectRoot: root,
+                allowCrossRepo: options.allowCrossRepo ?? false,
+                repoAllowlist: options.repoAllowlist,
+                explicitRepo: options.repo ?? null,
+            });
+            pushUmbrellaChange(outcome, { ...change, close_action: closeAction });
+        }
+        catch (exc) {
+            outcome.errors.push({
+                story_id: storyId,
+                message: exc instanceof Error ? exc.message : String(exc),
+            });
+        }
+    }
     return [outcome.errors.length > 0 ? 1 : 0, outcome];
 }
 function formatChecklistSuffix(action) {
@@ -650,6 +877,11 @@ function formatChecklistSuffix(action) {
         return "";
     return `; checklist=${action}`;
 }
+function formatCloseSuffix(action) {
+    if (action === undefined || action === "skipped")
+        return "";
+    return `; close=${action}`;
+}
 export function renderUmbrellasReport(outcome) {
     const lines = ["vBRIEF reconcile umbrellas", ""];
     const suffix = outcome.dry_run ? " (dry-run)" : "";
@@ -657,7 +889,8 @@ export function renderUmbrellasReport(outcome) {
     if (outcome.changed.length > 0) {
         for (const c of outcome.changed) {
             lines.push(`- #${c.issue_number} (${c.repo}) [${c.story_id}]: ${c.action} -> pass-${c.pass_n}` +
-                formatChecklistSuffix(c.checklist_action));
+                formatChecklistSuffix(c.checklist_action) +
+                formatCloseSuffix(c.close_action));
         }
     }
     else {
@@ -668,7 +901,8 @@ export function renderUmbrellasReport(outcome) {
     if (outcome.unchanged.length > 0) {
         for (const c of outcome.unchanged) {
             lines.push(`- #${c.issue_number} (${c.repo}) [${c.story_id}]: pass-${c.pass_n}` +
-                formatChecklistSuffix(c.checklist_action));
+                formatChecklistSuffix(c.checklist_action) +
+                formatCloseSuffix(c.close_action));
         }
     }
     else {
@@ -696,6 +930,7 @@ export function umbrellasOutcomeToJson(outcome) {
         action: c.action,
         pass_n: c.pass_n,
         checklist_action: c.checklist_action ?? "skipped",
+        close_action: c.close_action ?? "skipped",
     });
     return {
         changed: outcome.changed.map(toChange),

package/dist/vbrief-validate/index.d.ts

@@ -6,7 +6,7 @@ export { validateFolderStatus } from "./folder-status.js";
 export type { ConformanceCliOptions, ValidateCliOptions } from "./main.js";
 export { cmdVbriefValidate, runConformance, runValidate } from "./main.js";
 export { validateOriginProvenance } from "./origin.js";
-export { validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
+export { validateForgeOutageRetryMinutesOnPlan, validateProjectInvariantsOnPlan, validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
 export { validateProjectDefinition } from "./project-definition.js";
 export type { ExtensionEntry, ExtensionRoundtripEvaluateResult, ExtensionRoundtripFinding, } from "./roundtrip.js";
 export { collectExtensionEntries, EXTENSION_CONFORMANCE_FIXTURES_DIR, evaluateExtensionRoundtrip, findExtensionPreservationViolations, reEmitVbriefArtifact, renderExtensionRoundtripFinding, VbriefSchemaValidationError, } from "./roundtrip.js";

package/dist/vbrief-validate/index.js

@@ -4,7 +4,7 @@ export { matchesFilenameConvention, validateFilename } from "./filename.js";
 export { validateFolderStatus } from "./folder-status.js";
 export { cmdVbriefValidate, runConformance, runValidate } from "./main.js";
 export { validateOriginProvenance } from "./origin.js";
-export { validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
+export { validateForgeOutageRetryMinutesOnPlan, validateProjectInvariantsOnPlan, validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
 export { validateProjectDefinition } from "./project-definition.js";
 export { collectExtensionEntries, EXTENSION_CONFORMANCE_FIXTURES_DIR, evaluateExtensionRoundtrip, findExtensionPreservationViolations, reEmitVbriefArtifact, renderExtensionRoundtripFinding, VbriefSchemaValidationError, } from "./roundtrip.js";
 export { normalizeNarrativeKey, validateVbriefSchema } from "./schema.js";

package/dist/vbrief-validate/plan-hooks.d.ts

@@ -2,6 +2,10 @@
 export declare function validateWipCapOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook for ``sessionRitualStalenessHours`` (#1348). */
 export declare function validateSessionRitualStalenessHoursOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook for ``projectInvariants`` (#3425). */
+export declare function validateProjectInvariantsOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook for ``forgeOutageRetryMinutes`` (#3422). */
+export declare function validateForgeOutageRetryMinutesOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.triageRankingLabels`` (#1128). */
 export declare function validateTriageRankingLabelsOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.runtimeAuthority`` (#1394). */

package/dist/vbrief-validate/plan-hooks.js

@@ -3,6 +3,7 @@ import { validateCoverageDebt } from "../policy/coverage-debt.js";
 import { validateHostHooks } from "../policy/host-hooks.js";
 import { validateHostSlashCommands } from "../policy/host-slash-commands.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { parseProjectInvariants } from "../policy/project-invariants.js";
 import { validateRuntimeAuthority } from "../policy/runtime-authority.js";
 import { validateStalenessTickler } from "../policy/staleness-tickler.js";
 import { validateOpenClawProductCommands } from "../slash/openclaw-deposit.js";
@@ -93,6 +94,61 @@ export function validateSessionRitualStalenessHoursOnPlan(plan, filepath) {
     }
     return out;
 }
+function validateForgeOutageRetryMinutes(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        const repr = typeof value === "string"
+            ? pyStrRepr(value)
+            : typeof value === "boolean"
+                ? value
+                    ? "True"
+                    : "False"
+                : String(value);
+        return [
+            "plan.policy.forgeOutageRetryMinutes must be an integer; got " +
+                `${pythonTypeName(value)} (${repr})`,
+        ];
+    }
+    if (value < 5) {
+        return [`plan.policy.forgeOutageRetryMinutes must be >= 5; got ${value}`];
+    }
+    return [];
+}
+/** vbrief_validate hook for ``projectInvariants`` (#3425). */
+export function validateProjectInvariantsOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("projectInvariants" in policy)) {
+        return [];
+    }
+    const { errors } = parseProjectInvariants(policy.projectInvariants);
+    return errors.map((err) => `${filepath}: ${err} (#3425)`);
+}
+/** vbrief_validate hook for ``forgeOutageRetryMinutes`` (#3422). */
+export function validateForgeOutageRetryMinutesOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("forgeOutageRetryMinutes" in policy)) {
+        return [];
+    }
+    const out = [];
+    for (const err of validateForgeOutageRetryMinutes(policy.forgeOutageRetryMinutes)) {
+        out.push(`${filepath}: ${err} (#3422)`);
+    }
+    return out;
+}
 /** vbrief_validate hook: validate ``plan.policy.triageRankingLabels`` (#1128). */
 export function validateTriageRankingLabelsOnPlan(plan, filepath) {
     if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
@@ -283,6 +339,18 @@ export function runProjectDefinitionHooks(plan, filepath) {
     catch {
         /* hook must not break validation */
     }
+    try {
+        errors.push(...validateForgeOutageRetryMinutesOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
+    try {
+        errors.push(...validateProjectInvariantsOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
     try {
         errors.push(...validateStalenessTicklerOnPlan(plan, filepath));
     }

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

@@ -27,6 +27,11 @@ export interface OracleIntegrityResultFields {
     readonly code: number;
     readonly message: string;
 }
+/**
+ * Walk-level method fingerprint: command list + cwd hash (#3397 / #3322).
+ * Same shape for fail and pass so an honest product fix does not flag.
+ */
+export declare function methodFingerprintForWalk(commands: readonly string[], cwd: string): string;
 /** Stable prefix for product-oracle check ids emitted by verify:ac (#3322 / #3337). */
 export declare const VERIFY_AC_CHECK_ID_PREFIX = "verify:ac";
 /**
@@ -40,7 +45,8 @@ export declare function verifyAcCheckId(scopeKey?: string | null): string;
 /** Test seam: isolate stdout-dest buffer across cases. */
 export declare function resetInProcessVerificationBuffer(): void;
 /**
- * Record each executed acceptance command as a verification event (#3322).
+ * 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).
  * Fail-open: missing dest / write errors never change the AC result.
  * Stdout dest also appends to the same-process buffer so evaluate can
  * inspect this invocation without re-reading a file.

package/dist/verify-ac/evaluate.js

@@ -7,14 +7,25 @@
  * attempts just emitted by this verify:ac — it does not treat non-file
  * dest as no evidence.
  */
-import { randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseRunSummaryJsonl, RunSummaryEmitter, resolveRunSummaryDestination, } from "../run-summary/index.js";
 import { flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, } from "./flag.js";
 function formatUnresolved(flag) {
+    const delta = typeof flag.resolved_command_count_delta === "number"
+        ? ` command_count_delta=${flag.resolved_command_count_delta}`
+        : "";
     return (`check_id=${flag.check_id} fail method=${flag.failed_method} ` +
-        `then pass method=${flag.passed_method} without independent re-derivation`);
+        `then pass method=${flag.passed_method} without independent re-derivation${delta}`);
+}
+/**
+ * Walk-level method fingerprint: command list + cwd hash (#3397 / #3322).
+ * Same shape for fail and pass so an honest product fix does not flag.
+ */
+export function methodFingerprintForWalk(commands, cwd) {
+    const cwdHash = createHash("sha256").update(cwd, "utf8").digest("hex");
+    return `${commands.join("\0")}\0${cwdHash}`;
 }
 /** Stable prefix for product-oracle check ids emitted by verify:ac (#3322 / #3337). */
 export const VERIFY_AC_CHECK_ID_PREFIX = "verify:ac";
@@ -36,11 +47,9 @@ export function verifyAcCheckId(scopeKey) {
 }
 /** Same-process verification JSONL when dest is stdout (`-`). */
 const inProcessVerificationLines = [];
-let inProcessStdoutSessionId;
 /** Test seam: isolate stdout-dest buffer across cases. */
 export function resetInProcessVerificationBuffer() {
     inProcessVerificationLines.length = 0;
-    inProcessStdoutSessionId = undefined;
 }
 function inProcessVerificationText() {
     if (inProcessVerificationLines.length === 0) {
@@ -49,7 +58,8 @@ function inProcessVerificationText() {
     return inProcessVerificationLines.join("\n");
 }
 /**
- * Record each executed acceptance command as a verification event (#3322).
+ * 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).
  * Fail-open: missing dest / write errors never change the AC result.
  * Stdout dest also appends to the same-process buffer so evaluate can
  * inspect this invocation without re-reading a file.
@@ -63,18 +73,7 @@ export function emitVerifyAcAttempts(options) {
         const env = options.env ?? process.env;
         const projectRoot = resolve(options.projectRoot);
         const dest = resolveRunSummaryDestination(projectRoot, { env });
-        const explicitSession = options.sessionId?.trim() ||
-            (typeof env.DEFT_SESSION_ID === "string" ? env.DEFT_SESSION_ID.trim() : "");
-        let sessionId = explicitSession;
-        if (!sessionId) {
-            if (dest.kind === "stdout") {
-                inProcessStdoutSessionId ??= randomUUID();
-                sessionId = inProcessStdoutSessionId;
-            }
-            else {
-                sessionId = randomUUID();
-            }
-        }
+        const sessionId = options.sessionId;
         const explicitCheck = typeof options.checkId === "string" && options.checkId.trim().length > 0
             ? options.checkId.trim()
             : null;
@@ -83,17 +82,26 @@ export function emitVerifyAcAttempts(options) {
             projectRoot,
             sessionId,
             env,
+            component: "verify-ac",
             writeStdout: options.writeStdout,
         });
-        for (const run of options.runs) {
-            const emitted = emitter.emitVerification({
-                check_id: checkId,
-                method_fingerprint: `${run.command}\0${run.cwd}`,
-                outcome: run.ok ? "pass" : "fail",
-            });
-            if (dest.kind === "stdout" && emitted.line !== null) {
-                inProcessVerificationLines.push(JSON.stringify(emitted.line));
-            }
+        // 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)
+            ? firstCwd
+            : options.runs.map((run) => run.cwd).join("\0");
+        const outcome = options.runs.every((run) => run.ok) ? "pass" : "fail";
+        const emitted = emitter.emitVerification({
+            check_id: checkId,
+            method_fingerprint: methodFingerprintForWalk(commands, cwdKey),
+            outcome,
+        });
+        if (dest.kind === "stdout" && emitted.line !== null) {
+            inProcessVerificationLines.push(JSON.stringify(emitted.line));
         }
     }
     catch {

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

@@ -20,7 +20,11 @@ export interface FlaggedMethodChangePass {
     readonly failed_method: string;
     readonly passed_method: string;
     readonly independent_rederivation: boolean;
+    /** Pass count minus fail count when both fingerprints carry a command list (#3397). */
+    readonly resolved_command_count_delta?: number;
 }
+/** Command count encoded in a walk fingerprint (`cmd\0cmd\0cwd-or-hash`). */
+export declare function commandCountFromFingerprint(fingerprint: string): number;
 /** Extract well-formed verification attempts in stream order. */
 export declare function readVerificationAttempts(lines: readonly RunSummaryLine[]): VerificationAttempt[];
 /**

package/dist/verify-ac/flag.js

@@ -6,6 +6,19 @@
  * In-place comparison repair then pass is unresolved.
  */
 import { parseRunSummaryJsonl } from "../run-summary/index.js";
+/** Command count encoded in a walk fingerprint (`cmd\0cmd\0cwd-or-hash`). */
+export function commandCountFromFingerprint(fingerprint) {
+    const parts = fingerprint.split("\0");
+    if (parts.length <= 1) {
+        return 1;
+    }
+    const last = parts[parts.length - 1] ?? "";
+    const lastIsCwdOrHash = /^[0-9a-f]{8,64}$/i.test(last) ||
+        last.includes("/") ||
+        last.includes("\\") ||
+        last.includes(":");
+    return lastIsCwdOrHash ? Math.max(1, parts.length - 1) : parts.length;
+}
 function asRecord(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -74,11 +87,14 @@ export function flagPassAfterFailWithMethodChange(attempts) {
         }
         const other = [...prior].find((method) => method !== attempt.method_fingerprint);
         if (other !== undefined) {
+            const delta = commandCountFromFingerprint(attempt.method_fingerprint) -
+                commandCountFromFingerprint(other);
             flagged.push({
                 check_id: attempt.check_id,
                 failed_method: other,
                 passed_method: attempt.method_fingerprint,
                 independent_rederivation: attempt.independent_rederivation,
+                ...(delta !== 0 ? { resolved_command_count_delta: delta } : {}),
             });
         }
         if (attempt.independent_rederivation || other === undefined) {

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

@@ -5,6 +5,6 @@
  * 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 EvaluateProductOracleIntegrityOptions, emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, type OracleIntegrityResultFields, type ProductOracleIntegrityVerdict, VERIFY_AC_CHECK_ID_PREFIX, verifyAcCheckId, } from "./evaluate.js";
-export { type FlaggedMethodChangePass, flagPassAfterFailFromJsonl, flagPassAfterFailWithMethodChange, readVerificationAttempts, unresolvedMethodChangePasses, type VerificationAttempt, } from "./flag.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