@deftai/directive-core 0.100.0 → 0.102.0

package/dist/policy/index.js

@@ -1,5 +1,6 @@
 import { FIELD_HOST_SKILL_DISCOVERY, FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS, inspectHostSkillDiscovery, } from "../init-deposit/skill-discovery-hosts.js";
 import { FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, } from "../slash/openclaw-deposit.js";
+import { FIELD_AC_PASS_BANKING, FIELD_AC_PASS_BANKING_CLI_ALIAS, inspectAcPassBanking, } from "./ac-pass-banking.js";
 import { FIELD_CEREMONY_DIAL, FIELD_CEREMONY_DIAL_CLI_ALIAS, inspectCeremonyDial, } from "./ceremony-dial.js";
 import { FIELD_CHECK_RESUME, FIELD_CHECK_RESUME_CLI_ALIAS, inspectCheckResume, } from "./check-resume.js";
 import { FIELD_COVERAGE_DEBT, FIELD_COVERAGE_DEBT_CLI_ALIAS, inspectCoverageDebt, } from "./coverage-debt.js";
@@ -16,12 +17,13 @@ import { FIELD_RUNTIME_AUTHORITY, FIELD_RUNTIME_AUTHORITY_CLI_ALIAS, inspectRunt
 import { FIELD_STALENESS_TICKLER, FIELD_STALENESS_TICKLER_CLI_ALIAS, inspectStalenessTickler, } from "./staleness-tickler.js";
 import { FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, inspectValueFeedback, } from "./value-feedback.js";
 import { DEFAULT_WIP_CAP } from "./wip.js";
+export * from "./ac-pass-banking.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./ceremony-dial.js";
+export * from "./ceremony-dial-escalation.js";
 export * from "./check-resume.js";
-export * from "./coverage-check-resume-presets.js";
 export * from "./coverage-debt.js";
 export * from "./decisions.js";
 export * from "./deft-directive-disable.js";
@@ -420,6 +422,15 @@ function inspectCeremonyDialField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectAcPassBankingField(data, projectRoot) {
+    const field = inspectAcPassBanking(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -448,6 +459,7 @@ const REGISTERED_POLICIES = [
     inspectRequireHumanMergeField,
     inspectHotfixCriteriaField,
     inspectCeremonyDialField,
+    inspectAcPassBankingField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
 export function inspectAllPolicies(projectRoot) {
@@ -486,7 +498,9 @@ export function inspectOnePolicy(name, projectRoot) {
                                                             ? FIELD_MIN_GREPTILE_CONFIDENCE
                                                             : name === FIELD_CEREMONY_DIAL_CLI_ALIAS
                                                                 ? FIELD_CEREMONY_DIAL
-                                                                : name;
+                                                                : name === FIELD_AC_PASS_BANKING_CLI_ALIAS
+                                                                    ? FIELD_AC_PASS_BANKING
+                                                                    : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/preflight-cache/evaluate.d.ts

@@ -44,6 +44,9 @@ export declare function normaliseRepoUrl(url: string): string | null;
  * Evaluate cache freshness for the given project root.
  *
  * Faithful port of scripts/preflight_cache.py::evaluate().
+ * #3286 note: deposit-sha orientation no-ops live in session orientation
+ * composition (age-gated), not here — triage cache freshness is age/drift based
+ * and must not short-circuit solely on payload/templates/engine fingerprints.
  */
 export declare function evaluate(projectRoot: string, options?: EvaluateOptions): GateResult;
 //# sourceMappingURL=evaluate.d.ts.map

package/dist/preflight-cache/evaluate.js

@@ -317,6 +317,9 @@ const REMEDIATION_NO_CANDIDATES = [
  * Evaluate cache freshness for the given project root.
  *
  * Faithful port of scripts/preflight_cache.py::evaluate().
+ * #3286 note: deposit-sha orientation no-ops live in session orientation
+ * composition (age-gated), not here — triage cache freshness is age/drift based
+ * and must not short-circuit solely on payload/templates/engine fingerprints.
  */
 export function evaluate(projectRoot, options = {}) {
     return evaluateWithContext(projectRoot, options, { afterEmptyPopulate: false });

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

@@ -0,0 +1,25 @@
+/**
+ * plan.acceptance schema helpers (#3284).
+ *
+ * Captures stated acceptance.commands at intake; empty requires none_stated:true.
+ * Interoperates with #3267 plan.metadata.literal_acceptance_commands.
+ */
+import { type AcceptanceCommand, type PlanAcceptance } from "./types.js";
+/** Validation errors for a plan.acceptance object (empty list = valid). */
+export declare function validatePlanAcceptance(value: unknown): string[];
+/**
+ * Read plan.acceptance when present; otherwise synthesize from #3267
+ * literal_acceptance_commands / empty+none_stated.
+ */
+export declare function readPlanAcceptance(plan: Record<string, unknown> | null | undefined): PlanAcceptance;
+/** Attach a validated PlanAcceptance onto plan.acceptance + mirror to #3267 metadata. */
+export declare function attachPlanAcceptance(plan: Record<string, unknown>, acceptance: PlanAcceptance): Record<string, unknown>;
+/**
+ * Build plan.acceptance from intake capture (#3284).
+ * Stated commands → none_stated:false, source_rung:stated.
+ * No stated commands → none_stated:true, source_rung:project_floor (until agent derives).
+ */
+export declare function buildAcceptanceFromIntakeCapture(capturedCommands: readonly AcceptanceCommand[]): PlanAcceptance;
+/** Stamp plan.acceptance from existing literal capture after issue ingest. */
+export declare function stampAcceptanceFromLiteralCapture(plan: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=acceptance.d.ts.map

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

@@ -0,0 +1,269 @@
+/**
+ * plan.acceptance schema helpers (#3284).
+ *
+ * Captures stated acceptance.commands at intake; empty requires none_stated:true.
+ * 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)) {
+        return value;
+    }
+    return null;
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function coerceCommands(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (typeof entry === "string") {
+            const command = entry.trim();
+            if (command.length > 0)
+                out.push({ command });
+            continue;
+        }
+        const rec = asRecord(entry);
+        if (rec === null)
+            continue;
+        const command = rec.command ?? rec.cmd ?? rec.shell;
+        if (!isNonEmptyString(command))
+            continue;
+        out.push({
+            command: command.trim(),
+            cwd: isNonEmptyString(rec.cwd) ? rec.cwd.trim() : null,
+            expectedStdout: isNonEmptyString(rec.expectedStdout)
+                ? rec.expectedStdout
+                : isNonEmptyString(rec.expected_stdout)
+                    ? rec.expected_stdout
+                    : null,
+            expectedExitCode: typeof rec.expectedExitCode === "number"
+                ? rec.expectedExitCode
+                : typeof rec.expected_exit_code === "number"
+                    ? rec.expected_exit_code
+                    : 0,
+        });
+    }
+    return out;
+}
+function isAcSourceRung(value) {
+    return value === "stated" || value === "derived" || value === "project_floor";
+}
+/** Validation errors for a plan.acceptance object (empty list = valid). */
+export function validatePlanAcceptance(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    const rec = asRecord(value);
+    if (rec === null) {
+        return ["plan.acceptance must be an object"];
+    }
+    const errors = [];
+    if ("commands" in rec && rec.commands !== undefined && !Array.isArray(rec.commands)) {
+        errors.push("plan.acceptance.commands must be an array");
+    }
+    if ("none_stated" in rec &&
+        rec.none_stated !== undefined &&
+        typeof rec.none_stated !== "boolean") {
+        errors.push("plan.acceptance.none_stated must be a boolean");
+    }
+    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) {
+        errors.push("plan.acceptance.commands is empty but none_stated is not true — " +
+            "empty acceptance is only allowed with an explicit none_stated: true marker (#3284)");
+    }
+    if (commands.length > 0 && noneStated && rec.source_rung === "stated") {
+        errors.push("plan.acceptance: none_stated:true with source_rung:stated is contradictory " +
+            "(use source_rung:derived when commands are agent-authored under none_stated)");
+    }
+    return errors;
+}
+/**
+ * Read plan.acceptance when present; otherwise synthesize from #3267
+ * literal_acceptance_commands / empty+none_stated.
+ */
+export function readPlanAcceptance(plan) {
+    if (plan === null || plan === undefined) {
+        return { commands: [], none_stated: true, source_rung: "project_floor" };
+    }
+    const raw = plan[PLAN_ACCEPTANCE_KEY];
+    if (raw !== null && raw !== undefined) {
+        const rec = asRecord(raw);
+        if (rec !== null) {
+            const commands = coerceCommands(rec.commands);
+            const noneStated = rec.none_stated === true || (commands.length === 0 && rec.none_stated !== false);
+            let sourceRung = isAcSourceRung(rec.source_rung)
+                ? rec.source_rung
+                : commands.length > 0
+                    ? "stated"
+                    : "project_floor";
+            if (noneStated && commands.length > 0 && sourceRung === "stated") {
+                sourceRung = "derived";
+            }
+            if (noneStated && commands.length === 0) {
+                sourceRung = isAcSourceRung(rec.source_rung) ? rec.source_rung : "project_floor";
+            }
+            const clauses = readAcceptanceClauses(rec);
+            return {
+                commands,
+                none_stated: noneStated,
+                source_rung: sourceRung,
+                derived_reason: isNonEmptyString(rec.derived_reason)
+                    ? rec.derived_reason
+                    : isNonEmptyString(rec.derivedReason)
+                        ? rec.derivedReason
+                        : null,
+                ...(clauses.length > 0 ? { clauses } : {}),
+            };
+        }
+    }
+    // Fallback: #3267 metadata ledger.
+    const literal = readStoredLiteralAcceptanceCommands(plan);
+    if (literal.length > 0) {
+        return {
+            commands: literal.map(literalToAcceptance),
+            none_stated: false,
+            source_rung: "stated",
+            derived_reason: null,
+        };
+    }
+    return {
+        commands: [],
+        none_stated: true,
+        source_rung: "project_floor",
+        derived_reason: "no plan.acceptance and no literal_acceptance_commands (#3284 floor)",
+    };
+}
+function literalToAcceptance(cmd) {
+    return {
+        command: cmd.command,
+        cwd: cmd.cwd ?? null,
+        expectedStdout: cmd.expectedStdout ?? null,
+        expectedExitCode: cmd.expectedExitCode ?? 0,
+    };
+}
+function acceptanceToLiteral(cmd, source) {
+    return {
+        command: cmd.command,
+        cwd: cmd.cwd ?? null,
+        expectedStdout: cmd.expectedStdout ?? null,
+        expectedExitCode: cmd.expectedExitCode ?? 0,
+        source,
+        sourceSpan: "plan.acceptance.commands",
+    };
+}
+/** Attach a validated PlanAcceptance onto plan.acceptance + mirror to #3267 metadata. */
+export function attachPlanAcceptance(plan, acceptance) {
+    const errors = validatePlanAcceptance(acceptance);
+    if (errors.length > 0) {
+        throw new Error(`attachPlanAcceptance: ${errors.join("; ")}`);
+    }
+    const serializable = {
+        commands: acceptance.commands.map((c) => {
+            const row = { command: c.command };
+            if (c.cwd)
+                row.cwd = c.cwd;
+            if (c.expectedStdout)
+                row.expectedStdout = c.expectedStdout;
+            if (typeof c.expectedExitCode === "number" && c.expectedExitCode !== 0) {
+                row.expectedExitCode = c.expectedExitCode;
+            }
+            return row;
+        }),
+        none_stated: acceptance.none_stated,
+        source_rung: acceptance.source_rung,
+    };
+    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,
+    };
+    // Mirror executable commands into #3267 ledger for verify:literal-ac interoperability.
+    if (acceptance.commands.length > 0) {
+        const source = acceptance.source_rung === "stated" ? "task_statement" : "explicit";
+        // derived / floor commands are agent-authored → executable source=explicit
+        const literalSource = acceptance.source_rung === "stated" ? "task_statement" : "explicit";
+        void source;
+        next = attachLiteralAcceptanceCommands(next, acceptance.commands.map((c) => acceptanceToLiteral(c, literalSource)));
+    }
+    return next;
+}
+/**
+ * Build plan.acceptance from intake capture (#3284).
+ * Stated commands → none_stated:false, source_rung:stated.
+ * No stated commands → none_stated:true, source_rung:project_floor (until agent derives).
+ */
+export function buildAcceptanceFromIntakeCapture(capturedCommands) {
+    if (capturedCommands.length === 0) {
+        return {
+            commands: [],
+            none_stated: true,
+            source_rung: "project_floor",
+            derived_reason: "no shell acceptance commands stated in task text; floor until agent derives AC (#3284 ladder)",
+        };
+    }
+    return {
+        commands: capturedCommands,
+        none_stated: false,
+        source_rung: "stated",
+        derived_reason: null,
+    };
+}
+/** Stamp plan.acceptance from existing literal capture after issue ingest. */
+export function stampAcceptanceFromLiteralCapture(plan) {
+    const literal = readStoredLiteralAcceptanceCommands(plan);
+    const acceptance = buildAcceptanceFromIntakeCapture(literal.map(literalToAcceptance));
+    // Avoid re-mirroring task_statement into verify_commands (ingest strips those).
+    const serializable = {
+        commands: acceptance.commands.map((c) => {
+            const row = { command: c.command };
+            if (c.cwd)
+                row.cwd = c.cwd;
+            if (c.expectedStdout)
+                row.expectedStdout = c.expectedStdout;
+            if (typeof c.expectedExitCode === "number" && c.expectedExitCode !== 0) {
+                row.expectedExitCode = c.expectedExitCode;
+            }
+            return row;
+        }),
+        none_stated: acceptance.none_stated,
+        source_rung: acceptance.source_rung,
+    };
+    if (acceptance.derived_reason) {
+        serializable.derived_reason = acceptance.derived_reason;
+    }
+    return {
+        ...plan,
+        [PLAN_ACCEPTANCE_KEY]: serializable,
+    };
+}
+//# sourceMappingURL=acceptance.js.map

package/dist/product-first-done-gate/check-mode.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Resolve product-first check composition mode (#3284).
+ *
+ * Priority (highest wins):
+ *  1. DEFT_CHECK_AC_ONLY / DEFT_CHECK_MODE=rapid → rapid (AC-only)
+ *  2. DEFT_CHECK_MODE=pressure|degraded or DEFT_HYGIENE_ADVISORY → pressure
+ *  3. ceremony dial depth rapid|minimal → rapid
+ *  4. hard effort budget (#3266) → pressure
+ *  5. default full
+ */
+import { type CeremonyDepth } from "../policy/ceremony-dial.js";
+import { type ProductFirstCheckMode } from "./types.js";
+export interface ResolveProductFirstCheckModeInput {
+    readonly environ?: Readonly<Record<string, string | undefined>>;
+    readonly projectRoot?: string;
+    /** Inject ceremony depth (tests); when unset, reads ritual-state audit. */
+    readonly ceremonyDepth?: CeremonyDepth | null;
+    /** Inject hard-budget detected flag (tests). */
+    readonly hardBudgetDetected?: boolean;
+}
+export interface ProductFirstCheckModeResolution {
+    readonly mode: ProductFirstCheckMode;
+    readonly sources: readonly string[];
+    readonly hygieneAdvisory: boolean;
+    readonly acOnly: boolean;
+    /** AC remains mandatory whenever mode is not a pure no-op. */
+    readonly acMandatory: true;
+}
+/**
+ * Resolve the active product-first check mode from env + ceremony + budget.
+ */
+export declare function resolveProductFirstCheckMode(input?: ResolveProductFirstCheckModeInput): ProductFirstCheckModeResolution;
+/** True when this gate id is the product AC gate. */
+export declare function isProductAcGate(gateId: string): boolean;
+/** True when this gate is classified as hygiene (may be advisory under pressure). */
+export declare function isHygieneGate(gateId: string): boolean;
+/**
+ * Filter / annotate gate list for the resolved mode.
+ * - rapid: only product AC gates
+ * - pressure/full: full list (pressure marks hygiene advisory at run time)
+ */
+export declare function applyProductFirstGateMode<T extends string | {
+    readonly task: string;
+}>(gates: readonly T[], mode: ProductFirstCheckMode, gateIdOf?: (g: T) => string): readonly T[];
+//# sourceMappingURL=check-mode.d.ts.map

package/dist/product-first-done-gate/check-mode.js

@@ -0,0 +1,148 @@
+/**
+ * Resolve product-first check composition mode (#3284).
+ *
+ * Priority (highest wins):
+ *  1. DEFT_CHECK_AC_ONLY / DEFT_CHECK_MODE=rapid → rapid (AC-only)
+ *  2. DEFT_CHECK_MODE=pressure|degraded or DEFT_HYGIENE_ADVISORY → pressure
+ *  3. ceremony dial depth rapid|minimal → rapid
+ *  4. hard effort budget (#3266) → pressure
+ *  5. default full
+ */
+import { CEREMONY_DEPTHS, readCeremonyDialAudit, } from "../policy/ceremony-dial.js";
+import { detectHardEffortBudget } from "../session/effort-budget.js";
+import { ENV_CHECK_AC_ONLY, ENV_CHECK_MODE, ENV_HYGIENE_ADVISORY, HYGIENE_GATE_ID_PREFIXES, PRODUCT_AC_GATE_ID, } from "./types.js";
+function asCeremonyDepth(value) {
+    return typeof value === "string" && CEREMONY_DEPTHS.includes(value)
+        ? value
+        : null;
+}
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+function isTruthy(raw) {
+    if (raw === undefined)
+        return false;
+    return TRUTHY.has(raw.trim().toLowerCase());
+}
+function normalizeModeToken(raw) {
+    const t = raw.trim().toLowerCase();
+    if (t === "full" || t === "standard")
+        return "full";
+    if (t === "pressure" || t === "degraded" || t === "advisory")
+        return "pressure";
+    if (t === "rapid" || t === "minimal" || t === "ac-only" || t === "ac_only")
+        return "rapid";
+    return null;
+}
+/**
+ * Resolve the active product-first check mode from env + ceremony + budget.
+ */
+export function resolveProductFirstCheckMode(input = {}) {
+    const env = input.environ ?? process.env;
+    const sources = [];
+    if (isTruthy(env[ENV_CHECK_AC_ONLY])) {
+        sources.push(`${ENV_CHECK_AC_ONLY}=truthy`);
+        return {
+            mode: "rapid",
+            sources,
+            hygieneAdvisory: true,
+            acOnly: true,
+            acMandatory: true,
+        };
+    }
+    const modeEnv = env[ENV_CHECK_MODE];
+    if (typeof modeEnv === "string" && modeEnv.trim().length > 0) {
+        const parsed = normalizeModeToken(modeEnv);
+        if (parsed !== null) {
+            sources.push(`${ENV_CHECK_MODE}=${modeEnv.trim()}`);
+            return {
+                mode: parsed,
+                sources,
+                hygieneAdvisory: parsed !== "full",
+                acOnly: parsed === "rapid",
+                acMandatory: true,
+            };
+        }
+    }
+    if (isTruthy(env[ENV_HYGIENE_ADVISORY])) {
+        sources.push(`${ENV_HYGIENE_ADVISORY}=truthy`);
+        return {
+            mode: "pressure",
+            sources,
+            hygieneAdvisory: true,
+            acOnly: false,
+            acMandatory: true,
+        };
+    }
+    let depth = input.ceremonyDepth;
+    if (depth === undefined && input.projectRoot !== undefined) {
+        try {
+            const audit = readCeremonyDialAudit(input.projectRoot);
+            depth = asCeremonyDepth(audit.depth);
+            if (depth !== null)
+                sources.push(`ceremony_dial.depth=${depth}`);
+        }
+        catch {
+            depth = null;
+        }
+    }
+    if (depth === "rapid" || depth === "minimal") {
+        if (!sources.some((s) => s.startsWith("ceremony_dial"))) {
+            sources.push(`ceremonyDepth=${depth}`);
+        }
+        return {
+            mode: "rapid",
+            sources,
+            hygieneAdvisory: true,
+            acOnly: true,
+            acMandatory: true,
+        };
+    }
+    let hardBudget = input.hardBudgetDetected;
+    if (hardBudget === undefined) {
+        hardBudget = detectHardEffortBudget({ environ: env }).detected;
+        if (hardBudget)
+            sources.push("hard_effort_budget");
+    }
+    else if (hardBudget) {
+        sources.push("hard_effort_budget(injected)");
+    }
+    if (hardBudget === true) {
+        return {
+            mode: "pressure",
+            sources,
+            hygieneAdvisory: true,
+            acOnly: false,
+            acMandatory: true,
+        };
+    }
+    sources.push("default:full");
+    return {
+        mode: "full",
+        sources,
+        hygieneAdvisory: false,
+        acOnly: false,
+        acMandatory: true,
+    };
+}
+/** True when this gate id is the product AC gate. */
+export function isProductAcGate(gateId) {
+    return gateId === PRODUCT_AC_GATE_ID || gateId === "verify:literal-ac";
+}
+/** True when this gate is classified as hygiene (may be advisory under pressure). */
+export function isHygieneGate(gateId) {
+    if (isProductAcGate(gateId))
+        return false;
+    return HYGIENE_GATE_ID_PREFIXES.includes(gateId);
+}
+/**
+ * Filter / annotate gate list for the resolved mode.
+ * - rapid: only product AC gates
+ * - pressure/full: full list (pressure marks hygiene advisory at run time)
+ */
+export function applyProductFirstGateMode(gates, mode, gateIdOf = (g) => (typeof g === "string" ? g : g.task)) {
+    if (mode === "rapid") {
+        const ac = gates.filter((g) => isProductAcGate(gateIdOf(g)));
+        return ac.length > 0 ? ac : gates.filter((g) => gateIdOf(g) === PRODUCT_AC_GATE_ID);
+    }
+    return gates;
+}
+//# sourceMappingURL=check-mode.js.map

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