@deftai/directive-core 0.99.0 → 0.101.0

package/dist/policy/ceremony-dial.d.ts

@@ -1,5 +1,5 @@
 /**
- * Ceremony dial (#3214): ritual depth = f(task size × model tier × project shape).
+ * Ceremony dial (#3214 / #3263): ritual depth = f(task size × model tier × project shape).
  *
  * Selection policy over existing pieces — not a new subsystem.
  * Composes:
@@ -7,11 +7,15 @@
  *   - #3014 minimal consumer AGENTS profile (research pointer; not yet a shipped deposit)
  *   - effort estimate (#1581), model routing (#1976/#818), host capability (#1461)
  *
- * Two-stage dial (#3214 design note / #1581 ordering):
- *   cold-start / incomplete inputs → **rapid** (start light; no plan-item deadlock)
- *   escalate when evidence arrives (provisional M/L, mid/low tier, full matrix)
+ * Two-stage dial (#3214 design note / #1581 ordering) with tier-conditional cold-start (#3263):
+ *   cold-start / incomplete size → **tier-conditional**:
+ *     frontier (or unknown tier) → rapid; mid/low → standard (not rapid)
+ *   escalate when evidence arrives (provisional M/L size, full matrix)
  * Full matrix: S × frontier → rapid; non-project → minimal; else scales up.
  * Override always available via plan.policy.ceremonyDial.override; audited on write.
+ *
+ * Audit path (#3263): session:start records depth + provisional reasons on
+ * `.deft/ritual-state.json` under `ceremony_dial` — use `readCeremonyDialAudit`.
  */
 /** Canonical dotted policy field name. */
 export declare const FIELD_CEREMONY_DIAL = "plan.policy.ceremonyDial";
@@ -60,6 +64,11 @@ export interface CeremonyDialProfile {
     readonly skipFatPath: boolean;
     /** How much lifecycle / history write budget this depth intends. */
     readonly lifecycleWrites: "minimal" | "light" | "full";
+    /**
+     * Literal acceptance-command verification is always required (#3267 / #3156).
+     * Ceremony dial never skips capture+verbatim run — including rapid/minimal.
+     */
+    readonly literalAcceptanceRequired: true;
     readonly label: string;
 }
 export type CeremonyDialSource = "override" | "matrix" | "default" | "disabled" | "typed" | "default-on-error";
