@deftai/directive-core 0.101.0 → 0.103.0

package/dist/product-first-done-gate/evaluate.js

@@ -3,14 +3,19 @@
  *
  * Runs plan.acceptance.commands (or #3267 literal ledger) via the shared
  * literal-acceptance runner. Records source_rung in the result message.
- * Project floor with empty commands is a soft pass (suite gates own the floor
- * inside full `task check`); standalone done paths still surface the rung.
+ * Project floor with empty commands is a soft pass only when a suite floor
+ * exists (suite gates own the floor inside full `task check`). With no suite
+ * floor, empty resolution is soft_empty — not a green run (#3334).
  */
 import { existsSync, readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
+import { basename, isAbsolute, relative, resolve } from "node:path";
 import { evaluateLiteralAcceptanceFromPlan, runLiteralAcceptanceCommands, } from "../literal-acceptance/index.js";
+import { ENV_RUN_SUMMARY_PATH, RunSummaryEmitter, } from "../run-summary/index.js";
 import { maybeBankOnAcPass } from "../session/ac-pass-banking.js";
+import { formatClauseWalkMessage, walkAcceptanceClauses, } from "../verify-ac/clauses.js";
+import { emitVerifyAcAttempts, evaluateProductOracleIntegrity, mergeOracleVerdict, } from "../verify-ac/evaluate.js";
 import { readPlanAcceptance, validatePlanAcceptance } from "./acceptance.js";
+import { formatSoftEmptyMessage, isEmptyAcResolution, projectHasSuiteFloor, } from "./empty-resolution.js";
 function asRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         return value;
@@ -21,11 +26,16 @@ function asRecord(value) {
  * Evaluate product AC from an in-memory plan.
  */
 export function evaluateVerifyAcFromPlan(plan, options = {}) {
+    const planId = typeof plan.id === "string" && plan.id.trim() ? plan.id.trim() : null;
+    const optionsWithScope = {
+        ...options,
+        oracleScopeKey: options.oracleScopeKey?.trim() || planId || null,
+    };
     const acceptance = readPlanAcceptance(plan);
     const schemaErrors = validatePlanAcceptance(plan.acceptance ?? acceptance);
     // Only hard-fail schema when an explicit plan.acceptance object exists.
     if (plan.acceptance !== undefined && schemaErrors.length > 0) {
-        return {
+        return applyOracle({
             ok: false,
             code: 2,
             message: `verify:ac config error (#3284): ${schemaErrors.join("; ")}`,
@@ -34,9 +44,11 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             sourceRung: acceptance.source_rung,
             noneStated: acceptance.none_stated,
             acceptance,
-        };
+            resolution: "config",
+            resolvedCommandCount: 0,
+        }, optionsWithScope);
     }
-    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const projectRoot = resolve(optionsWithScope.projectRoot ?? process.cwd());
     // Prefer shared literal-acceptance path so safety / promotion rules stay one place.
     // Empty plan.acceptance.commands still consults the #3267 rejected ledger
     // (Greptile P1: rejected stated AC must never soft-pass).
@@ -44,9 +56,13 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
     // if the literal ledger is empty of executables.
     const base = evaluateLiteralAcceptanceFromPlan(plan, {
         projectRoot,
-        runner: options.runner,
-        captureFromNarratives: options.captureFromNarratives,
-        quiet: options.quiet,
+        runner: optionsWithScope.runner,
+        // Check composition uses the stamped ledger only. Re-scanning issue prose
+        // during `task check` re-captures backtick `verify:ac` lines as rejected
+        // and deadlocks the graph (#3323 / #3284 check-integrated).
+        captureFromNarratives: optionsWithScope.captureFromNarratives ??
+            (optionsWithScope.checkIntegrated === true ? false : undefined),
+        quiet: optionsWithScope.quiet,
     });
     // When literal path had nothing executable but plan.acceptance has derived commands,
     // run them directly with source=explicit semantics.
@@ -54,7 +70,7 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
         base.runs.length === 0 &&
         acceptance.commands.length > 0 &&
         (acceptance.source_rung === "derived" || acceptance.source_rung === "project_floor")) {
-        const runner = options.runner;
+        const runner = optionsWithScope.runner;
         const direct = runLiteralAcceptanceCommands(acceptance.commands.map((c) => ({
             command: c.command,
             cwd: c.cwd ?? null,
@@ -62,25 +78,29 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             expectedExitCode: c.expectedExitCode ?? 0,
             source: "explicit",
             sourceSpan: "plan.acceptance.commands",
-        })), { projectRoot, runner, allowTaskStatement: options.allowTaskStatement });
-        return annotate(direct, acceptance, options.quiet);
+        })), {
+            projectRoot,
+            runner,
+            allowTaskStatement: optionsWithScope.allowTaskStatement,
+        });
+        return applyOracle(annotate(direct, acceptance, optionsWithScope.quiet), optionsWithScope);
     }
     // Check composition: mid-story unpromoted capture-only may soft-pass so the
     // framework graph is not deadlocked before agents promote peers.
     // Greptile P1 #3284: safety-rejected stated commands NEVER soft-pass — they
     // block product verification until a safe alternative is promoted.
