@deftai/directive-core 0.100.0 → 0.102.0

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

@@ -0,0 +1,76 @@
+/**
+ * evaluate verify:ac — product-first acceptance gate (#3284).
+ *
+ * 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 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 {
+    /**
+     * When true, missing xBRIEF / no active scope is exit 0 (check composition).
+     * Default false for standalone done-gate use.
+     */
+    readonly softMissingXbrief?: boolean;
+    /**
+     * Check-graph mode (#3284): used by `task check` via `--soft-missing-xbrief`.
+     * - Unpromoted capture-only (task_statement) commands do not fail the graph
+     *   (promotion remains a done-gate / scope:complete concern via verify:ac standalone).
+     * - Executable command failures still fail closed (product-first).
+     * - Safety-rejected ledger still fails closed.
+     */
+    readonly checkIntegrated?: boolean;
+    /** Allow task_statement sources to execute (tests / explicit promote). */
+    readonly allowTaskStatement?: boolean;
+    /**
+     * When false, skip AC-pass banking after executable pass (#3285).
+     * Default true — first green executable AC banks a finalize checkpoint.
+     */
+    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.
+ */
+export declare function evaluateVerifyAcFromPlan(plan: Record<string, unknown>, options?: EvaluateVerifyAcOptions): VerifyAcResult;
+/**
+ * Evaluate from xBRIEF path.
+ */
+export declare function evaluateVerifyAcFromPath(xbriefPath: string, options?: EvaluateVerifyAcOptions): VerifyAcResult;
+/** Pure: product AC is required at every ceremony depth (#3284 / #3267 / #3156). */
+export declare function isVerifyAcRequiredAtCeremonyDepth(_depth: string | null | undefined): boolean;
+//# sourceMappingURL=evaluate.d.ts.map

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

