@deftai/directive-core 0.101.0 → 0.102.0

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

@@ -5,6 +5,7 @@
  * Interoperates with #3267 plan.metadata.literal_acceptance_commands.
  */
 import { attachLiteralAcceptanceCommands, readStoredLiteralAcceptanceCommands, } from "../literal-acceptance/index.js";
+import { readAcceptanceClauses, serializeAcceptanceClauses } from "../verify-ac/clauses.js";
 import { PLAN_ACCEPTANCE_KEY, } from "./types.js";
 function asRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -73,6 +74,22 @@ export function validatePlanAcceptance(value) {
     if ("source_rung" in rec && rec.source_rung !== undefined && !isAcSourceRung(rec.source_rung)) {
         errors.push('plan.acceptance.source_rung must be "stated" | "derived" | "project_floor"');
     }
+    if ("clauses" in rec && rec.clauses !== undefined && !Array.isArray(rec.clauses)) {
+        errors.push("plan.acceptance.clauses must be an array");
+    }
+    if (Array.isArray(rec.clauses)) {
+        rec.clauses.forEach((entry, index) => {
+            const row = asRecord(entry);
+            if (row === null) {
+                errors.push(`plan.acceptance.clauses[${index}] must be an object`);
+                return;
+            }
+            const text = isNonEmptyString(row.text) ? row.text.trim() : "";
+            if (text.length === 0) {
+                errors.push(`plan.acceptance.clauses[${index}].text must be a non-empty string`);
+            }
+        });
+    }
     const commands = coerceCommands(rec.commands);
     const noneStated = rec.none_stated === true;
     if (commands.length === 0 && !noneStated) {
@@ -110,6 +127,7 @@ export function readPlanAcceptance(plan) {
             if (noneStated && commands.length === 0) {
                 sourceRung = isAcSourceRung(rec.source_rung) ? rec.source_rung : "project_floor";
             }
+            const clauses = readAcceptanceClauses(rec);
             return {
                 commands,
                 none_stated: noneStated,
@@ -119,6 +137,7 @@ export function readPlanAcceptance(plan) {
                     : isNonEmptyString(rec.derivedReason)
                         ? rec.derivedReason
                         : null,
+                ...(clauses.length > 0 ? { clauses } : {}),
             };
         }
     }
@@ -181,6 +200,9 @@ export function attachPlanAcceptance(plan, acceptance) {
     if (acceptance.derived_reason) {
         serializable.derived_reason = acceptance.derived_reason;
     }
+    if (acceptance.clauses !== undefined && acceptance.clauses.length > 0) {
+        serializable.clauses = serializeAcceptanceClauses(acceptance.clauses);
+    }
     let next = {
         ...plan,
         [PLAN_ACCEPTANCE_KEY]: serializable,

package/dist/product-first-done-gate/empty-resolution.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Empty verify:ac resolution is not a green run when there is no suite floor (#3334).
+ *
+ * Framework source keeps today's floor-pass (suite gates own the floor).
+ * Consumer / no-suite projects fail closed with a distinct soft_empty outcome.
+ */
+import type { PlanAcceptance } from "./types.js";
+export declare const EMPTY_AC_OUTCOME: "soft_empty";
+export declare const EMPTY_AC_CAUSE = "no acceptance stamped \u2014 floor is empty in this project";
+export declare const EMPTY_AC_REMEDY = "stamp plan.acceptance (author commands or run intake capture / task issue:ingest)";
+export type VerifyAcResolution = "verified-pass" | "empty-pass" | "soft_empty" | "fail" | "config" | "skipped";
+/** True when this project check composition includes a suite gate (#3188). */
+export declare function projectHasSuiteFloor(projectRoot: string): boolean;
+export declare function isSoftEmptyAcText(text: string): boolean;
+export interface EmptyAcResolutionInput {
+    readonly ok: boolean;
+    readonly code: number;
+    readonly runsLength: number;
+    readonly commandCount: number;
+    readonly rejectedCount: number;
+    readonly resolution?: VerifyAcResolution;
+}
+/** Zero executable commands, no rejected/unpromoted ledger, not already classified. */
+export declare function isEmptyAcResolution(input: EmptyAcResolutionInput): boolean;
+export declare function formatSoftEmptyMessage(acceptance: PlanAcceptance, quiet?: boolean): string;
+//# sourceMappingURL=empty-resolution.d.ts.map

package/dist/product-first-done-gate/empty-resolution.js

@@ -0,0 +1,38 @@
+/**
+ * Empty verify:ac resolution is not a green run when there is no suite floor (#3334).
+ *
+ * Framework source keeps today's floor-pass (suite gates own the floor).
+ * Consumer / no-suite projects fail closed with a distinct soft_empty outcome.
+ */
+import { isFrameworkRepoRoot } from "../check/context.js";
+export const EMPTY_AC_OUTCOME = "soft_empty";
+export const EMPTY_AC_CAUSE = "no acceptance stamped — floor is empty in this project";
+export const EMPTY_AC_REMEDY = "stamp plan.acceptance (author commands or run intake capture / task issue:ingest)";
+/** True when this project check composition includes a suite gate (#3188). */
+export function projectHasSuiteFloor(projectRoot) {
+    return isFrameworkRepoRoot(projectRoot);
+}
+export function isSoftEmptyAcText(text) {
+    return /soft_empty\s*\(#3334\)/i.test(text);
+}
+/** Zero executable commands, no rejected/unpromoted ledger, not already classified. */
+export function isEmptyAcResolution(input) {
+    if (input.resolution === "config" || input.resolution === "skipped") {
+        return false;
+    }
+    if (input.code === 2) {
+        return false;
+    }
+    if (input.rejectedCount > 0 || input.commandCount > 0 || input.runsLength > 0) {
+        return false;
+    }
+    return true;
+}
+export function formatSoftEmptyMessage(acceptance, quiet) {
+    if (quiet) {
+        return "";
+    }
+    return (`verify:ac ${EMPTY_AC_OUTCOME} (#3334) [rung=${acceptance.source_rung}]: ` +
+        `${EMPTY_AC_CAUSE}. ${EMPTY_AC_REMEDY}.`);
+}
+//# sourceMappingURL=empty-resolution.js.map

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

@@ -3,15 +3,22 @@
  *
  * 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 { type EvaluateLiteralAcceptanceOptions, type LiteralAcceptanceGateResult } from "../literal-acceptance/index.js";
+import { type ClauseWalkResult } from "../verify-ac/clauses.js";
+import { type VerifyAcResolution } from "./empty-resolution.js";
 import type { AcSourceRung, PlanAcceptance } from "./types.js";
 export interface VerifyAcResult extends LiteralAcceptanceGateResult {
     readonly sourceRung: AcSourceRung;
     readonly noneStated: boolean;
     readonly acceptance: PlanAcceptance;
+    readonly resolution: VerifyAcResolution;
+    readonly resolvedCommandCount: number;
+    readonly clauseOutcomes?: readonly ClauseWalkResult[];
+    readonly clauseWalked?: boolean;
 }
 export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOptions {
     /**
@@ -36,6 +43,25 @@ export interface EvaluateVerifyAcOptions extends EvaluateLiteralAcceptanceOption
     readonly bankOnPass?: boolean;
     /** Optional scope id override for the bank ledger (default plan.id / path). */
     readonly bankScopeId?: string | null;
+    /**
+     * Injected run-summary JSONL for product-oracle integrity (#3322).
+     * Undefined → read DEFT_RUN_SUMMARY_PATH / default dest; null → skip disk.
+     */
+    readonly runSummaryText?: string | null;
+    /** When false, skip #3322 oracle integrity. Default true. */
+    readonly applyOracleIntegrity?: boolean;
+    /** Env seam for run-summary dest resolution (#3322 / #3334). */
+    readonly env?: NodeJS.ProcessEnv;
+    /**
+     * Inject suite-floor detection (tests). Default: framework source has a
+     * suite floor; consumer projects do not (#3334).
+     */
+    readonly hasSuiteFloor?: boolean;
+    /**
+     * When true, skip the acceptance run-summary emit so the path helper can
+     * emit after the #3285 bank checkpoint.
+     */
+    readonly skipAcceptanceEmit?: boolean;
 }
 /**
  * Evaluate product AC from an in-memory plan.

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 { 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;
@@ -25,7 +30,7 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
     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,7 +39,9 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             sourceRung: acceptance.source_rung,
             noneStated: acceptance.none_stated,
             acceptance,
-        };
+            resolution: "config",
+            resolvedCommandCount: 0,
+        }, options);
     }
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
     // Prefer shared literal-acceptance path so safety / promotion rules stay one place.
@@ -45,7 +52,10 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
     const base = evaluateLiteralAcceptanceFromPlan(plan, {
         projectRoot,
         runner: options.runner,
-        captureFromNarratives: options.captureFromNarratives,
+        // 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: options.captureFromNarratives ?? (options.checkIntegrated === true ? false : undefined),
         quiet: options.quiet,
     });
     // When literal path had nothing executable but plan.acceptance has derived commands,
@@ -63,7 +73,7 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
             source: "explicit",
             sourceSpan: "plan.acceptance.commands",
         })), { projectRoot, runner, allowTaskStatement: options.allowTaskStatement });
-        return annotate(direct, acceptance, options.quiet);
+        return applyOracle(annotate(direct, acceptance, options.quiet), options);
     }
     // Check composition: mid-story unpromoted capture-only may soft-pass so the
     // framework graph is not deadlocked before agents promote peers.
@@ -72,12 +82,12 @@ export function evaluateVerifyAcFromPlan(plan, options = {}) {
     if (options.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, options.quiet), options);
         }
         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
@@ -92,10 +102,164 @@ 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,
+            }, options);
+        }
+    }
+    return applyOracle(annotate(base, acceptance, options.quiet), options);
+}
+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,
+        });
+    }
+    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 +280,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 +304,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 +314,20 @@ 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 result = evaluateVerifyAcFromPlan(plan, options);
-    return maybeAttachAcPassBank(result, plan, abs, options);
+    const result = evaluateVerifyAcFromPlan(plan, { ...options, skipAcceptanceEmit: true });
+    const banked = maybeAttachAcPassBank(result, plan, abs, options);
+    emitAcceptanceOutcome(banked, options, resolve(options.projectRoot ?? process.cwd()));
+    return banked;
 }
 /**
  * After executable AC pass, FINALIZE the banking checkpoint (#3285).
@@ -231,11 +370,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 +400,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 { 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, 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 { EMPTY_AC_CAUSE, EMPTY_AC_OUTCOME, EMPTY_AC_REMEDY, formatSoftEmptyMessage, isEmptyAcResolution, isSoftEmptyAcText, projectHasSuiteFloor, } from "./empty-resolution.js";
 export { evaluateVerifyAcFromPath, evaluateVerifyAcFromPlan, isVerifyAcRequiredAtCeremonyDepth, } 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.