-    if (options.checkIntegrated === true && !base.ok && base.runs.length === 0) {
+    if (optionsWithScope.checkIntegrated === true && !base.ok && base.runs.length === 0) {
         const hasRejected = (base.rejected?.length ?? 0) > 0;
         if (hasRejected) {
-            return annotate(base, acceptance, options.quiet);
+            return applyOracle(annotate(base, acceptance, optionsWithScope.quiet), optionsWithScope);
         }
         const unpromoted = /capture-only|task_statement|no matching agent-promoted/i.test(base.message) ||
             (base.commands.length > 0 && base.commands.every((c) => c.source === "task_statement"));
         if (unpromoted || base.commands.length === 0) {
-            return {
+            return applyOracle({
                 ok: true,
                 code: 0,
-                message: options.quiet
+                message: optionsWithScope.quiet
                     ? ""
                     : `verify:ac advisory (#3284 check-integrated): no executable AC peers yet ` +
                         `(capture-only / empty). Done-gate standalone verify:ac still requires promotion. ` +
@@ -92,10 +112,165 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
                 sourceRung: acceptance.source_rung,
                 noneStated: acceptance.none_stated,
                 acceptance,
-            };
+                resolution: classifyResolution({
+                    ok: true,
+                    code: 0,
+                    runsLength: 0,
+                    commandCount: base.commands.length,
+                    rejectedCount: base.rejected?.length ?? 0,
+                }),
+                resolvedCommandCount: base.commands.length,
+            }, optionsWithScope);
+        }
+    }
+    return applyOracle(annotate(base, acceptance, optionsWithScope.quiet), optionsWithScope);
+}
+function classifyResolution(input) {
+    if (input.resolution !== undefined) {
+        return input.resolution;
+    }
+    if (input.code === 2) {
+        return "config";
+    }
+    if (!input.ok) {
+        return "fail";
+    }
+    if (input.runsLength > 0) {
+        return "verified-pass";
+    }
+    if (isEmptyAcResolution(input)) {
+        return "empty-pass";
+    }
+    return "empty-pass";
+}
+function applyEmptyFloorPolicy(result, options) {
+    if (!isEmptyAcResolution({
+        ok: result.ok,
+        code: result.code,
+        runsLength: result.runs.length,
+        commandCount: Math.max(result.commands.length, result.acceptance.commands.length),
+        rejectedCount: result.rejected?.length ?? 0,
+        resolution: result.resolution,
+    })) {
+        return result;
+    }
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const suiteFloor = options.hasSuiteFloor ?? projectHasSuiteFloor(projectRoot);
+    if (suiteFloor) {
+        return {
+            ...result,
+            resolution: "empty-pass",
+            resolvedCommandCount: 0,
+        };
+    }
+    return {
+        ...result,
+        ok: false,
+        code: 1,
+        message: formatSoftEmptyMessage(result.acceptance),
+        resolution: "soft_empty",
+        resolvedCommandCount: 0,
+    };
+}
+function acceptanceOutcomeOf(result) {
+    if (result.resolution === "verified-pass")
+        return "verified-pass";
+    if (result.resolution === "empty-pass")
+        return "empty-pass";
+    if (result.resolution === "soft_empty")
+        return "soft_empty";
+    if (result.resolution === "fail")
+        return "fail";
+    return null;
+}
+function emitAcceptanceOutcome(result, options, projectRoot) {
+    if (options.env === undefined) {
+        return;
+    }
+    const dest = options.env[ENV_RUN_SUMMARY_PATH];
+    if (dest === undefined || dest.trim().length === 0) {
+        return;
+    }
+    const outcome = acceptanceOutcomeOf(result);
+    if (outcome === null) {
+        return;
+    }
+    try {
+        const emitter = new RunSummaryEmitter({
+            projectRoot,
+            sessionId: (typeof options.env.DEFT_SESSION_ID === "string" && options.env.DEFT_SESSION_ID.trim()) ||
+                "verify-ac",
+            env: options.env,
+        });
+        emitter.emitAcceptance({
+            resolved_command_count: result.resolvedCommandCount,
+            outcome,
+            source_rung: result.sourceRung,
+            none_stated: result.noneStated,
+            clause_count: result.clauseOutcomes?.length,
+            clause_outcomes: result.clauseOutcomes?.map((row) => ({
+                id: row.id,
+                outcome: row.outcome,
+            })),
+        });
+    }
+    catch {
+        // fail-open
+    }
+}
+function applyClauseWalk(result, options) {
+    const clauses = result.acceptance.clauses ?? [];
+    if (clauses.length === 0 || result.resolution === "config" || result.resolution === "skipped") {
+        return result;
+    }
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const report = walkAcceptanceClauses(clauses, projectRoot);
+    const message = options.quiet ? result.message : formatClauseWalkMessage(report, result.message);
+    const ok = result.ok && report.ok;
+    return {
+        ...result,
+        ok,
+        code: ok ? result.code : result.code === 2 ? 2 : 1,
+        message,
+        resolution: ok
+            ? result.resolution === "empty-pass"
+                ? "verified-pass"
+                : result.resolution
+            : "fail",
+        clauseOutcomes: report.clauses,
+        clauseWalked: true,
+    };
+}
+function applyOracle(result, options) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const walked = applyClauseWalk(result, options);
+    const gated = walked.clauseWalked === true ? walked : applyEmptyFloorPolicy(walked, options);
+    // Emit/read disk only when the caller supplied env (CLI passes process.env).
+    // Tests stay isolated unless they opt in with env or runSummaryText.
+    if (options.env !== undefined) {
+        emitVerifyAcAttempts({
+            projectRoot,
+            runs: gated.runs,
+            env: options.env,
+            scopeKey: options.oracleScopeKey,
+        });
+    }
+    let next = gated;
+    if (options.applyOracleIntegrity !== false) {
+        const verdict = evaluateProductOracleIntegrity({
+            projectRoot,
+            runSummaryText: options.runSummaryText,
+            env: options.env,
+        });
+        next = mergeOracleVerdict(gated, verdict);
+        if (!verdict.ok && next.resolution !== "soft_empty" && next.resolution !== "config") {
+            next = { ...next, resolution: "fail" };
         }
     }