@@ -97,25 +106,38 @@ export declare function normalizeCeremonyTaskSize(raw: unknown): CeremonyTaskSiz
 export declare function normalizeCeremonyModelTier(raw: unknown): CeremonyModelTier | null;
 export declare function normalizeCeremonyProjectShape(raw: unknown): CeremonyProjectShape | null;
 /**
- * Two-stage / partial-evidence selection when size or tier is missing (#3214 design note).
+ * Tier-conditional cold-start depth when task size is incomplete (#3263).
  *
- * Start light (rapid) on cold incomplete inputs; escalate when partial evidence already
- * implies heavier ceremony (apps-bank safety: hard/substantial work must not stay rapid).
- * Does not invent plan-item effort (#1581 post-planning only).
+ * Mid/low models benefit from structure on hard tasks and should not cold-start
+ * at rapid (start-light / escalate-too-late signature). Frontier recovers from a
+ * light start. Unknown tier stays rapid (optimistic cold default; pass
+ * `--model-tier` / `DEFT_CEREMONY_MODEL_TIER` to unlock the mid/low floor).
+ *
+ * Escalate-on-evidence still applies when size later arrives (full matrix).
+ */
+export declare function selectCeremonyColdStartDepth(modelTier: CeremonyModelTier | null | undefined): CeremonyDepth;
+/**
+ * Two-stage / partial-evidence selection when size or tier is missing
+ * (#3214 design note / #3263 tier-conditional cold-start).
+ *
+ * Cold incomplete size is tier-conditional (#3263): mid/low → standard, frontier
+ * or unknown → rapid. When size is known without tier, escalate on substantial
+ * size (apps-bank safety). Does not invent plan-item effort (#1581 post-planning only).
  */
 export declare function selectCeremonyDepthFromPartialEvidence(inputs: {
     readonly taskSize: CeremonyTaskSize | null;
     readonly modelTier: CeremonyModelTier | null;
 }): CeremonyDepth;
 /**
- * Pure default matrix (#3214 acceptance + two-stage design note):
+ * Pure default matrix (#3214 acceptance + #3263 tier-conditional cold-start):
  * - non-project → minimal (#3014 direction)
  * - S × frontier → rapid (strategies/rapid.md)
  * - S × mid → standard (mid-tier gains from structure)
  * - S × low → elevated
  * - M × low → elevated; M otherwise → standard
  * - L/XL → elevated (except L × frontier stays standard)
- * - Incomplete size/tier → two-stage partial evidence (default rapid; escalate on M/L or mid/low)
+ * - Incomplete size → tier-conditional cold-start (#3263): mid/low → standard; frontier/unknown → rapid
+ * - Size known, tier missing → escalate on M/L (partial evidence)
  */
 export declare function selectCeremonyDepthFromMatrix(inputs: CeremonyDialInputs): CeremonyDepth;
 export interface SelectCeremonyDepthOptions {
@@ -126,7 +148,7 @@ export interface SelectCeremonyDepthOptions {
  * Deterministic depth selection (pure; no IO).
  *
  * Precedence: disabled → standard; override → forced depth; else matrix on inputs;
- * empty inputs → **rapid** (two-stage cold default; escalate when evidence arrives).
+ * empty inputs → **rapid** (unknown-tier cold default; #3263 mid/low need modelTier set).
  */
 export declare function selectCeremonyDepth(options?: SelectCeremonyDepthOptions): CeremonyDialSelection;
 export interface ResolveCeremonyDialOptions {
@@ -230,4 +252,67 @@ export declare function resolveSessionCeremonyDialInputs(projectRoot: string, ex
     readonly inputs: CeremonyDialInputs;
     readonly provisional: ProvisionalCeremonyEstimate;
 };
+export interface CeremonyDialAuditProvisional {
+    readonly taskSize: CeremonyTaskSize | null;
+    readonly modelTier: CeremonyModelTier | null;
+    readonly projectShape: CeremonyProjectShape | null;
+    readonly reasons: readonly string[];
+}
+/**
+ * Snapshot of dial selection recorded on `.deft/ritual-state.json` at session:start.
+ * Operators audit failed-task depth / provisional reasons without re-running ritual.
+ */
+export interface CeremonyDialAuditSnapshot {
+    readonly path: string;
+    readonly depth: CeremonyDepth | null;
+    readonly source: string | null;
+    readonly inputs: {
+        readonly taskSize: CeremonyTaskSize | null;
+        readonly modelTier: CeremonyModelTier | null;
+        readonly projectShape: CeremonyProjectShape | null;
+    } | null;
+    readonly provisional: CeremonyDialAuditProvisional | null;
+    readonly raw: Record<string, unknown> | null;
+    readonly error: string | null;
+}
+/**
+ * Read ceremony dial depth + provisional reasons from ritual-state (#3263 audit path).
+ * session:start already writes `ceremony_dial` (incl. provisional) — this is the
+ * operator/read path so failed runs can confirm start-light vs escalate timing.
+ *
+ * Returns `error` when ritual-state is missing/unreadable or lacks `ceremony_dial`;
+ * does not throw.
+ */
+export declare function readCeremonyDialAudit(projectRoot: string): CeremonyDialAuditSnapshot;
+/** One-line operator summary for audit tooling / failed-task forensics (#3263). */
+export declare function formatCeremonyDialAuditLine(audit: CeremonyDialAuditSnapshot): string;
+/**
+ * Reified dial transition for run-summary telemetry (#3282).
+ *
+ * IMPLEMENTATION PREREQUISITE from the issue: dial transitions must be
+ * engine-managed events, not prose-only policy. This function is the CLI-facing
+ * transition hook (`policy:set-ceremony-dial` / dial escalate): it persists the
+ * override (when confirm) and always emits a `dial_transition` run-summary line
+ * when a depth change is applied.
+ */
+export interface EscalateCeremonyDialOptions {
+    readonly to: CeremonyDepth;
+    readonly reason: string;
+    readonly evidence?: string;
+    readonly sessionId?: string;
+    readonly confirm?: boolean;
+    readonly actor?: string;
+    readonly note?: string;
+    /** When false, skip run-summary emission (tests). Default true. */
+    readonly emitRunSummary?: boolean;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface EscalateCeremonyDialResult {
+    readonly exitCode: number;
+    readonly from: CeremonyDepth | null;
+    readonly to: CeremonyDepth;
+    readonly changed: boolean;
+    readonly lines: readonly string[];
+}
+export declare function escalateCeremonyDial(projectRoot: string, options: EscalateCeremonyDialOptions): EscalateCeremonyDialResult;
 //# sourceMappingURL=ceremony-dial.d.ts.map

package/dist/policy/ceremony-dial.js

@@ -1,5 +1,5 @@
 /**
- * Ceremony dial (#3214): ritual depth = f(task size × model tier × project shape).
+ * Ceremony dial (#3214 / #3263): ritual depth = f(task size × model tier × project shape).
  *
  * Selection policy over existing pieces — not a new subsystem.
  * Composes:
@@ -7,14 +7,19 @@
  *   - #3014 minimal consumer AGENTS profile (research pointer; not yet a shipped deposit)
  *   - effort estimate (#1581), model routing (#1976/#818), host capability (#1461)
  *
- * Two-stage dial (#3214 design note / #1581 ordering):
- *   cold-start / incomplete inputs → **rapid** (start light; no plan-item deadlock)
- *   escalate when evidence arrives (provisional M/L, mid/low tier, full matrix)
+ * Two-stage dial (#3214 design note / #1581 ordering) with tier-conditional cold-start (#3263):
+ *   cold-start / incomplete size → **tier-conditional**:
+ *     frontier (or unknown tier) → rapid; mid/low → standard (not rapid)
+ *   escalate when evidence arrives (provisional M/L size, full matrix)
  * Full matrix: S × frontier → rapid; non-project → minimal; else scales up.
  * Override always available via plan.policy.ceremonyDial.override; audited on write.
+ *
+ * Audit path (#3263): session:start records depth + provisional reasons on
+ * `.deft/ritual-state.json` under `ceremony_dial` — use `readCeremonyDialAudit`.
  */
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { RunSummaryEmitter } from "../run-summary/emit.js";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
 import { policyColonInvocation } from "./policy-invocation.js";
@@ -45,6 +50,9 @@ export const CEREMONY_MINIMAL_AGENTS_PROFILE_POINTER = "docs/analysis/2026-07-31
  *   (`verify:session-ritual --tier=gated`). Gated verify treats
  *   `deferred_reason` as satisfied, so dial-driven deferral would skip gates.
  * ! `verify_tools` also remains required on every dial depth (not skipFatPath).
+ * ! Literal acceptance-command verification (#3267) is required at every depth
+ *   (`literalAcceptanceRequired: true`), including rapid/minimal — capture exact
+ *   stated commands at intake and run them verbatim before done. Extends #973.
  * ~ Rapid/minimal MAY lighten informational cold path only: triage welcome,
  *   optional network/release probe, staleness tickler.
  */
@@ -55,6 +63,7 @@ const PROFILES = {
         autoDeferSteps: ["triage_welcome"],
         skipFatPath: true,
         lifecycleWrites: "minimal",
+        literalAcceptanceRequired: true,
         label: "minimal (non-project / #3014 direction)",
     },
     rapid: {
@@ -62,6 +71,7 @@ const PROFILES = {
         autoDeferSteps: ["triage_welcome"],
         skipFatPath: true,
         lifecycleWrites: "light",
+        literalAcceptanceRequired: true,
         label: "rapid (strategies/rapid.md light path)",
     },
     standard: {
@@ -69,6 +79,7 @@ const PROFILES = {
         autoDeferSteps: [],
         skipFatPath: false,
         lifecycleWrites: "full",
+        literalAcceptanceRequired: true,
         label: "standard (full session ritual)",
     },
     elevated: {
@@ -76,6 +87,7 @@ const PROFILES = {
         autoDeferSteps: [],
         skipFatPath: false,
         lifecycleWrites: "full",
+        literalAcceptanceRequired: true,
         label: "elevated (full ritual; prefer more gates for weaker tiers / large tasks)",
     },
 };
@@ -186,11 +198,29 @@ export function normalizeCeremonyProjectShape(raw) {
     return null;
 }
 /**
- * Two-stage / partial-evidence selection when size or tier is missing (#3214 design note).
+ * Tier-conditional cold-start depth when task size is incomplete (#3263).
+ *
+ * Mid/low models benefit from structure on hard tasks and should not cold-start
+ * at rapid (start-light / escalate-too-late signature). Frontier recovers from a
+ * light start. Unknown tier stays rapid (optimistic cold default; pass
+ * `--model-tier` / `DEFT_CEREMONY_MODEL_TIER` to unlock the mid/low floor).
+ *
+ * Escalate-on-evidence still applies when size later arrives (full matrix).
+ */
+export function selectCeremonyColdStartDepth(modelTier) {
+    if (modelTier === "mid" || modelTier === "low") {
+        return "standard";
+    }
+    // frontier or unknown → rapid
+    return "rapid";
+}
+/**
+ * Two-stage / partial-evidence selection when size or tier is missing
+ * (#3214 design note / #3263 tier-conditional cold-start).
  *
- * Start light (rapid) on cold incomplete inputs; escalate when partial evidence already
- * implies heavier ceremony (apps-bank safety: hard/substantial work must not stay rapid).
- * Does not invent plan-item effort (#1581 post-planning only).
+ * Cold incomplete size is tier-conditional (#3263): mid/low → standard, frontier
+ * or unknown → rapid. When size is known without tier, escalate on substantial
+ * size (apps-bank safety). Does not invent plan-item effort (#1581 post-planning only).
  */
 export function selectCeremonyDepthFromPartialEvidence(inputs) {
     const size = inputs.taskSize;
@@ -203,26 +233,20 @@ export function selectCeremonyDepthFromPartialEvidence(inputs) {
             return "standard";
         return "elevated"; // L / XL
     }
-    // Tier known, size unknown — mid/low need structure; frontier can start light.
-    if (size === null && tier !== null) {
-        if (tier === "frontier")
-            return "rapid";
-        if (tier === "mid")
-            return "standard";
-        return "elevated"; // low
-    }
-    // Both unknown: two-stage cold default.
-    return "rapid";
+    // Size incomplete (null), any tier including unknown: tier-conditional cold-start (#3263).
+    // Callers with both size and tier set use the full matrix instead.
+    return selectCeremonyColdStartDepth(tier);
 }
 /**
- * Pure default matrix (#3214 acceptance + two-stage design note):
+ * Pure default matrix (#3214 acceptance + #3263 tier-conditional cold-start):
  * - non-project → minimal (#3014 direction)
  * - S × frontier → rapid (strategies/rapid.md)
  * - S × mid → standard (mid-tier gains from structure)
  * - S × low → elevated
  * - M × low → elevated; M otherwise → standard
  * - L/XL → elevated (except L × frontier stays standard)
- * - Incomplete size/tier → two-stage partial evidence (default rapid; escalate on M/L or mid/low)
+ * - Incomplete size → tier-conditional cold-start (#3263): mid/low → standard; frontier/unknown → rapid
+ * - Size known, tier missing → escalate on M/L (partial evidence)
  */
 export function selectCeremonyDepthFromMatrix(inputs) {
     const shape = inputs.projectShape ?? null;
@@ -279,7 +303,7 @@ function parseConfig(raw) {
  * Deterministic depth selection (pure; no IO).
  *
  * Precedence: disabled → standard; override → forced depth; else matrix on inputs;
- * empty inputs → **rapid** (two-stage cold default; escalate when evidence arrives).
+ * empty inputs → **rapid** (unknown-tier cold default; #3263 mid/low need modelTier set).
  */
 export function selectCeremonyDepth(options = {}) {
     const config = {
@@ -317,8 +341,8 @@ export function selectCeremonyDepth(options = {}) {
     }
     const hasAnyInput = inputs.taskSize !== null || inputs.modelTier !== null || inputs.projectShape !== null;
     if (!hasAnyInput) {
-        // Two-stage dial cold default (#3214 design note / #1581 ordering).
-        const depth = "rapid";
+        // Unknown-tier cold default (#3214 / #3263): rapid until modelTier or size arrives.
+        const depth = selectCeremonyColdStartDepth(null);
         return {
             depth,
             source: "default",
@@ -408,6 +432,7 @@ export function ceremonyDialToDict(selection) {
             autoDeferSteps: [...selection.profile.autoDeferSteps],
             skipFatPath: selection.profile.skipFatPath,
             lifecycleWrites: selection.profile.lifecycleWrites,
+            literalAcceptanceRequired: selection.profile.literalAcceptanceRequired,
             label: selection.profile.label,
         },
         composition: {
@@ -826,4 +851,206 @@ export function resolveSessionCeremonyDialInputs(projectRoot, explicit, options
         provisional,
     };
 }
+function asOptionalDepth(value) {
+    return isCeremonyDepth(value) ? value : null;
+}
+function asOptionalTaskSize(value) {
+    return isTaskSize(value) ? value : null;
+}
+function asOptionalModelTier(value) {
+    return isModelTier(value) ? value : null;
+}
+function asOptionalProjectShape(value) {
+    return isProjectShape(value) ? value : null;
+}
+/**
+ * Read ceremony dial depth + provisional reasons from ritual-state (#3263 audit path).
+ * session:start already writes `ceremony_dial` (incl. provisional) — this is the
+ * operator/read path so failed runs can confirm start-light vs escalate timing.
+ *
+ * Returns `error` when ritual-state is missing/unreadable or lacks `ceremony_dial`;
+ * does not throw.
+ */
+export function readCeremonyDialAudit(projectRoot) {
+    const path = join(projectRoot, ".deft", "ritual-state.json");
+    const empty = (error) => ({
+        path,
+        depth: null,
+        source: null,
+        inputs: null,
+        provisional: null,
+        raw: null,
+        error,
+    });
+    try {
+        if (!existsSync(path) || !statSync(path).isFile()) {
+            return empty(`ritual-state missing at ${path}`);
+        }
+    }
+    catch (exc) {
+        return empty(`ritual-state unreadable at ${path}: ${String(exc)}`);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(readFileSync(path, { encoding: "utf8" }));
+    }
+    catch (exc) {
+        if (exc instanceof SyntaxError) {
+            return empty(`ritual-state is not valid JSON: ${exc.message}`);
+        }
+        return empty(`ritual-state cannot be read: ${String(exc)}`);
+    }
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return empty("ritual-state top-level value must be an object");
+    }
+    const root = payload;
+    const dialRaw = root.ceremony_dial;
+    if (dialRaw === undefined || dialRaw === null) {
+        return empty("ritual-state has no ceremony_dial field (pre-#3214 or non-mutation session)");
+    }
+    if (typeof dialRaw !== "object" || Array.isArray(dialRaw)) {
+        return empty("ritual-state ceremony_dial must be an object");
+    }
+    const dial = dialRaw;
+    const depth = asOptionalDepth(dial.depth);
+    const source = typeof dial.source === "string" ? dial.source : null;
+    let inputs = null;
+    const inputsRaw = dial.inputs;
+    if (typeof inputsRaw === "object" && inputsRaw !== null && !Array.isArray(inputsRaw)) {
+        const rec = inputsRaw;
+        inputs = {
+            taskSize: asOptionalTaskSize(rec.taskSize),
+            modelTier: asOptionalModelTier(rec.modelTier),
+            projectShape: asOptionalProjectShape(rec.projectShape),
+        };
+    }
+    let provisional = null;
+    const provRaw = dial.provisional;
+    if (typeof provRaw === "object" && provRaw !== null && !Array.isArray(provRaw)) {
+        const rec = provRaw;
+        const reasons = Array.isArray(rec.reasons)
+            ? rec.reasons.filter((r) => typeof r === "string")
+            : [];
+        provisional = {
+            taskSize: asOptionalTaskSize(rec.taskSize),
+            modelTier: asOptionalModelTier(rec.modelTier),
+            projectShape: asOptionalProjectShape(rec.projectShape),
+            reasons,
+        };
+    }
+    return {
+        path,
+        depth,
+        source,
+        inputs,
+        provisional,
+        raw: { ...dial },
+        error: null,
+    };
+}
+/** Collapse whitespace so operator audit lines stay single-line (Greptile P2 #3263). */
+function oneLineAuditToken(value) {
+    return value
+        .replace(/[\r\n\t]+/g, " ")
+        .replace(/ {2,}/g, " ")
+        .trim();
+}
+/** One-line operator summary for audit tooling / failed-task forensics (#3263). */
+export function formatCeremonyDialAuditLine(audit) {
+    if (audit.error !== null) {
+        return `[deft ceremony-dial audit] error=${oneLineAuditToken(audit.error)}`;
+    }
+    const parts = [
+        `[deft ceremony-dial audit] depth=${audit.depth ?? "-"}`,
+        `source=${audit.source ?? "-"}`,
+        `taskSize=${audit.inputs?.taskSize ?? "-"}`,
+        `modelTier=${audit.inputs?.modelTier ?? "-"}`,
+        `projectShape=${audit.inputs?.projectShape ?? "-"}`,
+    ];
+    if (audit.provisional !== null) {
+        const reasons = audit.provisional.reasons.length > 0
+            ? audit.provisional.reasons
+                .map(oneLineAuditToken)
+                .filter((r) => r.length > 0)
+                .join("; ")
+            : "(none)";
+        parts.push(`provisional.reasons=${reasons.length > 0 ? reasons : "(none)"}`);
+    }
+    return parts.join(" ");
+}
+export function escalateCeremonyDial(projectRoot, options) {
+    const prior = resolveCeremonyDial(projectRoot);
+    const from = prior.depth;
+    if (options.confirm !== true) {
+        return {
+            exitCode: 1,
+            from,
+            to: options.to,
+            changed: false,
+            lines: [
+                "Ceremony dial escalate changes ritual depth for future session:start.",
+                "  Re-run with --confirm to apply.",
+                `  Proposed: ${from} -> ${options.to} (reason: ${oneLineAuditToken(options.reason)})`,
+            ],
+        };
+    }
+    const setResult = setCeremonyDial(projectRoot, {
+        override: options.to,
+        confirm: true,
+        actor: options.actor ?? policyColonInvocation("set-ceremony-dial"),
+        note: options.note ?? `escalate: ${options.reason}`,
+    });
+    if (setResult.exitCode !== 0) {
+        return {
+            exitCode: setResult.exitCode,
+            from,
+            to: options.to,
+            changed: false,
+            lines: setResult.stdout
+                .split("\n")
+                .map((l) => l.trimEnd())
+                .filter((l) => l.length > 0),
+        };
+    }
+    // #3282: event-driven dial_transition line (fail-open).
+    if (options.emitRunSummary !== false) {
+        try {
+            const audit = readCeremonyDialAudit(projectRoot);
+            const rawSid = audit.raw?.session_id;
+            const sid = options.sessionId ??
+                (typeof rawSid === "string" && rawSid.length > 0
+                    ? rawSid
+                    : `dial-${Date.now().toString(36)}`);
+            const emitter = new RunSummaryEmitter({
+                projectRoot,
+                sessionId: sid,
+                env: options.env,
+            });
+            emitter.emitDialTransition({
+                from,
+                to: options.to,
+                reason: options.reason,
+                evidence: options.evidence,
+            });
+        }
+        catch {
+            // fail-open
+        }
+    }
+    return {
+        exitCode: 0,
+        from,
+        to: options.to,
+        changed: setResult.changed || from !== options.to,
+        lines: [
+            `✓ ceremony dial escalate: ${from} -> ${options.to}`,
+            `  reason: ${oneLineAuditToken(options.reason)}`,
+            ...(options.evidence ? [`  evidence: ${oneLineAuditToken(options.evidence)}`] : []),
+            ...setResult.stdout
+                .split("\n")
+                .map((l) => l.trimEnd())
+                .filter((l) => l.length > 0),
+        ],
+    };
+}
 //# sourceMappingURL=ceremony-dial.js.map

package/dist/policy/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./ac-pass-banking.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
@@ -13,6 +14,7 @@ export * from "./host-hooks.js";
 export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
+export * from "./merge-approval-head.js";
 export * from "./min-greptile-confidence.js";
 export * from "./no-deft-directive.js";
 export * from "./org-force-on-migration.js";

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,6 +17,7 @@ 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";
@@ -31,6 +33,7 @@ export * from "./host-hooks.js";
 export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
+export * from "./merge-approval-head.js";
 export * from "./min-greptile-confidence.js";
 export * from "./no-deft-directive.js";
 export * from "./org-force-on-migration.js";
@@ -419,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,
@@ -447,6 +459,7 @@ const REGISTERED_POLICIES = [
     inspectRequireHumanMergeField,
     inspectHotfixCriteriaField,
     inspectCeremonyDialField,
+    inspectAcPassBankingField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
 export function inspectAllPolicies(projectRoot) {
@@ -485,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;