@deftai/directive-core 0.102.0 → 0.104.0

package/dist/run-summary/emit.js

@@ -5,10 +5,11 @@
  * most one warning when an *explicit* DEFT_RUN_SUMMARY_PATH write fails.
  * Symlink destinations are refused (no-follow / containment) — fail-open.
  */
-import { mkdirSync, realpathSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, unlinkSync } from "node:fs";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
-import { containedWrite } from "../fs/contained-write.js";
+import { ContainedWriteError, ContainedWriteErrorCode, containedWrite, } from "../fs/contained-write.js";
 import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 import { resolveRunSummaryDestination } from "./path.js";
 import { ENV_TOTAL_TOOL_TURNS, RUN_SUMMARY_SCHEMA_VERSION, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";
@@ -80,7 +81,169 @@ function writeRunSummaryLine(projectRoot, targetPath, textLine, mode) {
     assertRealpathStillContained(parentAbs, targetAbs);
 }
 /**
- * Stateful emitter: one instance per session tracks seq and write-warning once.
+ * Count non-empty lines in an existing append-only JSONL. Missing/unreadable
+ * files seed at 0 (fail-open). Used so a fresh CLI process continues seq
+ * from the destination file instead of resetting to 1 (#3350).
+ */
+function countExistingJsonlLines(path) {
+    try {
+        if (!existsSync(path)) {
+            return 0;
+        }
+        const text = readFileSync(path, "utf8");
+        if (text.length === 0) {
+            return 0;
+        }
+        let count = 0;
+        for (const line of text.split(/\r?\n/)) {
+            if (line.trim().length > 0) {
+                count += 1;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
+function seedSeqFromDestination(destination) {
+    if (destination.kind !== "file") {
+        return 0;
+    }
+    return countExistingJsonlLines(destination.path);
+}
+const SEQ_LOCK_WAIT_MS = 2_000;
+const SEQ_LOCK_SPIN_MS = 15;
+function isErrno(err, code) {
+    return Boolean(err && typeof err === "object" && "code" in err && err.code === code);
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: process exists but we cannot signal it — treat as live.
+        return isErrno(err, "EPERM");
+    }
+}
+function parseSeqLockOwner(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object") {
+            return null;
+        }
+        const pid = parsed.pid;
+        const nonce = parsed.nonce;
+        if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+            return null;
+        }
+        if (typeof nonce !== "string" || nonce.length === 0) {
+            return null;
+        }
+        return { pid, nonce };
+    }
+    catch {
+        return null;
+    }
+}
+function newSeqLockOwner() {
+    return { pid: process.pid, nonce: randomBytes(8).toString("hex") };
+}
+function serializeSeqLockOwner(owner) {
+    return `${JSON.stringify({ pid: owner.pid, nonce: owner.nonce })}\n`;
+}
+/**
+ * Reclaim `.seq.lock` only when the owner process is dead or the token is
+ * missing/unreadable/corrupt (unknown owner). Live holders are never stolen
+ * by mtime (#3361).
+ */
+export function tryReclaimSeqLock(lockPath) {
+    try {
+        const owner = parseSeqLockOwner(readFileSync(lockPath, "utf8"));
+        if (owner !== null && isPidAlive(owner.pid)) {
+            return false;
+        }
+        unlinkSync(lockPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Unlink `.seq.lock` only when the on-disk token still matches this holder
+ * (ownership-blind release must not delete a successor's lock).
+ */
+export function releaseSeqLockIfOwner(lockPath, owner) {
+    try {
+        const current = parseSeqLockOwner(readFileSync(lockPath, "utf8"));
+        if (current === null || current.pid !== owner.pid || current.nonce !== owner.nonce) {
+            return false;
+        }
+        unlinkSync(lockPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Cross-process exclusive lock so count-then-append is one critical section
+ * (#3350 / #3361). Fail-open: if the lock cannot be acquired within the wait
+ * window, emit still proceeds with a best-effort recount. Reclaim is allowed
+ * only when the owner process is dead or the token is unknown — never by
+ * mtime of a live holder.
+ */
+function acquireSeqLock(targetPath) {
+    const noop = () => {
+        /* fail-open: no lock held */
+    };
+    try {
+        const targetAbs = resolve(targetPath);
+        const parent = dirname(targetAbs);
+        mkdirSync(parent, { recursive: true });
+        const lockPath = `${targetAbs}.seq.lock`;
+        const deadline = Date.now() + SEQ_LOCK_WAIT_MS;
+        while (true) {
+            const owner = newSeqLockOwner();
+            try {
+                containedWrite({
+                    root: parent,
+                    target: lockPath,
+                    data: serializeSeqLockOwner(owner),
+                    mode: "create",
+                });
+                return () => {
+                    releaseSeqLockIfOwner(lockPath, owner);
+                };
+            }
+            catch (err) {
+                if (err instanceof ContainedWriteError && err.code === ContainedWriteErrorCode.EXISTS) {
+                    if (tryReclaimSeqLock(lockPath)) {
+                        continue;
+                    }
+                    if (Date.now() < deadline) {
+                        const spinEnd = Date.now() + SEQ_LOCK_SPIN_MS;
+                        while (Date.now() < spinEnd) {
+                            /* brief spin */
+                        }
+                        continue;
+                    }
+                }
+                return noop;
+            }
+        }
+    }
+    catch {
+        return noop;
+    }
+}
+/**
+ * Stateful emitter: one instance tracks seq and write-warning once.
+ * File destinations seed seq from the current JSONL line count so multiple
+ * CLI processes appending to one DEFT_RUN_SUMMARY_PATH share 1..N (#3350).
+ * Stdout destinations stay per-process (each constructor starts at 0).
  */
 export class RunSummaryEmitter {
     seq = 0;
@@ -105,43 +268,51 @@ export class RunSummaryEmitter {
                     env: this.env,
                     gitignoreCovers: options.gitignoreCovers,
                 });
+        this.seq = seedSeqFromDestination(this.destination);
         this.writeStdout = options.writeStdout ?? ((line) => process.stdout.write(`${line}\n`));
         this.writeStderr = options.writeStderr ?? ((line) => process.stderr.write(`${line}\n`));
     }
     getDestination() {
         return this.destination;
     }
+    buildLine(event, payload) {
+        const denominator = readPayloadToolTurnDenominator(payload) ?? readEnvToolTurnDenominator(this.env);
+        return {
+            schema_version: RUN_SUMMARY_SCHEMA_VERSION,
+            session_id: this.sessionId,
+            framework_version: this.frameworkVersion,
+            seq: this.seq,
+            ts: this.now().toISOString(),
+            event,
+            payload,
+            ...(denominator !== undefined ? { total_tool_turns: denominator } : {}),
+        };
+    }
     emit(event, payload) {
         try {
             if (this.destination.kind === "silent") {
                 return { emitted: false, destination: this.destination, line: null, warning: false };
             }
-            this.seq += 1;
-            const denominator = readPayloadToolTurnDenominator(payload) ?? readEnvToolTurnDenominator(this.env);
-            const line = {
-                schema_version: RUN_SUMMARY_SCHEMA_VERSION,
-                session_id: this.sessionId,
-                framework_version: this.frameworkVersion,
-                seq: this.seq,
-                ts: this.now().toISOString(),
-                event,
-                payload,
-                ...(denominator !== undefined ? { total_tool_turns: denominator } : {}),
-            };
-            const text = lineToJson(line);
             if (this.destination.kind === "stdout") {
-                this.writeStdout(`${RUN_SUMMARY_STDOUT_PREFIX}${text}`);
+                this.seq += 1;
+                const line = this.buildLine(event, payload);
+                this.writeStdout(`${RUN_SUMMARY_STDOUT_PREFIX}${lineToJson(line)}`);
                 return { emitted: true, destination: this.destination, line, warning: false };
             }
-            // file destination — no-follow containment (#3282 Greptile P1 security)
+            // file destination — lock count-then-append so concurrent CLI processes
+            // cannot share the same next seq (#3350 Greptile P1).
             const { path, truncateOnSessionStart, explicit } = this.destination;
+            const release = acquireSeqLock(path);
             try {
-                const mode = event === "session_start" && truncateOnSessionStart ? "replace" : "append";
-                writeRunSummaryLine(this.projectRoot, path, text, mode);
+                const replace = event === "session_start" && truncateOnSessionStart;
+                this.seq = replace ? 1 : countExistingJsonlLines(path) + 1;
+                const line = this.buildLine(event, payload);
+                writeRunSummaryLine(this.projectRoot, path, lineToJson(line), replace ? "replace" : "append");
                 return { emitted: true, destination: this.destination, line, warning: false };
             }
             catch {
                 // Symlink / containment refusal and I/O both fail-open.
+                const line = this.buildLine(event, payload);
                 if (explicit && !this.warned) {
                     this.warned = true;
                     this.writeStderr(RUN_SUMMARY_WRITE_WARNING);
@@ -149,6 +320,9 @@ export class RunSummaryEmitter {
                 }
                 return { emitted: false, destination: this.destination, line, warning: false };
             }
+            finally {
+                release();
+            }
         }
         catch {
             return { emitted: false, destination: this.destination, line: null, warning: false };
@@ -186,6 +360,16 @@ export class RunSummaryEmitter {
         }
         return this.emitToolTurnDenominator({ total_tool_turns: n });
     }
+    /**
+     * Always emit a session denominator when the destination is live (#3356).
+     * `emitKnownToolTurnDenominator` stays silent unless DEFT_TOTAL_TOOL_TURNS is
+     * set; this caller records host planned turns or the session:start CLI floor.
+     */
+    emitSessionToolTurnDenominator(hostMaxTurns) {
+        return this.emitToolTurnDenominator({
+            total_tool_turns: resolveSessionToolTurnDenominator(this.env, hostMaxTurns),
+        });
+    }
 }
 function readPayloadToolTurnDenominator(payload) {
     if (!("total_tool_turns" in payload)) {
@@ -196,19 +380,60 @@ function readPayloadToolTurnDenominator(payload) {
 }
 /** Parse harness-supplied DEFT_TOTAL_TOOL_TURNS (integer > 0). Invalid/unset → omit. */
 export function readEnvToolTurnDenominator(env) {
-    const raw = env[ENV_TOTAL_TOOL_TURNS];
+    return readPositiveIntegerEnv(env, ENV_TOTAL_TOOL_TURNS);
+}
+/** Canonical host planned-turn budget recorded at session:start (#3356). */
+export const ENV_MAX_TURNS_DENOMINATOR = "DEFT_MAX_TURNS";
+/** session:start is one CLI invocation when no host/harness count is known (#3356). */
+export const SESSION_START_CLI_INVOCATION_DENOMINATOR = 1;
+function isPositiveIntegerDenominator(value) {
+    return (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value > 0);
+}
+/**
+ * Host descriptors (#3266) accept any finite number >= 0. Keep a positive
+ * planned-turn budget as-is so share uses the host value, not a floored proxy.
+ */
+function coercePositiveHostDenominator(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    return value;
+}
+function readPositiveIntegerEnv(env, key) {
+    const raw = env[key];
     if (raw === undefined || raw.trim().length === 0) {
         return undefined;
     }
     const n = Number(raw.trim());
-    if (!Number.isInteger(n) || !Number.isFinite(n) || n <= 0) {
-        return undefined;
+    return isPositiveIntegerDenominator(n) ? n : undefined;
+}
+/**
+ * Resolve the session tool/turn denominator (#3356).
+ *
+ * Prefer harness actuals (`DEFT_TOTAL_TOOL_TURNS`), then a host planned-turn
+ * budget (`DEFT_MAX_TURNS` or `hostMaxTurns` from the session:start descriptor),
+ * else this CLI invocation (1). An emitted proxy beats a perfect unused kind.
+ */
+export function resolveSessionToolTurnDenominator(env, hostMaxTurns) {
+    const known = readEnvToolTurnDenominator(env);
+    if (known !== undefined) {
+        return known;
+    }
+    const planned = readPositiveIntegerEnv(env, ENV_MAX_TURNS_DENOMINATOR);
+    if (planned !== undefined) {
+        return planned;
+    }
+    const host = coercePositiveHostDenominator(hostMaxTurns);
+    if (host !== undefined) {
+        return host;
     }
-    return n;
+    return SESSION_START_CLI_INVOCATION_DENOMINATOR;
 }
 /**
  * One-shot helper for call sites that do not hold an emitter (e.g. dial escalate).
- * Still fail-open; creates a fresh seq=1 emitter unless `seqSeed` is passed via reuse.
+ * Still fail-open. File destinations seed seq from the existing JSONL line
+ * count so successive one-shot calls into the same path continue 1..N (#3350).
+ * Stdout destinations stay per-process (each call starts at seq=1).
  */
 export function emitRunSummaryEvent(options) {
     const emitter = new RunSummaryEmitter(options);

package/dist/run-summary/index.d.ts

@@ -1,4 +1,4 @@
-export { type EmitRunSummaryResult, emitRunSummaryEvent, RunSummaryEmitter, type RunSummaryEmitterOptions, } from "./emit.js";
+export { type EmitRunSummaryResult, ENV_MAX_TURNS_DENOMINATOR, emitRunSummaryEvent, RunSummaryEmitter, type RunSummaryEmitterOptions, resolveSessionToolTurnDenominator, SESSION_START_CLI_INVOCATION_DENOMINATOR, } from "./emit.js";
 export { gitignoreCoversRunSummary, type ResolveRunSummaryDestinationOptions, resolveRunSummaryDestination, } from "./path.js";
 export { computeRitualGateShare, parseRunSummaryJsonl, type RitualGateShare, readToolTurnDenominator, } from "./share.js";
 export { type AcceptanceClauseOutcomeRow, type AcceptanceRunSummaryOutcome, type AcceptanceRunSummaryPayload, type AcceptanceStampRunSummaryPayload, type CheckGateOutcome, type CheckInvocationRunSummaryPayload, DEFAULT_RUN_SUMMARY_BASENAME, type DialEscalationEvaluationOutcome, type DialEscalationEvaluationRunSummaryPayload, type DialTransitionRunSummaryPayload, ENV_RUN_SUMMARY_PATH, ENV_TOTAL_TOOL_TURNS, RUN_SUMMARY_EVENT_KINDS, RUN_SUMMARY_SCHEMA_VERSION, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, type RunSummaryBaseFields, type RunSummaryDestination, type RunSummaryEventKind, type RunSummaryLine, type RunSummaryPayload, type SessionStartRunSummaryPayload, type ToolTurnDenominatorRunSummaryPayload, type VerificationOutcome, type VerificationRunSummaryPayload, } from "./types.js";

package/dist/run-summary/index.js

@@ -1,4 +1,4 @@
-export { emitRunSummaryEvent, RunSummaryEmitter, } from "./emit.js";
+export { ENV_MAX_TURNS_DENOMINATOR, emitRunSummaryEvent, RunSummaryEmitter, resolveSessionToolTurnDenominator, SESSION_START_CLI_INVOCATION_DENOMINATOR, } from "./emit.js";
 export { gitignoreCoversRunSummary, resolveRunSummaryDestination, } from "./path.js";
 export { computeRitualGateShare, parseRunSummaryJsonl, readToolTurnDenominator, } from "./share.js";
 export { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, ENV_TOTAL_TOOL_TURNS, RUN_SUMMARY_EVENT_KINDS, RUN_SUMMARY_SCHEMA_VERSION, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";

package/dist/run-summary/share.d.ts

@@ -11,7 +11,7 @@ export interface RitualGateShare {
     readonly totalToolTurns: number | null;
     readonly share: number | null;
 }
-/** True when n is a finite integer usable as a share denominator. */
+/** True when n is a finite positive number usable as a share denominator. */
 export declare function isValidToolTurnDenominator(value: unknown): value is number;
 /** Read total_tool_turns from a line (top-level field or payload). */
 export declare function readToolTurnDenominator(line: unknown): number | undefined;

package/dist/run-summary/share.js

@@ -11,9 +11,9 @@ function asRecord(value) {
     }
     return value;
 }
-/** True when n is a finite integer usable as a share denominator. */
+/** True when n is a finite positive number usable as a share denominator. */
 export function isValidToolTurnDenominator(value) {
-    return (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value > 0);
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
 }
 /** Read total_tool_turns from a line (top-level field or payload). */
 export function readToolTurnDenominator(line) {

package/dist/run-summary/types.d.ts

@@ -21,7 +21,14 @@ export interface RunSummaryBaseFields {
     readonly schema_version: typeof RUN_SUMMARY_SCHEMA_VERSION;
     readonly session_id: string;
     readonly framework_version: string;
-    /** Monotonic per-emitter sequence (1-based). */
+    /**
+     * Monotonic 1-based sequence for this destination (#3350).
+     * File destinations continue from the existing JSONL line count so multiple
+     * CLI processes appending to one DEFT_RUN_SUMMARY_PATH share 1..N. Concurrent
+     * file writers serialize count-then-append via a sibling lock; reclaim is
+     * allowed only when the lock owner process is dead or the token is unknown
+     * (#3361). Stdout destinations stay per-process (each process starts at 1).
+     */
     readonly seq: number;
     readonly ts: string;
     readonly event: RunSummaryEventKind;
@@ -87,8 +94,8 @@ export interface ToolTurnDenominatorRunSummaryPayload {
 }
 /** Product-oracle attempt (#3322). Same emitter as #3319 / #3320. */
 export type VerificationOutcome = "pass" | "fail";
-/** verify:ac resolution telemetry (#3334). Distinct from verification pass/fail. */
-export type AcceptanceRunSummaryOutcome = "verified-pass" | "empty-pass" | "soft_empty" | "fail";
+/** verify:ac resolution telemetry (#3334 / #3355). Distinct from verification pass/fail. */
+export type AcceptanceRunSummaryOutcome = "verified-pass" | "empty-pass" | "soft_empty" | "fail" | "config-error" | "soft-missing";
 export interface AcceptanceRunSummaryPayload {
     readonly resolved_command_count: number;
     readonly outcome: AcceptanceRunSummaryOutcome;

package/dist/scope/acceptance-activate-gate.d.ts

@@ -3,7 +3,7 @@
  *
  * Agents author Test / AcceptanceCriteria / Verification prose in narratives
  * and then skip the executable plan.acceptance block. Activation fails closed
- * with one remediation: stamp the acceptance block.
+ * with one remediation: stamp plan.acceptance via clause derivation.
  */
 export interface AcceptanceActivateHit {
     readonly key: string;

package/dist/scope/acceptance-activate-gate.js

@@ -3,7 +3,7 @@
  *
  * Agents author Test / AcceptanceCriteria / Verification prose in narratives
  * and then skip the executable plan.acceptance block. Activation fails closed
- * with one remediation: stamp the acceptance block.
+ * with one remediation: stamp plan.acceptance via clause derivation.
  */
 import { validatePlanAcceptance } from "../product-first-done-gate/acceptance.js";
 function asRecord(value) {
@@ -51,7 +51,7 @@ export function evaluateAcceptanceActivateGate(plan) {
                 ok: false,
                 message: `Refusing activate: plan.acceptance is present but invalid (#3334): ` +
                     `${schemaErrors.join("; ")}. Stamp a valid plan.acceptance block ` +
-                    `(author commands or none_stated via intake capture / task issue:ingest).`,
+                    `via clause derivation (scope:activate / scope:promote runs #3323).`,
                 hits,
             };
         }
@@ -61,8 +61,8 @@ export function evaluateAcceptanceActivateGate(plan) {
     return {
         ok: false,
         message: `Refusing activate: narratives contain acceptance-shaped keys (${keys}) ` +
-            `but plan.acceptance is absent (#3334). Stamp plan.acceptance ` +
-            `(author commands or none_stated via intake capture / task issue:ingest) — ` +
+            `but plan.acceptance is absent (#3334). Stamp plan.acceptance via clause derivation ` +
+            `(scope:activate / scope:promote runs #3323, or task issue:ingest) — ` +
             `the criteria are in the wrong, non-executable field.`,
         hits,
     };

package/dist/scope/acceptance-evidence.d.ts

@@ -13,6 +13,7 @@
  * ITEM_CORE is not expanded with bare keys; verify:vbrief-conformance rejects them.
  */
 import type { GrantOrigin } from "../authz/types.js";
+import { type EvaluateVerifyAcOptions } from "../product-first-done-gate/evaluate.js";
 /** Canonical namespaced key for typed acceptance evidence (#3305 / #1620). */
 export declare const ACCEPTANCE_EVIDENCE_KEY: "x-directive/evidence";
 /** Canonical namespaced key for human-origin disposition (#3305 / #1620). */
@@ -98,6 +99,20 @@ export declare function stampNamespacedEvidence(item: Record<string, unknown>, r
  * cannot carry both acceptance fields after a replace (#3305 Greptile P2).
  */
 export declare function stampNamespacedDisposition(item: Record<string, unknown>, record: AcceptanceDispositionRecord): void;
+/**
+ * One remediation when scope:complete cannot accept empty or failing product AC (#3357).
+ * Item-level disposition is not a substitute for the acceptance walk.
+ */
+export declare const SCOPE_COMPLETE_ACCEPTANCE_REMEDIATION = "Run task verify:ac -- <completing-xbrief> and stamp executable plan.acceptance; scope:complete refuses empty or failing acceptance (disposition is not a substitute) (#3357)";
+/**
+ * Hard precondition for scope:complete (#3357 / #3267 / #3284).
+ *
+ * Runs the same verify:ac walk check uses. Disposition on plan items does not
+ * skip it. Briefs with no stamped plan.acceptance and no executable commands
+ * keep the legacy #3267 "nothing to run" pass so existing evidence-only
+ * fixtures stay valid.
+ */
+export declare function evaluateScopeCompleteAcceptanceWalk(plan: Record<string, unknown>, options?: EvaluateVerifyAcOptions): AcceptanceEvidenceGateResult;
 /**
  * Fail closed when any non-terminal plan item lacks suitable evidence or a human-origin disposition.
  */

package/dist/scope/acceptance-evidence.js

@@ -13,6 +13,7 @@
  * ITEM_CORE is not expanded with bare keys; verify:vbrief-conformance rejects them.
  */
 import { isHumanOrigin } from "../authz/origin.js";
+import { evaluateVerifyAcFromPlan, } from "../product-first-done-gate/evaluate.js";
 /** Canonical namespaced key for typed acceptance evidence (#3305 / #1620). */
 export const ACCEPTANCE_EVIDENCE_KEY = "x-directive/evidence";
 /** Canonical namespaced key for human-origin disposition (#3305 / #1620). */
@@ -369,6 +370,44 @@ function walkItems(items, pathPrefix, reports) {
         walkItems(obj.items, `${path}.items`, reports);
     });
 }
+/**
+ * One remediation when scope:complete cannot accept empty or failing product AC (#3357).
+ * Item-level disposition is not a substitute for the acceptance walk.
+ */
+export const SCOPE_COMPLETE_ACCEPTANCE_REMEDIATION = "Run task verify:ac -- <completing-xbrief> and stamp executable plan.acceptance; scope:complete refuses empty or failing acceptance (disposition is not a substitute) (#3357)";
+/**
+ * Hard precondition for scope:complete (#3357 / #3267 / #3284).
+ *
+ * Runs the same verify:ac walk check uses. Disposition on plan items does not
+ * skip it. Briefs with no stamped plan.acceptance and no executable commands
+ * keep the legacy #3267 "nothing to run" pass so existing evidence-only
+ * fixtures stay valid.
+ */
+export function evaluateScopeCompleteAcceptanceWalk(plan, options = {}) {
+    const stamped = plan.acceptance !== undefined;
+    const walk = evaluateVerifyAcFromPlan(plan, {
+        ...options,
+        checkIntegrated: false,
+        captureFromNarratives: options.captureFromNarratives ?? true,
+    });
+    const rejectedCount = walk.rejected?.length ?? 0;
+    const hadWork = walk.runs.length > 0 || walk.commands.length > 0 || rejectedCount > 0;
+    if (!stamped && !hadWork) {
+        return {
+            ok: true,
+            message: "Acceptance walk not required (no stamped plan.acceptance) (#3357)",
+            reports: [],
+        };
+    }
+    if (walk.ok) {
+        return { ok: true, message: walk.message, reports: [] };
+    }
+    return {
+        ok: false,
+        message: `${SCOPE_COMPLETE_ACCEPTANCE_REMEDIATION}\n${walk.message}`,
+        reports: [],
+    };
+}
 /**
  * Fail closed when any non-terminal plan item lacks suitable evidence or a human-origin disposition.
  */

package/dist/scope/capacity-stamp.d.ts

@@ -19,6 +19,8 @@ export interface StampCompletionOptions {
      * tests so the fallback path is exercised without a network call.
      */
     readonly liveLabelReader?: LabelReader;
+    /** Session that ran scope:complete; check uses this to target xbrief/completed (#3357). */
+    readonly completedSessionId?: string | null;
 }
 /** Stamp completedAt + label-matched capacityBucket onto a completing vBRIEF (#1419, #2237). */
 export declare function stampCompletionMetadata(plan: Record<string, unknown>, projectRoot: string, timestamp: string, options?: StampCompletionOptions): void;

package/dist/scope/capacity-stamp.js

@@ -86,6 +86,10 @@ export function stampCompletionMetadata(plan, projectRoot, timestamp, options =
     }
     const meta = metadata;
     meta.completedAt = timestamp;
+    const sessionId = options.completedSessionId?.trim() ?? "";
+    if (sessionId.length > 0) {
+        meta.completedSessionId = sessionId;
+    }
     const existing = meta.capacityBucket;
     if (typeof existing === "string" && existing.trim().length > 0) {
         return;

package/dist/scope/delivery-evidence.d.ts

@@ -32,6 +32,8 @@ export interface CompletionProvenance {
     readonly deployed: boolean | null;
     /** Always null unless explicitly supplied — never inferred from Git (#3041). */
     readonly uatVerified: boolean | null;
+    /** Session that completed the brief; used by check to target xbrief/completed (#3357). */
+    readonly completedSessionId?: string | null;
 }
 export interface DeliveryEvidenceInput {
     readonly repository?: string | null;
@@ -67,6 +69,10 @@ export interface DeliveryGateResult {
     readonly provenance: CompletionProvenance | null;
     readonly codeBearing: boolean;
 }
+/**
+ * Session id for a completing brief (#3357). Prefer DEFT_SESSION_ID, then ritual-state.
+ */
+export declare function resolveCompletionSessionId(projectRoot: string, env?: NodeJS.ProcessEnv): string | null;
 export declare function isNonDeliveryDisposition(value: unknown): value is NonDeliveryDisposition;
 /** True when the brief is treated as code-bearing for the delivery gate (#3041). */
 export declare function isCodeBearingScope(plan: Record<string, unknown>): boolean;

package/dist/scope/delivery-evidence.js

@@ -9,6 +9,7 @@
  */
 import { resolveDeliveryBranch } from "../policy/delivery-branch.js";
 import { defaultGitRunner, gitIsAncestor } from "../session/git.js";
+import { readRitualState } from "../session/ritual-sentinel.js";
 /** Handoff states that Git delivery can assert (deploy/UAT never inferred). */
 export const HANDOFF_STATES = [
     "implemented",
@@ -29,6 +30,18 @@ function asRecord(value) {
     }
     return null;
 }
+/**
+ * Session id for a completing brief (#3357). Prefer DEFT_SESSION_ID, then ritual-state.
+ */
+export function resolveCompletionSessionId(projectRoot, env = process.env) {
+    const fromEnv = typeof env.DEFT_SESSION_ID === "string" ? env.DEFT_SESSION_ID.trim() : "";
+    if (fromEnv.length > 0) {
+        return fromEnv;
+    }
+    const [state] = readRitualState(projectRoot);
+    const id = state?.sessionId.trim() ?? "";
+    return id.length > 0 ? id : null;
+}
 export function isNonDeliveryDisposition(value) {
     return (typeof value === "string" && NON_DELIVERY_DISPOSITIONS.includes(value));
 }
@@ -380,6 +393,10 @@ export function stampDeliveryProvenance(plan, provenance) {
         // Deploy/UAT are explicit-only; default null so readers never infer from Git.
         deployed: provenance.deployed,
         uatVerified: provenance.uatVerified,
+        ...(typeof provenance.completedSessionId === "string" &&
+            provenance.completedSessionId.trim().length > 0
+            ? { completedSessionId: provenance.completedSessionId.trim() }
+            : {}),
     };
     meta.deliveryDisposition = provenance.disposition;
     meta.handoffState = provenance.handoffState;