-    return annotate(base, acceptance, options.quiet);
+    if (options.skipAcceptanceEmit !== true) {
+        emitAcceptanceOutcome(next, options, projectRoot);
+    }
+    return next;
 }
 function annotate(result, acceptance, quiet) {
     const prefix = result.ok
@@ -116,12 +291,21 @@ function annotate(result, acceptance, quiet) {
     else if (result.ok) {
         message = "";
     }
+    const commandCount = Math.max(result.commands.length, acceptance.commands.length);
     return {
         ...result,
         message,
         sourceRung: acceptance.source_rung,
         noneStated: acceptance.none_stated,
         acceptance,
+        resolution: classifyResolution({
+            ok: result.ok,
+            code: result.code,
+            runsLength: result.runs.length,
+            commandCount,
+            rejectedCount: result.rejected?.length ?? 0,
+        }),
+        resolvedCommandCount: result.runs.length > 0 ? result.runs.length : commandCount,
     };
 }
 /**
@@ -131,18 +315,9 @@ export function evaluateVerifyAcFromPath(xbriefPath, options = {}) {
     const abs = resolve(xbriefPath);
     if (!existsSync(abs)) {
         if (options.softMissingXbrief) {
-            return softSkip(`xBRIEF not found: ${abs}`, options.quiet);
+            return applyOracle(softSkip(`xBRIEF not found: ${abs}`, options.quiet), options);
         }
-        return {
-            ok: false,
-            code: 2,
-            message: `verify:ac: xBRIEF not found: ${abs}`,
-            commands: [],
-            runs: [],
-            sourceRung: "project_floor",
-            noneStated: true,
-            acceptance: { commands: [], none_stated: true, source_rung: "project_floor" },
-        };
+        return applyOracle(configResult(`verify:ac: xBRIEF not found: ${abs}`), options);
     }
     let parsed;
     try {
@@ -150,45 +325,45 @@ export function evaluateVerifyAcFromPath(xbriefPath, options = {}) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return {
-            ok: false,
-            code: 2,
-            message: `verify:ac: unreadable xBRIEF (${msg}): ${abs}`,
-            commands: [],
-            runs: [],
-            sourceRung: "project_floor",
-            noneStated: true,
-            acceptance: { commands: [], none_stated: true, source_rung: "project_floor" },
-        };
+        return applyOracle(configResult(`verify:ac: unreadable xBRIEF (${msg}): ${abs}`), options);
     }
     const data = asRecord(parsed);
     if (data === null) {
-        return {
-            ok: false,
-            code: 2,
-            message: `verify:ac: xBRIEF top-level is not an object: ${abs}`,
-            commands: [],
-            runs: [],
-            sourceRung: "project_floor",
-            noneStated: true,
-            acceptance: { commands: [], none_stated: true, source_rung: "project_floor" },
-        };
+        return applyOracle(configResult(`verify:ac: xBRIEF top-level is not an object: ${abs}`), options);
     }
     const plan = asRecord(data.plan);
     if (plan === null) {
-        return {
-            ok: false,
-            code: 2,
-            message: `verify:ac: xBRIEF missing plan object: ${abs}`,
-            commands: [],
-            runs: [],
-            sourceRung: "project_floor",
-            noneStated: true,
-            acceptance: { commands: [], none_stated: true, source_rung: "project_floor" },
-        };
+        return applyOracle(configResult(`verify:ac: xBRIEF missing plan object: ${abs}`), options);
+    }
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    // Path-relative keys stay unique across xbrief/ vs vbrief/ and duplicate plan.id (#3337 Greptile).
+    const oracleScopeKey = options.oracleScopeKey?.trim() || resolveOracleScopeKey(plan, abs, projectRoot);
+    const result = evaluateVerifyAcFromPlan(plan, {
+        ...options,
+        skipAcceptanceEmit: true,
+        oracleScopeKey,
+    });
+    const banked = maybeAttachAcPassBank(result, plan, abs, options);
+    emitAcceptanceOutcome(banked, options, projectRoot);
+    return banked;
+}
+/**
+ * Unique product-oracle scope key for one active xBRIEF path (#3337).
+ * Relative path is always unique across active roots; plan.id alone is not
+ * (duplicate ids / same stem in xbrief+vbrief). Prefer `id@relPath` when both exist.
+ */
+export function resolveOracleScopeKey(plan, xbriefPath, projectRoot) {
+    const abs = resolve(xbriefPath);
+    const root = resolve(projectRoot);
+    let rel = relative(root, abs).replace(/\\/g, "/");
+    if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) {
+        rel = basename(abs);
+    }
+    const planId = typeof plan.id === "string" && plan.id.trim() ? plan.id.trim() : null;
+    if (planId !== null) {
+        return `${planId}@${rel}`;
     }
-    const result = evaluateVerifyAcFromPlan(plan, options);
-    return maybeAttachAcPassBank(result, plan, abs, options);
+    return rel;
 }
 /**
  * After executable AC pass, FINALIZE the banking checkpoint (#3285).
@@ -231,11 +406,26 @@ function maybeAttachAcPassBank(result, plan, xbriefPath, options) {
             ...result,
             ok: false,
             code: 1,
+            resolution: "fail",
             message: `verify:ac bank checkpoint failed (#3285): ${msg}` +
                 (result.message ? `\n${result.message}` : ""),
         };
     }
 }
+function configResult(message) {
+    return {
+        ok: false,
+        code: 2,
+        message,
+        commands: [],
+        runs: [],
+        sourceRung: "project_floor",
+        noneStated: true,
+        acceptance: { commands: [], none_stated: true, source_rung: "project_floor" },
+        resolution: "config",
+        resolvedCommandCount: 0,
+    };
+}
 function softSkip(detail, quiet) {
     return {
         ok: true,
@@ -246,6 +436,8 @@ function softSkip(detail, quiet) {
         sourceRung: "project_floor",
         noneStated: true,
         acceptance: { commands: [], none_stated: true, source_rung: "project_floor" },
+        resolution: "skipped",
+        resolvedCommandCount: 0,
     };
 }
 /** Pure: product AC is required at every ceremony depth (#3284 / #3267 / #3156). */