@@ -0,0 +1,411 @@
+/**
+ * evaluate verify:ac — product-first acceptance gate (#3284).
+ *
+ * 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 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;
+    }
+    return null;
+}
+/**
+ * Evaluate product AC from an in-memory plan.
+ */
+export function evaluateVerifyAcFromPlan(plan, options = {}) {
+    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 applyOracle({
+            ok: false,
+            code: 2,
+            message: `verify:ac config error (#3284): ${schemaErrors.join("; ")}`,
+            commands: [],
+            runs: [],
+            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.
+    // Empty plan.acceptance.commands still consults the #3267 rejected ledger
+    // (Greptile P1: rejected stated AC must never soft-pass).
+    // For derived/floor commands already on plan.acceptance, inject as explicit metadata
+    // if the literal ledger is empty of executables.
+    const base = evaluateLiteralAcceptanceFromPlan(plan, {
+        projectRoot,
+        runner: options.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: options.captureFromNarratives ?? (options.checkIntegrated === true ? false : undefined),
+        quiet: options.quiet,
+    });
+    // When literal path had nothing executable but plan.acceptance has derived commands,
+    // run them directly with source=explicit semantics.
+    if (base.ok &&
+        base.runs.length === 0 &&
+        acceptance.commands.length > 0 &&
+        (acceptance.source_rung === "derived" || acceptance.source_rung === "project_floor")) {
+        const runner = options.runner;
+        const direct = runLiteralAcceptanceCommands(acceptance.commands.map((c) => ({
+            command: c.command,
+            cwd: c.cwd ?? null,
+            expectedStdout: c.expectedStdout ?? null,
+            expectedExitCode: c.expectedExitCode ?? 0,
+            source: "explicit",
+            sourceSpan: "plan.acceptance.commands",
+        })), { projectRoot, runner, allowTaskStatement: options.allowTaskStatement });
+        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.
+    // 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) {
+        const hasRejected = (base.rejected?.length ?? 0) > 0;
+        if (hasRejected) {
+            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 applyOracle({
+                ok: true,
+                code: 0,
+                message: options.quiet
+                    ? ""
+                    : `verify:ac advisory (#3284 check-integrated): no executable AC peers yet ` +
+                        `(capture-only / empty). Done-gate standalone verify:ac still requires promotion. ` +
+                        `[rung=${acceptance.source_rung}]\n` +
+                        base.message,
+                commands: base.commands,
+                runs: [],
+                rejected: base.rejected,
+                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" };
+        }
+    }
+    if (options.skipAcceptanceEmit !== true) {
+        emitAcceptanceOutcome(next, options, projectRoot);
+    }
+    return next;
+}
+function annotate(result, acceptance, quiet) {
+    const prefix = result.ok
+        ? `verify:ac passed (#3284) [rung=${acceptance.source_rung}]`
+        : `verify:ac FAILED (#3284) [rung=${acceptance.source_rung}]`;
+    let message = result.message;
+    if (!quiet) {
+        if (message.includes("#3267")) {
+            message = message.replace(/#3267/g, "#3284/#3267");
+        }
+        if (!message.startsWith("verify:ac")) {
+            message = `${prefix}\n${message}`;
+        }
+        else if (!message.includes(`rung=${acceptance.source_rung}`)) {
+            message = `${message} [rung=${acceptance.source_rung}]`;
+        }
+    }
+    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,
+    };
+}
+/**
+ * Evaluate from xBRIEF path.
+ */
+export function evaluateVerifyAcFromPath(xbriefPath, options = {}) {
+    const abs = resolve(xbriefPath);
+    if (!existsSync(abs)) {
+        if (options.softMissingXbrief) {
+            return applyOracle(softSkip(`xBRIEF not found: ${abs}`, options.quiet), options);
+        }
+        return applyOracle(configResult(`verify:ac: xBRIEF not found: ${abs}`), options);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(abs, "utf8"));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return applyOracle(configResult(`verify:ac: unreadable xBRIEF (${msg}): ${abs}`), options);
+    }
+    const data = asRecord(parsed);
+    if (data === null) {
+        return applyOracle(configResult(`verify:ac: xBRIEF top-level is not an object: ${abs}`), options);
+    }
+    const plan = asRecord(data.plan);
+    if (plan === null) {
+        return applyOracle(configResult(`verify:ac: xBRIEF missing plan object: ${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).
+ * Soft/advisory passes with zero runs do not bank. Fail-open on ledger errors.
+ */
+function maybeAttachAcPassBank(result, plan, xbriefPath, options) {
+    if (options.bankOnPass === false) {
+        return result;
+    }
+    if (!result.ok || result.runs.length === 0) {
+        return result;
+    }
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const planId = typeof plan.id === "string" && plan.id.trim() ? plan.id.trim() : null;
+    const scopeId = options.bankScopeId?.trim() ||
+        planId ||
+        basename(xbriefPath)
+            .replace(/\.xbrief\.json$/i, "")
+            .replace(/\.vbrief\.json$/i, "");
+    try {
+        const banked = maybeBankOnAcPass({
+            projectRoot,
+            scopeId,
+            executableRuns: result.runs.length,
+            quiet: options.quiet,
+        });
+        if (options.quiet || banked.notes.length === 0) {
+            return result;
+        }
+        const extra = banked.notes.join("\n");
+        return {
+            ...result,
+            message: result.message ? `${result.message}\n${extra}` : extra,
+        };
+    }
+    catch (err) {
+        // Checkpoint is mandatory after executable AC green (#3285 Greptile residual).
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            ...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,
+        code: 0,
+        message: quiet ? "" : `verify:ac skipped (#3284 soft-missing): ${detail}`,
+        commands: [],
+        runs: [],
+        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). */
+export function isVerifyAcRequiredAtCeremonyDepth(_depth) {
+    return true;
+}
+//# sourceMappingURL=evaluate.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * Product-first done-gate (#3284).
+ *
+ * acceptance.commands schema, verify:ac evaluation, check-mode composition
+ * (AC-first, hygiene advisory under pressure, rapid=AC-only).
+ */
+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

@@ -0,0 +1,12 @@
+/**
+ * Product-first done-gate (#3284).
+ *
+ * acceptance.commands schema, verify:ac evaluation, check-mode composition
+ * (AC-first, hygiene advisory under pressure, rapid=AC-only).
+ */
+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

@@ -0,0 +1,67 @@
+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.
+ *
+ * Architecture for #3267 (literal acceptance-command mechanism). Composes
+ * #3214 ceremony dial (rapid = AC-only) and #3266 bank-the-pass.
+ */
+/** Three-rung AC-source ladder (probe lock on #3284). */
+export type AcSourceRung = "stated" | "derived" | "project_floor";
+/**
+ * One executable acceptance command (verbatim when source_rung=stated).
+ * Mirrors literal-acceptance command shape for interoperability.
+ */
+export interface AcceptanceCommand {
+    readonly command: string;
+    readonly cwd?: string | null;
+    readonly expectedStdout?: string | null;
+    readonly expectedExitCode?: number;
+}
+/**
+ * Canonical plan.acceptance block (#3284).
+ *
+ * - Empty `commands` is allowed only when `none_stated: true` (absence is a decision).
+ * - `none_stated: true` never means "no AC" — it means AC is derived/floor and flagged.
+ * - `source_rung` records which ladder rung was locked at intake / promote.
+ */
+export interface PlanAcceptance {
+    readonly commands: readonly AcceptanceCommand[];
+    /** Explicit marker when the task statement stated no shell commands. */
+    readonly none_stated: boolean;
+    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 = 
+/** Full graph: AC first (fail-fast), then hygiene (hard), then suite. */
+"full"
+/**
+ * Budget pressure / degraded env: AC still mandatory; hygiene runs but is
+ * advisory (non-zero does not fail check). Suite still runs after AC when present.
+ */
+ | "pressure"
+/**
+ * Ceremony dial rapid/minimal positive content: only AC verification
+ * (no hygiene, no suite) before declaring done via check.
+ */
+ | "rapid";
+/** Canonical product AC gate id used in check gate lists. */
+export declare const PRODUCT_AC_GATE_ID: "verify:ac";
+/** plan.acceptance object key on the plan root. */
+export declare const PLAN_ACCEPTANCE_KEY: "acceptance";
+/** Env override for check mode (full|pressure|rapid|degraded→pressure). */
+export declare const ENV_CHECK_MODE = "DEFT_CHECK_MODE";
+/** Explicit hygiene-advisory flag (truthy → pressure mode floor). */
+export declare const ENV_HYGIENE_ADVISORY = "DEFT_HYGIENE_ADVISORY";
+/** Explicit rapid AC-only flag (truthy → rapid mode). */
+export declare const ENV_CHECK_AC_ONLY = "DEFT_CHECK_AC_ONLY";
+/**
+ * Hygiene gate ids (framework + consumer). Failures may become advisory under
+ * pressure; AC never does. Suite gates are separate (#3188).
+ */
+export declare const HYGIENE_GATE_ID_PREFIXES: readonly string[];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,54 @@
+/** 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. */
+export const PLAN_ACCEPTANCE_KEY = "acceptance";
+/** Env override for check mode (full|pressure|rapid|degraded→pressure). */
+export const ENV_CHECK_MODE = "DEFT_CHECK_MODE";
+/** Explicit hygiene-advisory flag (truthy → pressure mode floor). */
+export const ENV_HYGIENE_ADVISORY = "DEFT_HYGIENE_ADVISORY";
+/** Explicit rapid AC-only flag (truthy → rapid mode). */
+export const ENV_CHECK_AC_ONLY = "DEFT_CHECK_AC_ONLY";
+/**
+ * Hygiene gate ids (framework + consumer). Failures may become advisory under
+ * pressure; AC never does. Suite gates are separate (#3188).
+ */
+export const HYGIENE_GATE_ID_PREFIXES = [
+    "verify:branch",
+    "verify:encoding",
+    "verify:cache-fresh",
+    "verify:orphan-active",
+    "verify:license-sync",
+    "verify:contract-drift",
+    "toolchain:check",
+    "toolchain:check-consumer",
+    "verify:stubs",
+    "verify:links",
+    "verify:rule-ownership",
+    "verify:biome-config",
+    "verify:content-manifest",
+    "verify:skill-external-fetch-gate",
+    "verify:cursor-tier1",
+    "verify:openclaw-tier1",
+    "verify:go-freeze",
+    "verify:bridge-drift",
+    "verify:forward-coverage",
+    "verify:test-boundary",
+    "verify:scope-provenance",
+    "verify:consumer-check-contract",
+    "verify:vbrief-conformance",
+    "verify:destructive-gh-verbs",
+    "verify:scm-boundary",
+    "verify:xbrief-drift",
+    "verify:no-task-runtime",
+    "verify:pack-drift",
+    "verify:wip-cap",
+    "verify:agents-md-budget",
+    "verify:eval-health-relocation",
+    "verify:eval-triggers-relocation",
+    "vbrief:validate",
+    "codebase:validate-structure",
+    "verify:codebase-map-fresh",
+    "verify-strategy-output",
+    "doctor",
+];
+//# sourceMappingURL=types.js.map