@deftai/directive-core 0.103.0 → 0.105.0

package/dist/run-summary/emit.js

@@ -5,12 +5,14 @@
  * 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 { resolveRunSummarySessionId } from "./session-id.js";
 import { ENV_TOTAL_TOOL_TURNS, RUN_SUMMARY_SCHEMA_VERSION, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";
 function sortKeysDeep(value) {
     if (Array.isArray(value)) {
@@ -80,13 +82,176 @@ 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;
     warned = false;
     projectRoot;
     sessionId;
+    component;
     frameworkVersion;
     now;
     destination;
@@ -95,7 +260,12 @@ export class RunSummaryEmitter {
     writeStderr;
     constructor(options) {
         this.projectRoot = options.projectRoot;
-        this.sessionId = options.sessionId;
+        this.sessionId = resolveRunSummarySessionId({
+            projectRoot: options.projectRoot,
+            explicit: options.sessionId,
+            env: options.env,
+        });
+        this.component = options.component?.trim() || undefined;
         this.frameworkVersion = options.frameworkVersion ?? readCorePackageVersion();
         this.now = options.now ?? (() => new Date());
         this.env = options.env ?? process.env;
@@ -105,43 +275,52 @@ 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,
+            ...(this.component !== undefined ? { component: this.component } : {}),
+            ...(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 +328,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 };
@@ -178,6 +360,9 @@ export class RunSummaryEmitter {
     emitAcceptanceStamp(payload) {
         return this.emit("acceptance_stamp", payload);
     }
+    emitAcPassBank(payload) {
+        return this.emit("ac_pass_bank", payload);
+    }
     /** Emit the harness-supplied denominator when DEFT_TOTAL_TOOL_TURNS is set. */
     emitKnownToolTurnDenominator() {
         const n = readEnvToolTurnDenominator(this.env);
@@ -186,6 +371,18 @@ export class RunSummaryEmitter {
         }
         return this.emitToolTurnDenominator({ total_tool_turns: n });
     }
+    /**
+     * Emit a session denominator only when a host/harness value is known (#3399).
+     * `emitKnownToolTurnDenominator` stays silent unless DEFT_TOTAL_TOOL_TURNS is
+     * set; this caller also records DEFT_MAX_TURNS / host maxTurns.
+     */
+    emitSessionToolTurnDenominator(hostMaxTurns) {
+        const resolved = resolveSessionToolTurnDenominator(this.env, hostMaxTurns);
+        if (resolved === undefined) {
+            return { emitted: false, destination: this.destination, line: null, warning: false };
+        }
+        return this.emitToolTurnDenominator(resolved);
+    }
 }
 function readPayloadToolTurnDenominator(payload) {
     if (!("total_tool_turns" in payload)) {
@@ -196,19 +393,58 @@ 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";
+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 (#3399).
+ *
+ * Prefer harness actuals (`DEFT_TOTAL_TOOL_TURNS`), then a host planned-turn
+ * budget (`DEFT_MAX_TURNS` or `hostMaxTurns`). Unset → undefined (no event).
+ * Share is unevaluable without a host/harness value.
+ */
+export function resolveSessionToolTurnDenominator(env, hostMaxTurns) {
+    const known = readEnvToolTurnDenominator(env);
+    if (known !== undefined) {
+        return { total_tool_turns: known, denominator_source: "harness_actual" };
+    }
+    const planned = readPositiveIntegerEnv(env, ENV_MAX_TURNS_DENOMINATOR);
+    if (planned !== undefined) {
+        return { total_tool_turns: planned, denominator_source: "host_planned" };
+    }
+    const host = coercePositiveHostDenominator(hostMaxTurns);
+    if (host !== undefined) {
+        return { total_tool_turns: host, denominator_source: "host_planned" };
     }
-    return n;
+    return undefined;
 }
 /**
  * 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,5 +1,6 @@
-export { type EmitRunSummaryResult, emitRunSummaryEvent, RunSummaryEmitter, type RunSummaryEmitterOptions, } from "./emit.js";
+export { type EmitRunSummaryResult, ENV_MAX_TURNS_DENOMINATOR, emitRunSummaryEvent, type ResolvedSessionToolTurnDenominator, RunSummaryEmitter, type RunSummaryEmitterOptions, resolveSessionToolTurnDenominator, } from "./emit.js";
 export { gitignoreCoversRunSummary, type ResolveRunSummaryDestinationOptions, resolveRunSummaryDestination, } from "./path.js";
+export { type ResolveRunSummarySessionIdInput, resolveRunSummarySessionId, } from "./session-id.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";
+export { type AcceptanceClauseOutcomeRow, type AcceptanceRunSummaryOutcome, type AcceptanceRunSummaryPayload, type AcceptanceStampRunSummaryPayload, type AcPassBankRunSummaryPayload, 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 ToolTurnDenominatorSource, type VerificationOutcome, type VerificationRunSummaryPayload, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/run-summary/index.js

@@ -1,5 +1,6 @@
-export { emitRunSummaryEvent, RunSummaryEmitter, } from "./emit.js";
+export { ENV_MAX_TURNS_DENOMINATOR, emitRunSummaryEvent, RunSummaryEmitter, resolveSessionToolTurnDenominator, } from "./emit.js";
 export { gitignoreCoversRunSummary, resolveRunSummaryDestination, } from "./path.js";
+export { resolveRunSummarySessionId, } from "./session-id.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";
 //# sourceMappingURL=index.js.map

package/dist/run-summary/session-id.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared workspace session identity for run-summary emitters (#3399).
+ *
+ * Ritual-state holds the workspace session id written by session:start.
+ * #3350 persisted seq by counting JSONL lines; it is not the identity store.
+ */
+export interface ResolveRunSummarySessionIdInput {
+    readonly projectRoot: string;
+    readonly explicit?: string | null;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly mint?: () => string;
+}
+/**
+ * Resolve one workspace session id for a run-summary line.
+ *
+ * Order: explicit option → DEFT_SESSION_ID → ritual-state session_id →
+ * last session_id already in the destination JSONL → mint only when no
+ * workspace session exists yet.
+ */
+export declare function resolveRunSummarySessionId(input: ResolveRunSummarySessionIdInput): string;
+//# sourceMappingURL=session-id.d.ts.map

package/dist/run-summary/session-id.js

@@ -0,0 +1,92 @@
+/**
+ * Shared workspace session identity for run-summary emitters (#3399).
+ *
+ * Ritual-state holds the workspace session id written by session:start.
+ * #3350 persisted seq by counting JSONL lines; it is not the identity store.
+ */
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { readRitualState } from "../session/ritual-sentinel.js";
+import { resolveRunSummaryDestination } from "./path.js";
+import { parseRunSummaryJsonl } from "./share.js";
+const mintedByProjectRoot = new Map();
+function trimNonEmpty(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function lastSessionIdFromJsonl(path) {
+    try {
+        if (!existsSync(path)) {
+            return undefined;
+        }
+        const lines = parseRunSummaryJsonl(readFileSync(path, "utf8"));
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            const id = trimNonEmpty(lines[i]?.session_id);
+            if (id !== undefined) {
+                return id;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ritualSessionId(projectRoot) {
+    try {
+        const [state] = readRitualState(projectRoot);
+        return trimNonEmpty(state?.sessionId);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve one workspace session id for a run-summary line.
+ *
+ * Order: explicit option → DEFT_SESSION_ID → ritual-state session_id →
+ * last session_id already in the destination JSONL → mint only when no
+ * workspace session exists yet.
+ */
+export function resolveRunSummarySessionId(input) {
+    const explicit = trimNonEmpty(input.explicit);
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    const env = input.env ?? process.env;
+    const fromEnv = trimNonEmpty(env.DEFT_SESSION_ID);
+    if (fromEnv !== undefined) {
+        return fromEnv;
+    }
+    const fromRitual = ritualSessionId(input.projectRoot);
+    if (fromRitual !== undefined) {
+        return fromRitual;
+    }
+    const dest = resolveRunSummaryDestination(input.projectRoot, { env });
+    if (dest.kind === "file") {
+        const fromJsonl = lastSessionIdFromJsonl(dest.path);
+        if (fromJsonl !== undefined) {
+            return fromJsonl;
+        }
+    }
+    const rootKey = resolve(input.projectRoot);
+    if (input.mint !== undefined) {
+        const minted = trimNonEmpty(input.mint());
+        if (minted !== undefined) {
+            mintedByProjectRoot.set(rootKey, minted);
+            return minted;
+        }
+    }
+    const cached = mintedByProjectRoot.get(rootKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const minted = randomUUID();
+    mintedByProjectRoot.set(rootKey, minted);
+    return minted;
+}
+//# sourceMappingURL=session-id.js.map

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

@@ -15,16 +15,28 @@ export declare const DEFAULT_RUN_SUMMARY_BASENAME = ".deft-run-summary.json";
 export declare const RUN_SUMMARY_STDOUT_PREFIX = "DEFT-TLM:";
 /** One warning when an explicitly requested write fails. */
 export declare const RUN_SUMMARY_WRITE_WARNING = "[deft run-summary] failed to write DEFT_RUN_SUMMARY_PATH telemetry (fail-open; exit codes unchanged)";
-export declare const RUN_SUMMARY_EVENT_KINDS: readonly ["session_start", "dial_transition", "dial_escalation_evaluation", "check_invocation", "tool_turn_denominator", "verification", "acceptance", "acceptance_stamp"];
+export declare const RUN_SUMMARY_EVENT_KINDS: readonly ["session_start", "dial_transition", "dial_escalation_evaluation", "check_invocation", "tool_turn_denominator", "verification", "acceptance", "acceptance_stamp", "ac_pass_bank"];
 export type RunSummaryEventKind = (typeof RUN_SUMMARY_EVENT_KINDS)[number];
 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;
+    /**
+     * Optional emitter label (verify-ac, clause-derivation, …). Not a closed
+     * union — new callers add a string without a schema bump (#3399).
+     */
+    readonly component?: string;
     /**
      * Session total tool/turn count (#3320). Present so ritual+gate share is
      * computable from the summary alone. Absence means the #3286 trigger is unevaluable.
@@ -81,14 +93,32 @@ export interface CheckInvocationRunSummaryPayload {
     readonly none_stated?: boolean;
     readonly clause_outcomes?: readonly AcceptanceClauseOutcomeRow[];
 }
-/** Total tool/turn count for the session (#3320). */
+/** How a tool_turn_denominator value was obtained (#3399). */
+export type ToolTurnDenominatorSource = "harness_actual" | "host_planned";
+/** Total tool/turn count for the session (#3320 / #3399). */
 export interface ToolTurnDenominatorRunSummaryPayload {
     readonly total_tool_turns: number;
+    readonly denominator_source?: ToolTurnDenominatorSource;
+}
+/** Bank checkpoint JSONL payload. Disk ledger stays camelCase (#3387). */
+export interface AcPassBankRunSummaryPayload {
+    readonly scope_id: string;
+    readonly banked_at: string;
+    readonly next_action?: string;
+    readonly had_surplus?: boolean;
+    readonly surplus_threshold?: number;
+    readonly remaining_fraction?: number | null;
+    readonly remaining_turns?: number | null;
+    readonly remaining_budget?: number | null;
+    readonly max_turns?: number | null;
+    readonly max_budget?: number | null;
+    readonly head_sha?: string | null;
+    readonly path?: string;
 }
 /** 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" | "rejected-noop";
 export interface AcceptanceRunSummaryPayload {
     readonly resolved_command_count: number;
     readonly outcome: AcceptanceRunSummaryOutcome;
@@ -96,6 +126,8 @@ export interface AcceptanceRunSummaryPayload {
     readonly none_stated?: boolean;
     readonly clause_count?: number;
     readonly clause_outcomes?: readonly AcceptanceClauseOutcomeRow[];
+    /** bank | cache | executed — how verify:ac obtained this result (#3387). */
+    readonly served_from?: "bank" | "cache" | "executed";
 }
 /** Intake-time stamp: which rung locked, whether commands were stated, counts (#3323). */
 export interface AcceptanceStampRunSummaryPayload {
@@ -115,7 +147,7 @@ export interface VerificationRunSummaryPayload {
      */
     readonly independent_rederivation?: boolean;
 }
-export type RunSummaryPayload = SessionStartRunSummaryPayload | DialTransitionRunSummaryPayload | DialEscalationEvaluationRunSummaryPayload | CheckInvocationRunSummaryPayload | ToolTurnDenominatorRunSummaryPayload | VerificationRunSummaryPayload | AcceptanceRunSummaryPayload | AcceptanceStampRunSummaryPayload;
+export type RunSummaryPayload = SessionStartRunSummaryPayload | DialTransitionRunSummaryPayload | DialEscalationEvaluationRunSummaryPayload | CheckInvocationRunSummaryPayload | ToolTurnDenominatorRunSummaryPayload | VerificationRunSummaryPayload | AcceptanceRunSummaryPayload | AcceptanceStampRunSummaryPayload | AcPassBankRunSummaryPayload;
 export type RunSummaryLine = RunSummaryBaseFields & {
     readonly payload: RunSummaryPayload;
 };

package/dist/run-summary/types.js

@@ -24,5 +24,6 @@ export const RUN_SUMMARY_EVENT_KINDS = [
     "verification",
     "acceptance",
     "acceptance_stamp",
+    "ac_pass_bank",
 ];
 //# sourceMappingURL=types.js.map

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,
     };