package/dist/product-first-done-gate/index.d.ts

@@ -6,6 +6,7 @@
  */
 export { attachPlanAcceptance, buildAcceptanceFromIntakeCapture, readPlanAcceptance, stampAcceptanceFromLiteralCapture, validatePlanAcceptance, } from "./acceptance.js";
 export { applyProductFirstGateMode, isHygieneGate, isProductAcGate, type ProductFirstCheckModeResolution, type ResolveProductFirstCheckModeInput, resolveProductFirstCheckMode, } from "./check-mode.js";
-export { type EvaluateVerifyAcOptions, evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, type VerifyAcResult, } from "./evaluate.js";
+export { EMPTY_AC_CAUSE, EMPTY_AC_OUTCOME, EMPTY_AC_REMEDY, formatSoftEmptyMessage, isEmptyAcResolution, isSoftEmptyAcText, projectHasSuiteFloor, type VerifyAcResolution, } from "./empty-resolution.js";
+export { type EvaluateVerifyAcOptions, evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, resolveOracleScopeKey, type VerifyAcResult, } from "./evaluate.js";
 export { type AcceptanceCommand, type AcSourceRung, ENV_CHECK_AC_ONLY, ENV_CHECK_MODE, ENV_HYGIENE_ADVISORY, HYGIENE_GATE_ID_PREFIXES, PLAN_ACCEPTANCE_KEY, type PlanAcceptance, PRODUCT_AC_GATE_ID, type ProductFirstCheckMode, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/product-first-done-gate/index.js

@@ -6,6 +6,7 @@
  */
 export { attachPlanAcceptance, buildAcceptanceFromIntakeCapture, readPlanAcceptance, stampAcceptanceFromLiteralCapture, validatePlanAcceptance, } from "./acceptance.js";
 export { applyProductFirstGateMode, isHygieneGate, isProductAcGate, resolveProductFirstCheckMode, } from "./check-mode.js";
-export { evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, } from "./evaluate.js";
+export { EMPTY_AC_CAUSE, EMPTY_AC_OUTCOME, EMPTY_AC_REMEDY, formatSoftEmptyMessage, isEmptyAcResolution, isSoftEmptyAcText, projectHasSuiteFloor, } from "./empty-resolution.js";
+export { evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, resolveOracleScopeKey, } from "./evaluate.js";
 export { ENV_CHECK_AC_ONLY, ENV_CHECK_MODE, ENV_HYGIENE_ADVISORY, HYGIENE_GATE_ID_PREFIXES, PLAN_ACCEPTANCE_KEY, PRODUCT_AC_GATE_ID, } from "./types.js";
 //# sourceMappingURL=index.js.map

package/dist/product-first-done-gate/types.d.ts

@@ -1,3 +1,4 @@
+import type { AcceptanceClause } from "../verify-ac/clauses.js";
 /**
  * Product-first done-gate (#3284): stated acceptance criteria run FIRST and are
  * never skippable; hygiene gates run second and may degrade under pressure.
@@ -31,6 +32,8 @@ export interface PlanAcceptance {
     readonly source_rung: AcSourceRung;
     /** Why derived/floor was chosen (required for derived when recorded). */
     readonly derived_reason?: string | null;
+    /** Rung-2 independently testable clauses (#3323). Parallel to commands[]. */
+    readonly clauses?: readonly AcceptanceClause[];
 }
 /** How `task check` composes product vs hygiene gates under pressure (#3284). */
 export type ProductFirstCheckMode = 

