@deftai/directive-core 0.101.0 → 0.103.0

package/dist/policy/ceremony-dial.js

@@ -401,7 +401,7 @@ export function resolveCeremonyDial(projectRoot, options = {}) {
     return selected;
 }
 /** Human-readable status line for session:start / policy:show. */
-export function formatCeremonyDialStatusLine(selection) {
+export function formatCeremonyDialStatusLine(selection, extras) {
     const parts = [
         `[deft ceremony-dial] depth=${selection.depth}`,
         `source=${selection.source}`,
@@ -409,6 +409,10 @@ export function formatCeremonyDialStatusLine(selection) {
         `modelTier=${selection.inputs.modelTier ?? "-"}`,
         `projectShape=${selection.inputs.projectShape ?? "-"}`,
     ];
+    if (extras?.startTierProvenance !== undefined && extras.startTierProvenance.length > 0) {
+        parts.push(`start-tier=${selection.depth}`);
+        parts.push(`provenance=${extras.startTierProvenance}`);
+    }
     if (selection.composition.rapidStrategy) {
         parts.push(`compose=${selection.composition.rapidStrategy}`);
     }
@@ -981,7 +985,49 @@ export function formatCeremonyDialAuditLine(audit) {
 export function escalateCeremonyDial(projectRoot, options) {
     const prior = resolveCeremonyDial(projectRoot);
     const from = prior.depth;
+    const emitEscalationEvaluation = (applied, reasonSuffix) => {
+        if (options.emitRunSummary === false) {
+            return;
+        }
+        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 rank = {
+                minimal: 0,
+                rapid: 1,
+                standard: 2,
+                elevated: 3,
+            };
+            const raised = rank[options.to] > rank[from];
+            const outcome = applied && raised ? "escalated" : "declined";
+            const baseReason = options.confirm === true
+                ? options.reason
+                : `${options.reason}; not applied (need --confirm)`;
+            const reason = reasonSuffix !== undefined && reasonSuffix.length > 0
+                ? `${baseReason}; ${reasonSuffix}`
+                : baseReason;
+            const emitter = new RunSummaryEmitter({
+                projectRoot,
+                sessionId: sid,
+                env: options.env,
+            });
+            emitter.emitDialEscalationEvaluation({
+                tier: outcome === "escalated" ? options.to : from,
+                outcome,
+                reason,
+            });
+            emitter.emitKnownToolTurnDenominator();
+        }
+        catch {
+            // fail-open
+        }
+    };
     if (options.confirm !== true) {
+        emitEscalationEvaluation(false);
         return {
             exitCode: 1,
             from,
@@ -1001,6 +1047,8 @@ export function escalateCeremonyDial(projectRoot, options) {
         note: options.note ?? `escalate: ${options.reason}`,
     });
     if (setResult.exitCode !== 0) {
+        const persistDetail = oneLineAuditToken(setResult.stdout.trim().split("\n")[0] ?? `exit ${setResult.exitCode}`);
+        emitEscalationEvaluation(false, `persist failed (exit ${setResult.exitCode}): ${persistDetail}`);
         return {
             exitCode: setResult.exitCode,
             from,
@@ -1012,6 +1060,8 @@ export function escalateCeremonyDial(projectRoot, options) {
                 .filter((l) => l.length > 0),
         };
     }
+    // #3319: evaluation event on every escalate path (applied or not).
+    emitEscalationEvaluation(true);
     // #3282: event-driven dial_transition line (fail-open).
     if (options.emitRunSummary !== false) {
         try {
@@ -1032,6 +1082,7 @@ export function escalateCeremonyDial(projectRoot, options) {
                 reason: options.reason,
                 evidence: options.evidence,
             });
+            emitter.emitKnownToolTurnDenominator();
         }
         catch {
             // fail-open

package/dist/policy/check-resume.d.ts

@@ -1,52 +1,36 @@
 /**
- * Check-resume / local suite-stamp policy (#3189).
+ * Check-resume / local suite-stamp policy (#3189 / #3314).
  *
- * Consent / SoT surface for consumer expansion of local suite-stamp resume
- * (#3188). Unset is fail-closed (localStamp off). CI never trusts a local
- * stamp in v1 — `ciTrustsLocalStamp` is fixed false.
+ * Plain optional setting. Default off. Fail-closed when absent or invalid.
+ * Reserved — consumer expansion not implemented. CI never trusts a laptop stamp.
  */
 /** Canonical registered policy field name. */
 export declare const FIELD_CHECK_RESUME = "plan.policy.checkResume";
 /** Short alias for `policy:show --field=checkResume`. */
 export declare const FIELD_CHECK_RESUME_CLI_ALIAS = "checkResume";
-export declare const CHECK_RESUME_STATUSES: readonly ["unset", "decided"];
-export type CheckResumeStatus = (typeof CHECK_RESUME_STATUSES)[number];
 export declare const CHECK_RESUME_LOCAL_STAMP: readonly ["off", "on"];
 export type CheckResumeLocalStamp = (typeof CHECK_RESUME_LOCAL_STAMP)[number];
-/** Fail-closed when unset / missing. */
+/** Fail-closed when absent / missing / invalid. */
 export declare const DEFAULT_CHECK_RESUME_LOCAL_STAMP: CheckResumeLocalStamp;
-/**
- * FIXED false in v1 (#3189 non-goal). Separate RFC required to ever allow CI
- * to trust a laptop suite stamp.
- */
-export declare const CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1: false;
 export interface CheckResumeConfig {
-    readonly status: CheckResumeStatus;
     readonly localStamp: CheckResumeLocalStamp;
-    /** Always false in v1; present for schema visibility. */
-    readonly ciTrustsLocalStamp: false;
-    /** Present when decided via dismiss-with-reason. */
-    readonly dismissReason: string | null;
 }
 export type CheckResumeSource = "typed" | "default" | "default-on-error";
 export interface CheckResumeResolved extends CheckResumeConfig {
     readonly source: CheckResumeSource;
     readonly error: string | null;
 }
-/** Validate a `plan.policy.checkResume` payload. */
+/** Validate a `plan.policy.checkResume` payload. Extra keys are ignored. */
 export declare function validateCheckResume(value: unknown): string[];
 /**
- * Resolve a typed block. Missing/invalid → localStamp off, status unset.
- * `ciTrustsLocalStamp` is always forced false regardless of input truthiness
- * (malformed non-false is validation error → fail-closed default).
+ * Resolve a typed block. Missing/invalid → localStamp off.
+ * Leftover ritual fields (status/dismissReason/ciTrustsLocalStamp) are ignored.
  */
 export declare function resolveCheckResumeFromTypedBlock(raw: unknown): CheckResumeResolved;
-/** Resolve `plan.policy.checkResume` from PROJECT-DEFINITION (#3189). */
+/** Resolve `plan.policy.checkResume` from PROJECT-DEFINITION (#3314). */
 export declare function resolveCheckResume(projectRoot: string): CheckResumeResolved;
-/** Local suite stamp resume only when decided localStamp=on. */
+/** Local suite stamp resume only when localStamp=on. Reserved — unused by check/release. */
 export declare function isLocalStampResumeAllowed(policy: CheckResumeResolved): boolean;
-/** Always false in v1 — CI must re-run suite, never trust a laptop stamp. */
-export declare function isCiTrustsLocalStampAllowed(_policy?: CheckResumeResolved): false;
 export declare function formatCheckResumeStatusLine(policy: CheckResumeResolved): string;
 export interface CheckResumePolicyField {
     readonly name: typeof FIELD_CHECK_RESUME;
@@ -56,17 +40,4 @@ export interface CheckResumePolicyField {
 }
 /** Inspector row for `policy:show --field=checkResume`. */
 export declare function inspectCheckResume(data: Record<string, unknown> | null, projectRoot?: string): CheckResumePolicyField;
-export interface WriteCheckResumeOptions {
-    readonly localStamp: CheckResumeLocalStamp;
-    readonly dismissReason?: string | null;
-    readonly actor?: string;
-    readonly note?: string;
-}
-export interface WriteCheckResumeResult {
-    readonly exitCode: 0 | 2;
-    readonly stdout: string;
-    readonly changed: boolean;
-}
-/** Persist decided checkResume (preset or dismiss-with-reason). */
-export declare function writeCheckResume(projectRoot: string, options: WriteCheckResumeOptions): WriteCheckResumeResult;
 //# sourceMappingURL=check-resume.d.ts.map

package/dist/policy/check-resume.js

@@ -1,45 +1,29 @@
 /**
- * Check-resume / local suite-stamp policy (#3189).
+ * Check-resume / local suite-stamp policy (#3189 / #3314).
  *
- * Consent / SoT surface for consumer expansion of local suite-stamp resume
- * (#3188). Unset is fail-closed (localStamp off). CI never trusts a local
- * stamp in v1 — `ciTrustsLocalStamp` is fixed false.
+ * Plain optional setting. Default off. Fail-closed when absent or invalid.
+ * Reserved — consumer expansion not implemented. CI never trusts a laptop stamp.
  */
-import { readFileSync } from "node:fs";
-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";
-import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
 /** Canonical registered policy field name. */
 export const FIELD_CHECK_RESUME = "plan.policy.checkResume";
 /** Short alias for `policy:show --field=checkResume`. */
 export const FIELD_CHECK_RESUME_CLI_ALIAS = "checkResume";
-export const CHECK_RESUME_STATUSES = ["unset", "decided"];
 export const CHECK_RESUME_LOCAL_STAMP = ["off", "on"];
-/** Fail-closed when unset / missing. */
+/** Fail-closed when absent / missing / invalid. */
 export const DEFAULT_CHECK_RESUME_LOCAL_STAMP = "off";
-/**
- * FIXED false in v1 (#3189 non-goal). Separate RFC required to ever allow CI
- * to trust a laptop suite stamp.
- */
-export const CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1 = false;
 function defaultResolved(source, error = null) {
     return {
-        status: "unset",
         localStamp: DEFAULT_CHECK_RESUME_LOCAL_STAMP,
-        ciTrustsLocalStamp: CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1,
-        dismissReason: null,
         source,
         error,
     };
 }
-function isStatus(value) {
-    return typeof value === "string" && CHECK_RESUME_STATUSES.includes(value);
-}
 function isLocalStamp(value) {
     return (typeof value === "string" && CHECK_RESUME_LOCAL_STAMP.includes(value));
 }
-/** Validate a `plan.policy.checkResume` payload. */
+/** Validate a `plan.policy.checkResume` payload. Extra keys are ignored. */
 export function validateCheckResume(value) {
     if (value === null || value === undefined) {
         return [];
@@ -48,27 +32,16 @@ export function validateCheckResume(value) {
         return [`${FIELD_CHECK_RESUME} must be an object; got ${typeof value}`];
     }
     const rec = value;
-    const errors = [];
-    if ("status" in rec && !isStatus(rec.status)) {
-        errors.push(`${FIELD_CHECK_RESUME}.status must be one of ${CHECK_RESUME_STATUSES.join("|")}`);
-    }
     if ("localStamp" in rec && !isLocalStamp(rec.localStamp)) {
-        errors.push(`${FIELD_CHECK_RESUME}.localStamp must be one of ${CHECK_RESUME_LOCAL_STAMP.join("|")}`);
-    }
-    if ("ciTrustsLocalStamp" in rec && rec.ciTrustsLocalStamp !== false) {
-        errors.push(`${FIELD_CHECK_RESUME}.ciTrustsLocalStamp must be false in v1 (CI never trusts local stamps)`);
-    }
-    if ("dismissReason" in rec &&
-        rec.dismissReason !== null &&
-        typeof rec.dismissReason !== "string") {
-        errors.push(`${FIELD_CHECK_RESUME}.dismissReason must be a string or null`);
+        return [
+            `${FIELD_CHECK_RESUME}.localStamp must be one of ${CHECK_RESUME_LOCAL_STAMP.join("|")}`,
+        ];
     }
-    return errors;
+    return [];
 }
 /**
- * Resolve a typed block. Missing/invalid → localStamp off, status unset.
- * `ciTrustsLocalStamp` is always forced false regardless of input truthiness
- * (malformed non-false is validation error → fail-closed default).
+ * Resolve a typed block. Missing/invalid → localStamp off.
+ * Leftover ritual fields (status/dismissReason/ciTrustsLocalStamp) are ignored.
  */
 export function resolveCheckResumeFromTypedBlock(raw) {
     const errors = validateCheckResume(raw);
@@ -79,25 +52,16 @@ export function resolveCheckResumeFromTypedBlock(raw) {
         return defaultResolved("default");
     }
     const block = raw;
-    const status = isStatus(block.status) ? block.status : "unset";
-    const localStampRaw = isLocalStamp(block.localStamp)
+    const localStamp = isLocalStamp(block.localStamp)
         ? block.localStamp
         : DEFAULT_CHECK_RESUME_LOCAL_STAMP;
-    // Fail-closed: local stamp only when decided.
-    const localStamp = status === "decided" ? localStampRaw : DEFAULT_CHECK_RESUME_LOCAL_STAMP;
-    const dismissReason = typeof block.dismissReason === "string" && block.dismissReason.trim().length > 0
-        ? block.dismissReason.trim()
-        : null;
     return {
-        status,
         localStamp,
-        ciTrustsLocalStamp: CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1,
-        dismissReason: status === "decided" ? dismissReason : null,
         source: "typed",
         error: null,
     };
 }
-/** Resolve `plan.policy.checkResume` from PROJECT-DEFINITION (#3189). */
+/** Resolve `plan.policy.checkResume` from PROJECT-DEFINITION (#3314). */
 export function resolveCheckResume(projectRoot) {
     const [data, err] = loadProjectDefinition(projectRoot);
     if (data === null) {
@@ -112,33 +76,21 @@ export function resolveCheckResume(projectRoot) {
     }
     return resolveCheckResumeFromTypedBlock(policyBlock.checkResume);
 }
-/** Local suite stamp resume only when decided localStamp=on. */
+/** Local suite stamp resume only when localStamp=on. Reserved — unused by check/release. */
 export function isLocalStampResumeAllowed(policy) {
-    return policy.status === "decided" && policy.localStamp === "on";
-}
-/** Always false in v1 — CI must re-run suite, never trust a laptop stamp. */
-export function isCiTrustsLocalStampAllowed(_policy) {
-    return CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1;
+    return policy.localStamp === "on";
 }
 export function formatCheckResumeStatusLine(policy) {
-    const dismiss = policy.dismissReason !== null ? ` dismissReason=${JSON.stringify(policy.dismissReason)}` : "";
-    return (`[deft policy] checkResume status=${policy.status} localStamp=${policy.localStamp} ` +
-        `ciTrustsLocalStamp=${String(policy.ciTrustsLocalStamp)}${dismiss} (source=${policy.source}).`);
+    return (`[deft policy] checkResume localStamp=${policy.localStamp} ` + `(source=${policy.source}).`);
 }
 function fieldFromResolved(resolved) {
     return {
         name: FIELD_CHECK_RESUME,
         current: {
-            status: resolved.status,
             localStamp: resolved.localStamp,
-            ciTrustsLocalStamp: CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1,
-            dismissReason: resolved.dismissReason,
         },
         default: {
-            status: "unset",
             localStamp: DEFAULT_CHECK_RESUME_LOCAL_STAMP,
-            ciTrustsLocalStamp: CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1,
-            dismissReason: null,
         },
         source: resolved.source,
     };
@@ -160,94 +112,4 @@ export function inspectCheckResume(data, projectRoot) {
     }
     return fieldFromResolved(resolveCheckResumeFromTypedBlock(policyBlock.checkResume));
 }
-/** Persist decided checkResume (preset or dismiss-with-reason). */
-export function writeCheckResume(projectRoot, options) {
-    const path = projectDefinitionPath(projectRoot);
-    try {
-        const { changed } = projectDefinitionMutationLock(projectRoot, () => {
-            const parsed = JSON.parse(readFileSync(path, { encoding: "utf8" }));
-            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-                throw new Error(`PROJECT-DEFINITION at ${path} top-level value is not a JSON object`);
-            }
-            const data = parsed;
-            if (typeof data.plan !== "object" || data.plan === null || Array.isArray(data.plan)) {
-                if (data.plan === undefined) {
-                    data.plan = {};
-                }
-                else {
-                    throw new Error("PROJECT-DEFINITION 'plan' is not an object");
-                }
-            }
-            const plan = data.plan;
-            migrateLegacyPolicyKey(plan);
-            const existingPolicy = plan[PLAN_POLICY_KEY];
-            if (typeof existingPolicy !== "object" ||
-                existingPolicy === null ||
-                Array.isArray(existingPolicy)) {
-                if (existingPolicy === undefined) {
-                    plan[PLAN_POLICY_KEY] = {};
-                }
-                else {
-                    throw new Error("plan.policy is not an object");
-                }
-            }
-            const policyBlock = plan[PLAN_POLICY_KEY];
-            const previous = policyBlock.checkResume;
-            const dismissReason = typeof options.dismissReason === "string" && options.dismissReason.trim().length > 0
-                ? options.dismissReason.trim()
-                : null;
-            const nextBlock = {
-                status: "decided",
-                localStamp: options.localStamp,
-                ciTrustsLocalStamp: CHECK_RESUME_CI_TRUSTS_LOCAL_STAMP_V1,
-                dismissReason,
-            };
-            const previousNormalized = resolveCheckResumeFromTypedBlock(previous);
-            const changedFlag = previousNormalized.status !== nextBlock.status ||
-                previousNormalized.localStamp !== nextBlock.localStamp ||
-                previousNormalized.dismissReason !== nextBlock.dismissReason;
-            policyBlock.checkResume = nextBlock;
-            if (changedFlag) {
-                atomicWriteProjectDefinition(path, data);
-            }
-            const actor = options.actor ?? policyColonInvocation("set-check-resume");
-            const note = options.note ?? "";
-            const parts = [
-                `actor=${actor}`,
-                "checkResume.status=decided",
-                `localStamp=${nextBlock.localStamp}`,
-                "ciTrustsLocalStamp=false",
-                `dismissReason=${JSON.stringify(nextBlock.dismissReason)}`,
-                `previous=${JSON.stringify(previous ?? null)}`,
-            ];
-            if (note) {
-                parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
-            }
-            appendAuditLog(projectRoot, parts.join(" "));
-            return { changed: changedFlag };
-        });
-        const resolved = resolveCheckResume(projectRoot);
-        const lines = [
-            `\u2713 ${FIELD_CHECK_RESUME} status=decided localStamp=${resolved.localStamp}.`,
-            changed
-                ? "  audit: meta/policy-changes.log updated."
-                : "  no-op: value already matched (audit entry still appended for trail).",
-            formatCheckResumeStatusLine(resolved),
-        ];
-        return { exitCode: 0, stdout: `${lines.join("\n")}\n`, changed };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (message.includes("PROJECT-DEFINITION not found") ||
-            message.includes("ENOENT") ||
-            message.includes("no such file")) {
-            return {
-                exitCode: 2,
-                stdout: `\u274c PROJECT-DEFINITION not found under ${projectRoot}\n`,
-                changed: false,
-            };
-        }
-        return { exitCode: 2, stdout: `\u274c Config error: ${message}\n`, changed: false };
-    }
-}
 //# sourceMappingURL=check-resume.js.map

package/dist/policy/coverage-debt.d.ts

@@ -1,55 +1,43 @@
 /**
- * Coverage-debt hatch policy (#3189).
+ * Coverage-debt hatch policy (#3189 / #3314).
  *
- * Consent / SoT surface for consumer expansion of release-originated hatch
- * behavior (#3187). Unset is fail-closed for behavior (mode off) but still
- * nags on interactive session-start until decided or dismissed with reason.
- *
- * Non-goal: a consumer tree never auto-files coverage-debt issues on
- * deftai/directive -- ledger is always THIS repo.
+ * Plain optional setting. Default off. Fail-closed when absent or invalid.
+ * Hatch / auto-file are reserved — not a ship gate. Live hatch is
+ * `--allow-coverage-debt=#N` (#2866).
  */
+import { type CheckResumeResolved } from "./check-resume.js";
 /** Canonical registered policy field name. */
 export declare const FIELD_COVERAGE_DEBT = "plan.policy.coverageDebt";
 /** Short alias for `policy:show --field=coverageDebt`. */
 export declare const FIELD_COVERAGE_DEBT_CLI_ALIAS = "coverageDebt";
-export declare const COVERAGE_DEBT_STATUSES: readonly ["unset", "decided"];
-export type CoverageDebtStatus = (typeof COVERAGE_DEBT_STATUSES)[number];
 export declare const COVERAGE_DEBT_MODES: readonly ["off", "warn", "hatch"];
 export type CoverageDebtMode = (typeof COVERAGE_DEBT_MODES)[number];
-/** Fail-closed effective mode when unset / missing / invalid. */
+/** Fail-closed effective mode when absent / missing / invalid. */
 export declare const DEFAULT_COVERAGE_DEBT_MODE: CoverageDebtMode;
 /** Consumers default autoFile false even under hatch mode. */
 export declare const DEFAULT_COVERAGE_DEBT_AUTO_FILE = false;
 export interface CoverageDebtConfig {
-    readonly status: CoverageDebtStatus;
     readonly mode: CoverageDebtMode;
     readonly autoFile: boolean;
-    /** Present when decided via dismiss-with-reason (still visible to show/doctor). */
-    readonly dismissReason: string | null;
 }
 export type CoverageDebtSource = "typed" | "default" | "default-on-error";
 export interface CoverageDebtResolved extends CoverageDebtConfig {
     readonly source: CoverageDebtSource;
     readonly error: string | null;
 }
-/** Validate a `plan.policy.coverageDebt` payload. */
+/** Validate a `plan.policy.coverageDebt` payload. Extra keys are ignored. */
 export declare function validateCoverageDebt(value: unknown): string[];
 /**
- * Resolve a typed block. Missing/invalid → fail-closed mode off, status unset.
- * Unset is not the same as decided-off for nag purposes.
+ * Resolve a typed block. Missing/invalid → fail-closed mode off.
+ * `mode` is the setting; leftover ritual fields (status/dismissReason) are ignored.
  */
 export declare function resolveCoverageDebtFromTypedBlock(raw: unknown): CoverageDebtResolved;
-/** Resolve `plan.policy.coverageDebt` from PROJECT-DEFINITION (#3189). */
+/** Resolve `plan.policy.coverageDebt` from PROJECT-DEFINITION (#3314). */
 export declare function resolveCoverageDebt(projectRoot: string): CoverageDebtResolved;
-/** Effective hatch soft-pass allowed only when decided mode=hatch. */
+/** Effective hatch soft-pass allowed only when mode=hatch. Reserved — unused by check/release. */
 export declare function isCoverageDebtHatchAllowed(policy: CoverageDebtResolved): boolean;
 /** Auto-file debt issues only when hatch is allowed AND autoFile true. */
 export declare function isCoverageDebtAutoFileAllowed(policy: CoverageDebtResolved): boolean;
-/**
- * Non-goal guard (#3189): consumer trees never auto-file coverage-debt on
- * deftai/directive. Ledger is always the project under check.
- */
-export declare function coverageDebtLedgerRepoIsSelfOnly(): true;
 export declare function formatCoverageDebtStatusLine(policy: CoverageDebtResolved): string;
 export interface CoverageDebtPolicyField {
     readonly name: typeof FIELD_COVERAGE_DEBT;
@@ -59,18 +47,11 @@ export interface CoverageDebtPolicyField {
 }
 /** Inspector row for `policy:show --field=coverageDebt`. */
 export declare function inspectCoverageDebt(data: Record<string, unknown> | null, projectRoot?: string): CoverageDebtPolicyField;
-export interface WriteCoverageDebtOptions {
-    readonly mode: CoverageDebtMode;
-    readonly autoFile?: boolean;
-    readonly dismissReason?: string | null;
-    readonly actor?: string;
-    readonly note?: string;
-}
-export interface WriteCoverageDebtResult {
-    readonly exitCode: 0 | 2;
-    readonly stdout: string;
-    readonly changed: boolean;
-}
-/** Persist decided coverageDebt (preset or dismiss-with-reason). */
-export declare function writeCoverageDebt(projectRoot: string, options: WriteCoverageDebtOptions): WriteCoverageDebtResult;
+/**
+ * One-line standing disclosure when either setting is non-default (#3314).
+ * Silent when both default / invalid (invalid is fail-closed off).
+ */
+export declare function coverageCheckResumeDisclosureLine(debt: CoverageDebtResolved, resume: Pick<CheckResumeResolved, "localStamp" | "source">): string | null;
+/** Resolve both settings and format the standing disclosure, or null. */
+export declare function maybeFormatCoverageCheckResumeDisclosure(projectRoot: string): string | null;
 //# sourceMappingURL=coverage-debt.d.ts.map