@deftai/directive-core 0.100.0 → 0.102.0

package/dist/policy/ac-pass-banking.js

@@ -0,0 +1,150 @@
+/**
+ * Typed plan.policy.acPassBanking (#3285).
+ *
+ * Surplus-threshold policy for post-AC-pass deepening: after the first
+ * stated-AC bank, agents may deepen only when remaining budget is at least
+ * this fraction of the hard max (default 0.2 = 20%).
+ *
+ * Composes #3266 bank-the-pass and product-first done-gate (#3284).
+ */
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+/** Canonical dotted path for policy:show / PROJECT-DEFINITION. */
+export const FIELD_AC_PASS_BANKING = "plan.policy.acPassBanking";
+/** CLI alias for `task policy:show --field=acPassBanking`. */
+export const FIELD_AC_PASS_BANKING_CLI_ALIAS = "acPassBanking";
+/**
+ * Default surplus fraction of max turns/cost that must remain after bank
+ * before self-imposed deepening is allowed (#3285).
+ */
+export const DEFAULT_SURPLUS_THRESHOLD = 0.2;
+/** Floor / ceiling for surplusThreshold (inclusive). */
+export const SURPLUS_THRESHOLD_MIN = 0;
+export const SURPLUS_THRESHOLD_MAX = 1;
+/** Optional env override (fraction 0–1 or percent 0–100). */
+export const ENV_SURPLUS_THRESHOLD = "DEFT_AC_PASS_SURPLUS_THRESHOLD";
+function defaultResolved(source, error = null, override) {
+    return {
+        enabled: override?.enabled ?? true,
+        surplusThreshold: override?.surplusThreshold ?? DEFAULT_SURPLUS_THRESHOLD,
+        source,
+        error,
+    };
+}
+/** Parse a 0–1 fraction or a 0–100 percent string/number into a fraction. */
+export function parseSurplusThreshold(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        if (raw >= 0 && raw <= 1)
+            return raw;
+        // Allow 20 meaning 20% when clearly a percent.
+        if (raw > 1 && raw <= 100)
+            return raw / 100;
+        return null;
+    }
+    if (typeof raw === "string") {
+        const text = raw.trim();
+        if (!text)
+            return null;
+        const percent = text.endsWith("%");
+        const n = Number(percent ? text.slice(0, -1).trim() : text);
+        if (!Number.isFinite(n))
+            return null;
+        if (percent) {
+            if (n < 0 || n > 100)
+                return null;
+            return n / 100;
+        }
+        if (n >= 0 && n <= 1)
+            return n;
+        if (n > 1 && n <= 100)
+            return n / 100;
+        return null;
+    }
+    return null;
+}
+/** Validate a `plan.policy.acPassBanking` payload. */
+export function validateAcPassBanking(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_AC_PASS_BANKING} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    if ("enabled" in rec && typeof rec.enabled !== "boolean") {
+        errors.push(`${FIELD_AC_PASS_BANKING}.enabled must be a boolean`);
+    }
+    if ("surplusThreshold" in rec) {
+        const parsed = parseSurplusThreshold(rec.surplusThreshold);
+        if (parsed === null) {
+            errors.push(`${FIELD_AC_PASS_BANKING}.surplusThreshold must be a fraction 0–1 ` +
+                `(or percent 0–100); got ${JSON.stringify(rec.surplusThreshold)}`);
+        }
+    }
+    return errors;
+}
+/**
+ * Resolve surplus policy from typed plan.policy.acPassBanking, then env,
+ * then defaults (#3285).
+ */
+export function resolveAcPassBanking(projectRoot, environ = process.env) {
+    if (projectRoot !== undefined && projectRoot !== null && projectRoot.length > 0) {
+        const [data, err] = loadProjectDefinition(projectRoot);
+        if (data !== null) {
+            const policyBlock = readPlanPolicy(data.plan);
+            if (typeof policyBlock === "object" &&
+                policyBlock !== null &&
+                !Array.isArray(policyBlock) &&
+                "acPassBanking" in policyBlock) {
+                const raw = policyBlock.acPassBanking;
+                const errors = validateAcPassBanking(raw);
+                if (errors.length > 0) {
+                    return defaultResolved("default-on-error", errors[0] ?? "invalid acPassBanking");
+                }
+                if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+                    const rec = raw;
+                    const enabled = typeof rec.enabled === "boolean" ? rec.enabled : true;
+                    const threshold = "surplusThreshold" in rec
+                        ? (parseSurplusThreshold(rec.surplusThreshold) ?? DEFAULT_SURPLUS_THRESHOLD)
+                        : DEFAULT_SURPLUS_THRESHOLD;
+                    return {
+                        enabled,
+                        surplusThreshold: threshold,
+                        source: "typed",
+                        error: null,
+                    };
+                }
+            }
+        }
+        else if (err !== null && err.length > 0) {
+            // Fall through to env/default; record nothing as fatal.
+        }
+    }
+    const envRaw = environ[ENV_SURPLUS_THRESHOLD];
+    if (envRaw !== undefined && envRaw.trim() !== "") {
+        const parsed = parseSurplusThreshold(envRaw);
+        if (parsed !== null) {
+            return defaultResolved("env", null, { surplusThreshold: parsed });
+        }
+        return defaultResolved("default-on-error", `${ENV_SURPLUS_THRESHOLD} is not a valid fraction/percent: ${envRaw}`);
+    }
+    return defaultResolved("default");
+}
+/** Inspector row for `task policy:show --field=acPassBanking` (#3285). */
+export function inspectAcPassBanking(_data, projectRoot) {
+    const resolved = resolveAcPassBanking(projectRoot);
+    return {
+        name: FIELD_AC_PASS_BANKING,
+        current: {
+            enabled: resolved.enabled,
+            surplusThreshold: resolved.surplusThreshold,
+        },
+        default: {
+            enabled: true,
+            surplusThreshold: DEFAULT_SURPLUS_THRESHOLD,
+        },
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=ac-pass-banking.js.map

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

@@ -0,0 +1,52 @@
+/**
+ * Ceremony-dial escalation evaluation + start-tier provenance (#3319).
+ *
+ * Observability only: does not change escalate-on-evidence thresholds or the
+ * default start tier. A declined evaluation is distinct from never-evaluated.
+ */
+import type { DialEscalationEvaluationOutcome } from "../run-summary/types.js";
+import { type CeremonyDepth, type CeremonyDialInputs, type CeremonyDialSelection, type CeremonyModelTier } from "./ceremony-dial.js";
+export declare const CEREMONY_START_TIER_PROVENANCES: readonly ["cold-start", "external-pin", "operator"];
+export type CeremonyStartTierProvenance = (typeof CEREMONY_START_TIER_PROVENANCES)[number];
+export declare const CEREMONY_DEPTH_RANK: Readonly<Record<CeremonyDepth, number>>;
+export interface ResolveCeremonyStartTierProvenanceInput {
+    readonly selection: CeremonyDialSelection;
+    /** True when session:start received a pre-resolved selection (CLI/harness). */
+    readonly injectedSelection: boolean;
+    readonly hint?: CeremonyStartTierProvenance;
+}
+export declare function resolveCeremonyStartTierProvenance(input: ResolveCeremonyStartTierProvenanceInput): CeremonyStartTierProvenance;
+export declare function isCeremonyStartTierPinned(provenance: CeremonyStartTierProvenance): boolean;
+/** Session-start fail-closed line when a pin bypasses #3274 cold-start selection. */
+export declare function formatCeremonyDialPinBypassLine(provenance: CeremonyStartTierProvenance): string | null;
+export interface CeremonyDialEscalationEvaluation {
+    readonly tier: CeremonyDepth;
+    readonly outcome: DialEscalationEvaluationOutcome;
+    readonly reason: string;
+    readonly from: CeremonyDepth;
+    readonly to: CeremonyDepth;
+}
+export interface EvaluateCeremonyDialEscalationInput {
+    readonly from: CeremonyDepth;
+    readonly to: CeremonyDepth;
+    readonly inputs?: CeremonyDialInputs;
+}
+/**
+ * Pure escalate-on-evidence evaluation. `to > from` → escalated; else declined.
+ * Does not persist a transition.
+ */
+export declare function evaluateCeremonyDialEscalation(input: EvaluateCeremonyDialEscalationInput): CeremonyDialEscalationEvaluation;
+/** Cold-start vs selected depth at session:start (unpinned path only). */
+export declare function evaluateSessionStartCeremonyDialEscalation(input: {
+    readonly selection: CeremonyDialSelection;
+    readonly modelTier?: CeremonyModelTier | null;
+}): CeremonyDialEscalationEvaluation;
+export interface EmitCeremonyDialEscalationEvaluationOptions {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly evaluation: CeremonyDialEscalationEvaluation;
+}
+/** Fail-open emit of a #3319 evaluation event. */
+export declare function emitCeremonyDialEscalationEvaluation(options: EmitCeremonyDialEscalationEvaluationOptions): void;
+//# sourceMappingURL=ceremony-dial-escalation.d.ts.map

package/dist/policy/ceremony-dial-escalation.js

@@ -0,0 +1,92 @@
+/**
+ * Ceremony-dial escalation evaluation + start-tier provenance (#3319).
+ *
+ * Observability only: does not change escalate-on-evidence thresholds or the
+ * default start tier. A declined evaluation is distinct from never-evaluated.
+ */
+import { RunSummaryEmitter } from "../run-summary/emit.js";
+import { selectCeremonyColdStartDepth, } from "./ceremony-dial.js";
+export const CEREMONY_START_TIER_PROVENANCES = ["cold-start", "external-pin", "operator"];
+export const CEREMONY_DEPTH_RANK = {
+    minimal: 0,
+    rapid: 1,
+    standard: 2,
+    elevated: 3,
+};
+export function resolveCeremonyStartTierProvenance(input) {
+    if (input.hint !== undefined) {
+        return input.hint;
+    }
+    if (input.selection.source === "override") {
+        return input.injectedSelection ? "external-pin" : "operator";
+    }
+    return "cold-start";
+}
+export function isCeremonyStartTierPinned(provenance) {
+    return provenance === "external-pin" || provenance === "operator";
+}
+/** Session-start fail-closed line when a pin bypasses #3274 cold-start selection. */
+export function formatCeremonyDialPinBypassLine(provenance) {
+    if (!isCeremonyStartTierPinned(provenance)) {
+        return null;
+    }
+    const pinLabel = provenance === "external-pin" ? "external-pin" : "operator pin";
+    return (`[deft ceremony-dial] #3274 cold-start selection is bypassed (${pinLabel}). ` +
+        "Unset the pin (--ceremony-depth or plan.policy.ceremonyDial.override) to exercise #3274.");
+}
+/**
+ * Pure escalate-on-evidence evaluation. `to > from` → escalated; else declined.
+ * Does not persist a transition.
+ */
+export function evaluateCeremonyDialEscalation(input) {
+    const size = input.inputs?.taskSize ?? null;
+    const modelTier = input.inputs?.modelTier ?? null;
+    const evidence = `size=${size ?? "-"} modelTier=${modelTier ?? "-"}`;
+    const raised = CEREMONY_DEPTH_RANK[input.to] > CEREMONY_DEPTH_RANK[input.from];
+    if (raised) {
+        return {
+            tier: input.to,
+            outcome: "escalated",
+            reason: `evidence raised ${input.from} -> ${input.to} (${evidence})`,
+            from: input.from,
+            to: input.to,
+        };
+    }
+    return {
+        tier: input.from,
+        outcome: "declined",
+        reason: `insufficient evidence to raise above ${input.from} (${evidence})`,
+        from: input.from,
+        to: input.to,
+    };
+}
+/** Cold-start vs selected depth at session:start (unpinned path only). */
+export function evaluateSessionStartCeremonyDialEscalation(input) {
+    const modelTier = input.modelTier ?? input.selection.inputs.modelTier;
+    const from = selectCeremonyColdStartDepth(modelTier);
+    return evaluateCeremonyDialEscalation({
+        from,
+        to: input.selection.depth,
+        inputs: input.selection.inputs,
+    });
+}
+/** Fail-open emit of a #3319 evaluation event. */
+export function emitCeremonyDialEscalationEvaluation(options) {
+    try {
+        const emitter = new RunSummaryEmitter({
+            projectRoot: options.projectRoot,
+            sessionId: options.sessionId,
+            env: options.env,
+        });
+        emitter.emitDialEscalationEvaluation({
+            tier: options.evaluation.tier,
+            outcome: options.evaluation.outcome,
+            reason: options.evaluation.reason,
+        });
+        emitter.emitKnownToolTurnDenominator();
+    }
+    catch {
+        // fail-open
+    }
+}
+//# sourceMappingURL=ceremony-dial-escalation.js.map

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

@@ -161,7 +161,9 @@ export interface ResolveCeremonyDialOptions {
  */
 export declare function resolveCeremonyDial(projectRoot: string, options?: ResolveCeremonyDialOptions): CeremonyDialSelection;
 /** Human-readable status line for session:start / policy:show. */
-export declare function formatCeremonyDialStatusLine(selection: CeremonyDialSelection): string;
+export declare function formatCeremonyDialStatusLine(selection: CeremonyDialSelection, extras?: {
+    readonly startTierProvenance?: string;
+}): string;
 /** JSON-serializable dial snapshot for ritual-state / session payload. */
 export declare function ceremonyDialToDict(selection: CeremonyDialSelection): Record<string, unknown>;
 export interface CeremonyDialPolicyField {
@@ -286,4 +288,33 @@ export interface CeremonyDialAuditSnapshot {
 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

@@ -19,6 +19,7 @@
  */
 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";
@@ -400,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}`,
@@ -408,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}`);
     }
@@ -977,4 +982,126 @@ export function formatCeremonyDialAuditLine(audit) {
     }
     return parts.join(" ");
 }
+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,
+            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) {
+        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,
+            to: options.to,
+            changed: false,
+            lines: setResult.stdout
+                .split("\n")
+                .map((l) => l.trimEnd())
+                .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 {
+            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,
+            });
+            emitter.emitKnownToolTurnDenominator();
+        }
+        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/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