package/dist/product-first-done-gate/types.js

@@ -1,10 +1,3 @@
-/**
- * Product-first done-gate (#3284): stated acceptance criteria run FIRST and are
- * never skippable; hygiene gates run second and may degrade under pressure.
- *
- * Architecture for #3267 (literal acceptance-command mechanism). Composes
- * #3214 ceremony dial (rapid = AC-only) and #3266 bank-the-pass.
- */
 /** Canonical product AC gate id used in check gate lists. */
 export const PRODUCT_AC_GATE_ID = "verify:ac";
 /** plan.acceptance object key on the plan root. */

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

@@ -6,7 +6,7 @@
  * Symlink destinations are refused (no-follow / containment) — fail-open.
  */
 import { type ResolveRunSummaryDestinationOptions } from "./path.js";
-import { type CheckInvocationRunSummaryPayload, type DialTransitionRunSummaryPayload, type RunSummaryDestination, type RunSummaryEventKind, type RunSummaryLine, type RunSummaryPayload, type SessionStartRunSummaryPayload } from "./types.js";
+import { type AcceptanceRunSummaryPayload, type AcceptanceStampRunSummaryPayload, type CheckInvocationRunSummaryPayload, type DialEscalationEvaluationRunSummaryPayload, type DialTransitionRunSummaryPayload, type RunSummaryDestination, type RunSummaryEventKind, type RunSummaryLine, type RunSummaryPayload, type SessionStartRunSummaryPayload, type ToolTurnDenominatorRunSummaryPayload, type VerificationRunSummaryPayload } from "./types.js";
 export interface RunSummaryEmitterOptions extends ResolveRunSummaryDestinationOptions {
     readonly projectRoot: string;
     readonly sessionId: string;
@@ -36,6 +36,7 @@ export declare class RunSummaryEmitter {
     private readonly frameworkVersion;
     private readonly now;
     private readonly destination;
+    private readonly env;
     private readonly writeStdout;
     private readonly writeStderr;
     constructor(options: RunSummaryEmitterOptions);
@@ -43,8 +44,17 @@ export declare class RunSummaryEmitter {
     emit(event: RunSummaryEventKind, payload: RunSummaryPayload): EmitRunSummaryResult;
     emitSessionStart(payload: SessionStartRunSummaryPayload): EmitRunSummaryResult;
     emitDialTransition(payload: DialTransitionRunSummaryPayload): EmitRunSummaryResult;
+    emitDialEscalationEvaluation(payload: DialEscalationEvaluationRunSummaryPayload): EmitRunSummaryResult;
     emitCheckInvocation(payload: CheckInvocationRunSummaryPayload): EmitRunSummaryResult;
+    emitToolTurnDenominator(payload: ToolTurnDenominatorRunSummaryPayload): EmitRunSummaryResult;
+    emitVerification(payload: VerificationRunSummaryPayload): EmitRunSummaryResult;
+    emitAcceptance(payload: AcceptanceRunSummaryPayload): EmitRunSummaryResult;
+    emitAcceptanceStamp(payload: AcceptanceStampRunSummaryPayload): EmitRunSummaryResult;
+    /** Emit the harness-supplied denominator when DEFT_TOTAL_TOOL_TURNS is set. */
+    emitKnownToolTurnDenominator(): EmitRunSummaryResult;
 }
+/** Parse harness-supplied DEFT_TOTAL_TOOL_TURNS (integer > 0). Invalid/unset → omit. */
+export declare function readEnvToolTurnDenominator(env: NodeJS.ProcessEnv): number | 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.

package/dist/run-summary/emit.js

@@ -11,7 +11,7 @@ import { readCorePackageVersion } from "../engine-version.js";
 import { containedWrite } from "../fs/contained-write.js";
 import { assertWriteTargetSafe } from "../fs/projection-containment.js";
 import { resolveRunSummaryDestination } from "./path.js";
-import { RUN_SUMMARY_SCHEMA_VERSION, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.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)) {
         return value.map(sortKeysDeep);
@@ -90,6 +90,7 @@ export class RunSummaryEmitter {
     frameworkVersion;
     now;
     destination;
+    env;
     writeStdout;
     writeStderr;
     constructor(options) {
@@ -97,10 +98,11 @@ export class RunSummaryEmitter {
         this.sessionId = options.sessionId;
         this.frameworkVersion = options.frameworkVersion ?? readCorePackageVersion();
         this.now = options.now ?? (() => new Date());
+        this.env = options.env ?? process.env;
         this.destination =
             options.destination ??
                 resolveRunSummaryDestination(options.projectRoot, {
-                    env: options.env,
+                    env: this.env,
                     gitignoreCovers: options.gitignoreCovers,
                 });
         this.writeStdout = options.writeStdout ?? ((line) => process.stdout.write(`${line}\n`));
@@ -115,6 +117,7 @@ export class RunSummaryEmitter {
                 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,
@@ -123,6 +126,7 @@ export class RunSummaryEmitter {
                 ts: this.now().toISOString(),
                 event,
                 payload,
+                ...(denominator !== undefined ? { total_tool_turns: denominator } : {}),
             };
             const text = lineToJson(line);
             if (this.destination.kind === "stdout") {
@@ -156,9 +160,51 @@ export class RunSummaryEmitter {
     emitDialTransition(payload) {
         return this.emit("dial_transition", payload);
     }
+    emitDialEscalationEvaluation(payload) {
+        return this.emit("dial_escalation_evaluation", payload);
+    }
     emitCheckInvocation(payload) {
         return this.emit("check_invocation", payload);
     }
+    emitToolTurnDenominator(payload) {
+        return this.emit("tool_turn_denominator", payload);
+    }
+    emitVerification(payload) {
+        return this.emit("verification", payload);
+    }
+    emitAcceptance(payload) {
+        return this.emit("acceptance", payload);
+    }
+    emitAcceptanceStamp(payload) {
+        return this.emit("acceptance_stamp", payload);
+    }
+    /** Emit the harness-supplied denominator when DEFT_TOTAL_TOOL_TURNS is set. */
+    emitKnownToolTurnDenominator() {
+        const n = readEnvToolTurnDenominator(this.env);
+        if (n === undefined) {
+            return { emitted: false, destination: this.destination, line: null, warning: false };
+        }
+        return this.emitToolTurnDenominator({ total_tool_turns: n });
+    }
+}
+function readPayloadToolTurnDenominator(payload) {
+    if (!("total_tool_turns" in payload)) {
+        return undefined;
+    }
+    const value = payload.total_tool_turns;
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Parse harness-supplied DEFT_TOTAL_TOOL_TURNS (integer > 0). Invalid/unset → omit. */
+export function readEnvToolTurnDenominator(env) {
+    const raw = env[ENV_TOTAL_TOOL_TURNS];
+    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 n;
 }
 /**
  * One-shot helper for call sites that do not hold an emitter (e.g. dial escalate).

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

@@ -1,4 +1,5 @@
 export { type EmitRunSummaryResult, emitRunSummaryEvent, RunSummaryEmitter, type RunSummaryEmitterOptions, } from "./emit.js";
 export { gitignoreCoversRunSummary, type ResolveRunSummaryDestinationOptions, resolveRunSummaryDestination, } from "./path.js";
-export { type CheckGateOutcome, type CheckInvocationRunSummaryPayload, DEFAULT_RUN_SUMMARY_BASENAME, type DialTransitionRunSummaryPayload, ENV_RUN_SUMMARY_PATH, 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, } from "./types.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";
 //# sourceMappingURL=index.d.ts.map

package/dist/run-summary/index.js

@@ -1,4 +1,5 @@
 export { emitRunSummaryEvent, RunSummaryEmitter, } from "./emit.js";
 export { gitignoreCoversRunSummary, resolveRunSummaryDestination, } from "./path.js";
-export { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, RUN_SUMMARY_EVENT_KINDS, RUN_SUMMARY_SCHEMA_VERSION, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.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/path.d.ts

@@ -6,7 +6,7 @@
  * - unset → repo-root `.deft-run-summary.json` only when .gitignore covers it; else silent
  */
 import { type RunSummaryDestination } from "./types.js";
-export { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";
+export { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, ENV_TOTAL_TOOL_TURNS, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";
 /**
  * True when a .gitignore line covers the default run-summary basename.
  * Matches exact line or trailing slash variants; ignores comments.

package/dist/run-summary/path.js

@@ -8,7 +8,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, } from "./types.js";
-export { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";
+export { DEFAULT_RUN_SUMMARY_BASENAME, ENV_RUN_SUMMARY_PATH, ENV_TOTAL_TOOL_TURNS, RUN_SUMMARY_STDOUT_PREFIX, RUN_SUMMARY_WRITE_WARNING, } from "./types.js";
 /**
  * True when a .gitignore line covers the default run-summary basename.
  * Matches exact line or trailing slash variants; ignores comments.