@deftai/directive-core 0.101.0 → 0.103.0

package/dist/run-summary/share.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Ritual+gate share from a #3282 run-summary stream (#3320).
+ *
+ * Share is ritual+gate invocations over the emitted tool/turn denominator.
+ * Absence of the denominator is unevaluable — never invent a share from counts.
+ */
+import { type RunSummaryLine } from "./types.js";
+export interface RitualGateShare {
+    readonly evaluable: boolean;
+    readonly ritualGateCount: number;
+    readonly totalToolTurns: number | null;
+    readonly share: number | null;
+}
+/** True when n is a finite integer usable as a share denominator. */
+export declare function isValidToolTurnDenominator(value: unknown): value is number;
+/** Read total_tool_turns from a line (top-level field or payload). */
+export declare function readToolTurnDenominator(line: unknown): number | undefined;
+/** Parse JSONL (or DEFT-TLM: prefixed stdout capture) into run-summary lines. */
+export declare function parseRunSummaryJsonl(text: string): RunSummaryLine[];
+/**
+ * Compute ritual+gate share from summary lines alone.
+ * Uses the latest session in the stream. Missing/invalid denominator → unevaluable.
+ */
+export declare function computeRitualGateShare(lines: readonly RunSummaryLine[]): RitualGateShare;
+//# sourceMappingURL=share.d.ts.map

package/dist/run-summary/share.js

@@ -0,0 +1,106 @@
+/**
+ * Ritual+gate share from a #3282 run-summary stream (#3320).
+ *
+ * Share is ritual+gate invocations over the emitted tool/turn denominator.
+ * Absence of the denominator is unevaluable — never invent a share from counts.
+ */
+import { RUN_SUMMARY_STDOUT_PREFIX } from "./types.js";
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+/** True when n is a finite integer usable as a share denominator. */
+export function isValidToolTurnDenominator(value) {
+    return (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value > 0);
+}
+/** Read total_tool_turns from a line (top-level field or payload). */
+export function readToolTurnDenominator(line) {
+    const rec = asRecord(line);
+    if (rec === null) {
+        return undefined;
+    }
+    if (isValidToolTurnDenominator(rec.total_tool_turns)) {
+        return rec.total_tool_turns;
+    }
+    const payload = asRecord(rec.payload);
+    if (payload !== null && isValidToolTurnDenominator(payload.total_tool_turns)) {
+        return payload.total_tool_turns;
+    }
+    return undefined;
+}
+function parseLine(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const body = trimmed.startsWith(RUN_SUMMARY_STDOUT_PREFIX)
+        ? trimmed.slice(RUN_SUMMARY_STDOUT_PREFIX.length)
+        : trimmed;
+    try {
+        const parsed = JSON.parse(body);
+        const rec = asRecord(parsed);
+        if (rec === null) {
+            return null;
+        }
+        if (typeof rec.event !== "string" || typeof rec.session_id !== "string") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse JSONL (or DEFT-TLM: prefixed stdout capture) into run-summary lines. */
+export function parseRunSummaryJsonl(text) {
+    const lines = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const line = parseLine(raw);
+        if (line !== null) {
+            lines.push(line);
+        }
+    }
+    return lines;
+}
+function lastSessionId(lines) {
+    let lastStart = null;
+    let lastAny = null;
+    for (const line of lines) {
+        lastAny = line.session_id;
+        if (line.event === "session_start") {
+            lastStart = line.session_id;
+        }
+    }
+    return lastStart ?? lastAny;
+}
+/**
+ * Compute ritual+gate share from summary lines alone.
+ * Uses the latest session in the stream. Missing/invalid denominator → unevaluable.
+ */
+export function computeRitualGateShare(lines) {
+    const sessionId = lastSessionId(lines);
+    const sessionLines = sessionId === null ? [] : lines.filter((line) => line.session_id === sessionId);
+    let ritualGateCount = 0;
+    let totalToolTurns = null;
+    for (const line of sessionLines) {
+        if (line.event === "check_invocation") {
+            ritualGateCount += 1;
+        }
+        const denom = readToolTurnDenominator(line);
+        if (denom !== undefined) {
+            totalToolTurns = denom;
+        }
+    }
+    if (totalToolTurns === null) {
+        return { evaluable: false, ritualGateCount, totalToolTurns: null, share: null };
+    }
+    return {
+        evaluable: true,
+        ritualGateCount,
+        totalToolTurns,
+        share: ritualGateCount / totalToolTurns,
+    };
+}
+//# sourceMappingURL=share.js.map

package/dist/run-summary/types.d.ts

@@ -7,13 +7,15 @@
 export declare const RUN_SUMMARY_SCHEMA_VERSION: 1;
 /** Env var that opts into / redirects run-summary JSONL (#3282). */
 export declare const ENV_RUN_SUMMARY_PATH = "DEFT_RUN_SUMMARY_PATH";
+/** Harness-supplied session tool/turn total stamped onto run-summary lines (#3320). */
+export declare const ENV_TOTAL_TOOL_TURNS = "DEFT_TOTAL_TOOL_TURNS";
 /** Repo-root default collectible path when gitignore coverage is present. */
 export declare const DEFAULT_RUN_SUMMARY_BASENAME = ".deft-run-summary.json";
 /** Prefix for stdout lines when `DEFT_RUN_SUMMARY_PATH=-`. */
 export declare const RUN_SUMMARY_STDOUT_PREFIX = "DEFT-TLM:";
 /** One warning when an explicitly requested write fails. */
 export declare const RUN_SUMMARY_WRITE_WARNING = "[deft run-summary] failed to write DEFT_RUN_SUMMARY_PATH telemetry (fail-open; exit codes unchanged)";
-export declare const RUN_SUMMARY_EVENT_KINDS: readonly ["session_start", "dial_transition", "check_invocation"];
+export declare const RUN_SUMMARY_EVENT_KINDS: readonly ["session_start", "dial_transition", "dial_escalation_evaluation", "check_invocation", "tool_turn_denominator", "verification", "acceptance", "acceptance_stamp"];
 export type RunSummaryEventKind = (typeof RUN_SUMMARY_EVENT_KINDS)[number];
 export interface RunSummaryBaseFields {
     readonly schema_version: typeof RUN_SUMMARY_SCHEMA_VERSION;
@@ -23,6 +25,11 @@ export interface RunSummaryBaseFields {
     readonly seq: number;
     readonly ts: string;
     readonly event: RunSummaryEventKind;
+    /**
+     * Session total tool/turn count (#3320). Present so ritual+gate share is
+     * computable from the summary alone. Absence means the #3286 trigger is unevaluable.
+     */
+    readonly total_tool_turns?: number;
 }
 export interface SessionStartRunSummaryPayload {
     readonly ceremony_dial?: Record<string, unknown>;
@@ -43,6 +50,14 @@ export interface DialTransitionRunSummaryPayload {
     readonly reason: string;
     readonly evidence?: string;
 }
+/** One evaluation of escalate-on-evidence (#3319). Absence of this event ≠ declined. */
+export type DialEscalationEvaluationOutcome = "escalated" | "declined";
+export interface DialEscalationEvaluationRunSummaryPayload {
+    /** Ceremony depth considered (the start/current tier under evaluation). */
+    readonly tier: string;
+    readonly outcome: DialEscalationEvaluationOutcome;
+    readonly reason: string;
+}
 export interface CheckGateOutcome {
     readonly id: string;
     readonly status: "run" | "skipped" | "failed";
@@ -51,13 +66,56 @@ export interface CheckGateOutcome {
     readonly remedy?: string;
     readonly from_cache?: boolean;
 }
+/** Per-clause coverage row carried on verify:ac telemetry (#3323). */
+export interface AcceptanceClauseOutcomeRow {
+    readonly id: number;
+    readonly outcome: "verified" | "unverifiable" | "failed";
+}
 export interface CheckInvocationRunSummaryPayload {
     readonly target: string;
     readonly exit_code: number;
     readonly degraded?: boolean;
     readonly gates: readonly CheckGateOutcome[];
+    /** Additive verify:ac fields (#3323). Consumers ignore unknown keys. */
+    readonly source_rung?: string;
+    readonly none_stated?: boolean;
+    readonly clause_outcomes?: readonly AcceptanceClauseOutcomeRow[];
+}
+/** Total tool/turn count for the session (#3320). */
+export interface ToolTurnDenominatorRunSummaryPayload {
+    readonly total_tool_turns: number;
+}
+/** Product-oracle attempt (#3322). Same emitter as #3319 / #3320. */
+export type VerificationOutcome = "pass" | "fail";
+/** verify:ac resolution telemetry (#3334). Distinct from verification pass/fail. */
+export type AcceptanceRunSummaryOutcome = "verified-pass" | "empty-pass" | "soft_empty" | "fail";
+export interface AcceptanceRunSummaryPayload {
+    readonly resolved_command_count: number;
+    readonly outcome: AcceptanceRunSummaryOutcome;
+    readonly source_rung?: string;
+    readonly none_stated?: boolean;
+    readonly clause_count?: number;
+    readonly clause_outcomes?: readonly AcceptanceClauseOutcomeRow[];
+}
+/** Intake-time stamp: which rung locked, whether commands were stated, counts (#3323). */
+export interface AcceptanceStampRunSummaryPayload {
+    readonly rung: string;
+    readonly none_stated: boolean;
+    readonly command_count: number;
+    readonly clause_count: number;
+}
+export interface VerificationRunSummaryPayload {
+    readonly check_id: string;
+    readonly method_fingerprint: string;
+    readonly outcome: VerificationOutcome;
+    /**
+     * True when both sides of the comparison were rebuilt from scratch by a
+     * different method than the one that failed. Required to resolve
+     * fail → method-change → pass (#3322).
+     */
+    readonly independent_rederivation?: boolean;
 }
-export type RunSummaryPayload = SessionStartRunSummaryPayload | DialTransitionRunSummaryPayload | CheckInvocationRunSummaryPayload;
+export type RunSummaryPayload = SessionStartRunSummaryPayload | DialTransitionRunSummaryPayload | DialEscalationEvaluationRunSummaryPayload | CheckInvocationRunSummaryPayload | ToolTurnDenominatorRunSummaryPayload | VerificationRunSummaryPayload | AcceptanceRunSummaryPayload | AcceptanceStampRunSummaryPayload;
 export type RunSummaryLine = RunSummaryBaseFields & {
     readonly payload: RunSummaryPayload;
 };

package/dist/run-summary/types.js

@@ -7,6 +7,8 @@
 export const RUN_SUMMARY_SCHEMA_VERSION = 1;
 /** Env var that opts into / redirects run-summary JSONL (#3282). */
 export const ENV_RUN_SUMMARY_PATH = "DEFT_RUN_SUMMARY_PATH";
+/** Harness-supplied session tool/turn total stamped onto run-summary lines (#3320). */
+export const ENV_TOTAL_TOOL_TURNS = "DEFT_TOTAL_TOOL_TURNS";
 /** Repo-root default collectible path when gitignore coverage is present. */
 export const DEFAULT_RUN_SUMMARY_BASENAME = ".deft-run-summary.json";
 /** Prefix for stdout lines when `DEFT_RUN_SUMMARY_PATH=-`. */
@@ -16,6 +18,11 @@ export const RUN_SUMMARY_WRITE_WARNING = "[deft run-summary] failed to write DEF
 export const RUN_SUMMARY_EVENT_KINDS = [
     "session_start",
     "dial_transition",
+    "dial_escalation_evaluation",
     "check_invocation",
+    "tool_turn_denominator",
+    "verification",
+    "acceptance",
+    "acceptance_stamp",
 ];
 //# sourceMappingURL=types.js.map

package/dist/scope/acceptance-activate-gate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * scope:activate refuses acceptance-shaped narratives without plan.acceptance (#3334).
+ *
+ * Agents author Test / AcceptanceCriteria / Verification prose in narratives
+ * and then skip the executable plan.acceptance block. Activation fails closed
+ * with one remediation: stamp the acceptance block.
+ */
+export interface AcceptanceActivateHit {
+    readonly key: string;
+}
+export interface AcceptanceActivateGateResult {
+    readonly ok: boolean;
+    readonly message: string;
+    readonly hits: readonly AcceptanceActivateHit[];
+}
+/** Narrative keys that look like authored acceptance (non-empty string values). */
+export declare function collectAcceptanceShapedNarrativeKeys(narratives: Record<string, unknown>): AcceptanceActivateHit[];
+/**
+ * Fail closed when narratives carry acceptance-shaped keys and plan.acceptance
+ * is absent. A stamped (even empty/none_stated) block is enough.
+ */
+export declare function evaluateAcceptanceActivateGate(plan: Record<string, unknown>): AcceptanceActivateGateResult;
+//# sourceMappingURL=acceptance-activate-gate.d.ts.map

package/dist/scope/acceptance-activate-gate.js

@@ -0,0 +1,70 @@
+/**
+ * scope:activate refuses acceptance-shaped narratives without plan.acceptance (#3334).
+ *
+ * Agents author Test / AcceptanceCriteria / Verification prose in narratives
+ * and then skip the executable plan.acceptance block. Activation fails closed
+ * with one remediation: stamp the acceptance block.
+ */
+import { validatePlanAcceptance } from "../product-first-done-gate/acceptance.js";
+function asRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+const ACCEPTANCE_SHAPED_KEYS = new Set(["test", "acceptancecriteria", "verification"]);
+function normalizeNarrativeKey(key) {
+    return key.replace(/[\s_-]+/g, "").toLowerCase();
+}
+/** Narrative keys that look like authored acceptance (non-empty string values). */
+export function collectAcceptanceShapedNarrativeKeys(narratives) {
+    const hits = [];
+    for (const key of Object.keys(narratives)) {
+        if (!ACCEPTANCE_SHAPED_KEYS.has(normalizeNarrativeKey(key))) {
+            continue;
+        }
+        const value = narratives[key];
+        if (typeof value !== "string" || value.trim().length === 0) {
+            continue;
+        }
+        hits.push({ key });
+    }
+    return hits;
+}
+/**
+ * Fail closed when narratives carry acceptance-shaped keys and plan.acceptance
+ * is absent. A stamped (even empty/none_stated) block is enough.
+ */
+export function evaluateAcceptanceActivateGate(plan) {
+    const narratives = asRecord(plan.narratives);
+    if (narratives === null) {
+        return { ok: true, message: "", hits: [] };
+    }
+    const hits = collectAcceptanceShapedNarrativeKeys(narratives);
+    if (hits.length === 0) {
+        return { ok: true, message: "", hits: [] };
+    }
+    if (plan.acceptance !== undefined && plan.acceptance !== null) {
+        const schemaErrors = validatePlanAcceptance(plan.acceptance);
+        if (schemaErrors.length > 0) {
+            return {
+                ok: false,
+                message: `Refusing activate: plan.acceptance is present but invalid (#3334): ` +
+                    `${schemaErrors.join("; ")}. Stamp a valid plan.acceptance block ` +
+                    `(author commands or none_stated via intake capture / task issue:ingest).`,
+                hits,
+            };
+        }
+        return { ok: true, message: "", hits };
+    }
+    const keys = hits.map((h) => h.key).join(", ");
+    return {
+        ok: false,
+        message: `Refusing activate: narratives contain acceptance-shaped keys (${keys}) ` +
+            `but plan.acceptance is absent (#3334). Stamp plan.acceptance ` +
+            `(author commands or none_stated via intake capture / task issue:ingest) — ` +
+            `the criteria are in the wrong, non-executable field.`,
+        hits,
+    };
+}
+//# sourceMappingURL=acceptance-activate-gate.js.map

package/dist/scope/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./acceptance-activate-gate.js";
 export * from "./acceptance-evidence.js";
 export * from "./audit-log.js";
 export * from "./batch-promote.js";

package/dist/scope/index.js

@@ -1,3 +1,4 @@
+export * from "./acceptance-activate-gate.js";
 export * from "./acceptance-evidence.js";
 export * from "./audit-log.js";
 export * from "./batch-promote.js";

package/dist/scope/transition.js

@@ -5,6 +5,7 @@ import { assertProjectionContained, ProjectionContainmentError, } from "../fs/pr
 import { hasArtifactSuffix } from "../layout/resolve.js";
 import { evaluateCompletedPlanConsistency } from "../lifecycle/completed-consistency.js";
 import { evaluateLiteralAcceptanceFromPlan } from "../literal-acceptance/index.js";
+import { evaluateAcceptanceActivateGate } from "./acceptance-activate-gate.js";
 import { evaluateAcceptanceEvidenceGate, formatAcceptanceCompletionListing, } from "./acceptance-evidence.js";
 import { append, canonicalLogPath, newDecisionId } from "./audit-log.js";
 import { atomicWriteBrief, formatBriefJson, readBriefForMutation } from "./brief-io.js";
@@ -148,6 +149,10 @@ export function runTransition(action, filePath, now = new Date(), options = {})
         if (!effortGate.ok) {
             return { ok: false, message: effortGate.message };
         }
+        const acceptanceGate = evaluateAcceptanceActivateGate(planObj);
+        if (!acceptanceGate.ok) {
+            return { ok: false, message: acceptanceGate.message };
+        }
     }
     // #3041: fail closed before mutating a code-bearing complete without delivery evidence.
     if (act === "complete") {

package/dist/session/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./ac-pass-banking.js";
 export * from "./active-cli.js";
 export * from "./compact-ritual.js";
-export * from "./coverage-check-resume-nudge.js";
 export * from "./deposit-sha.js";
 export * from "./effort-budget.js";
 export * from "./git.js";

package/dist/session/index.js

@@ -1,7 +1,6 @@
 export * from "./ac-pass-banking.js";
 export * from "./active-cli.js";
 export * from "./compact-ritual.js";
-export * from "./coverage-check-resume-nudge.js";
 export * from "./deposit-sha.js";
 export * from "./effort-budget.js";
 export * from "./git.js";

package/dist/session/orientation-compression.js

@@ -6,6 +6,7 @@
  * agents:refresh and verify:cache-fresh; formats compact (opt-in) vs verbose
  * (default). Does NOT implement unified `deft orient` (Later remains open).
  */
+import { isFrameworkRepoRoot } from "../check/context.js";
 import { decideThrottle, readState as readDoctorState, renderDoctorStatusLine, } from "../doctor/doctor-state.js";
 import { cmdDoctor } from "../doctor/main.js";
 import { applyAgentsRefresh } from "../platform/agents-md.js";
@@ -271,16 +272,23 @@ export function runCacheFreshOrientationSection(projectRoot, options) {
     void options.now;
     try {
         const evaluate = options.evaluateFn ?? evaluateCacheFresh;
-        // #3286 Greptile: do not treat missing cache/candidates as a successful
-        // cache-fresh for orientation / gated_steps (bootstrap must not look green).
-        // Session:start still continues; gated verify will re-run cache_fresh when
-        // ok is false.
+        const consumerDeposit = !isFrameworkRepoRoot(projectRoot);
+        // Consumer deposits often have no triage cache. Treat that as a named
+        // bootstrap cause (dirty), never a generic orientation `error` (#3335).
+        // Framework source still evaluates live; missing cache stays non-green
+        // (#3286) so gated verify re-runs cache_fresh.
         const result = evaluate(projectRoot, {
             allowMissingBootstrap: false,
             autoPopulateEmpty: false,
             ...options.evaluateOptions,
         });
         const ok = result.code === 0;
+        const missingCache = result.code === 2 && /not found|bootstrap/i.test(result.message);
+        const namedCause = missingCache
+            ? consumerDeposit
+                ? `[deft cache-fresh] triage cache not populated (consumer deposit) — not a toolchain failure. Recovery: run \`deft triage:bootstrap\` if you need the queue.`
+                : result.message
+            : result.message;
         // Tag as sha_match only when message already uses the canonical phrase
         // (e.g. tests inject it) — never invent a shortcut past evaluate.
         const shaMatch = ok && result.message.includes(DEPOSIT_SHA_MATCH_NOOP);
@@ -288,19 +296,21 @@ export function runCacheFreshOrientationSection(projectRoot, options) {
             ? "sha_match"
             : ok
                 ? "ok"
-                : result.code === 2
-                    ? "error"
-                    : "dirty";
+                : missingCache
+                    ? "dirty"
+                    : result.code === 2
+                        ? "error"
+                        : "dirty";
         return {
             name: "cache_fresh",
             status,
             ok,
             exitCode: result.code,
-            lines: [result.message],
+            lines: [namedCause],
             shaMatch,
             depositSha: options.depositSha,
             durationMs: elapsedMs(started),
-            detail: { code: result.code },
+            detail: { code: result.code, missing_cache: missingCache },
         };
     }
     catch (exc) {

package/dist/session/session-start.d.ts

@@ -1,6 +1,7 @@
 import { type HostContentSurfaceSeams } from "../platform/host-content-surface.js";
 import { type EnvironmentContext } from "../platform/shell-context.js";
 import { type CeremonyDialInputs, type CeremonyDialSelection, type ProvisionalCeremonyEstimateHints } from "../policy/ceremony-dial.js";
+import { type CeremonyStartTierProvenance } from "../policy/ceremony-dial-escalation.js";
 import { type ProbeScmReadinessOptions, type ScmReadinessReport } from "../scm/readiness.js";
 import { type ResolveUserMdResult } from "../user-config/resolve-user-md.js";
 import { type DetectHardEffortBudgetInput } from "./effort-budget.js";
@@ -125,6 +126,11 @@ export interface SessionStartOptions {
      * loads plan.policy.ceremonyDial and applies inputs (after provisional fill).
      */
     readonly ceremonyDial?: CeremonyDialSelection;
+    /**
+     * #3319: start-tier provenance hint. CLI `--ceremony-depth` / harness pin
+     * should pass `external-pin`. Policy override is inferred as `operator`.
+     */
+    readonly ceremonyDialStartTierProvenance?: CeremonyStartTierProvenance;
     /**
      * #3282: done-gate toolchain preflight seams (tests inject result or probe).
      * When omitted, runs live preflight after verify_tools on cold path.

package/dist/session/session-start.js

@@ -7,6 +7,8 @@ import { MIGRATE_COMPLETION_NUDGE, shouldEmitMigrateNudge } from "../init-deposi
 import { hostContentSurfaceToDict, maybeFormatHostContentSurfaceLines, } from "../platform/host-content-surface.js";
 import { detectEnvironmentContext, environmentContextToDict, formatEnvironmentContext, } from "../platform/shell-context.js";
 import { ceremonyDialToDict, formatCeremonyDialStatusLine, mergeCeremonyDialDeferrals, resolveCeremonyDial, resolveSessionCeremonyDialInputs, } from "../policy/ceremony-dial.js";
+import { emitCeremonyDialEscalationEvaluation, evaluateSessionStartCeremonyDialEscalation, formatCeremonyDialPinBypassLine, isCeremonyStartTierPinned, resolveCeremonyStartTierProvenance, } from "../policy/ceremony-dial-escalation.js";
+import { maybeFormatCoverageCheckResumeDisclosure } from "../policy/coverage-debt.js";
 import { DEFT_DIRECTIVE_DISABLE_FLAG_NAME, DEFT_DIRECTIVE_DISABLE_STATUS, detectDeftDirectiveDisable, formatDeftDirectiveDisableMessage, isDeftDirectiveDisableActive, } from "../policy/deft-directive-disable.js";
 import { disclosureLine } from "../policy/disclosure.js";
 import { detectNoDeftDirective, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, NO_DEFT_DIRECTIVE_INCONSISTENT_POLICY, } from "../policy/no-deft-directive.js";
@@ -21,7 +23,6 @@ import { runDefaultMode } from "../triage/welcome/default-mode.js";
 import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
 import { emitSessionValueReadback } from "../value/readback.js";
 import { verifyRequiredTools } from "../verify-env/verify-tools.js";
-import { maybeFormatCoverageCheckResumeNudge } from "./coverage-check-resume-nudge.js";
 import { effortBudgetToDict, maybeFormatEffortBudgetLines, resolveProductionHostEffortDescriptor, } from "./effort-budget.js";
 import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js";
 import { runOrientationCompression, } from "./orientation-compression.js";
@@ -48,6 +49,18 @@ export const QUICK_STEPS = [
     "verify_tools",
 ];
 export const GATED_STEPS = ["agent_hooks", "doctor", "cache_fresh"];
+/** Standing one-liner when coverageDebt/checkResume is non-default (#3314). */
+function pushCoverageCheckResumeDisclosure(lines, projectRoot) {
+    try {
+        const line = maybeFormatCoverageCheckResumeDisclosure(projectRoot);
+        if (line !== null) {
+            lines.push(line);
+        }
+    }
+    catch {
+        // best-effort — ritual must not abort
+    }
+}
 /** Env opt-in for optional session:start network (release probe + triage cache hydrate) (#2991). */
 export const ENV_SESSION_START_NETWORK = "DEFT_SESSION_START_NETWORK";
 /** Human-readable skip notice when optional network is off the hot path (#2991). */
@@ -527,16 +540,7 @@ function runSessionRearm(projectRoot, options, instant, environment) {
     if (humanMergeLine !== null) {
         lines.push(humanMergeLine);
     }
-    // #3189: re-arm still surfaces undecided coverage/check-resume once per ritual.
-    try {
-        const coverageNudge = maybeFormatCoverageCheckResumeNudge({ projectRoot });
-        if (coverageNudge.length > 0) {
-            lines.push(coverageNudge.trimEnd());
-        }
-    }
-    catch {
-        // best-effort — re-arm must not abort
-    }
+    pushCoverageCheckResumeDisclosure(lines, projectRoot);
     const priorQuick = eligibility.state.quickSteps;
     const priorTriage = priorQuick.triage_welcome ?? ritualStep({ ok: true, ts: instant });
     // Greptile P1: legacy ritual-state without verify_tools must re-run tools —
@@ -802,6 +806,11 @@ export function runSessionStart(projectRoot, options = {}) {
         env: options.env,
     });
     const ceremonyDialSelection = options.ceremonyDial ?? resolveCeremonyDial(projectRoot, { inputs: resolvedDialInputs });
+    const startTierProvenance = resolveCeremonyStartTierProvenance({
+        selection: ceremonyDialSelection,
+        injectedSelection: options.ceremonyDial !== undefined,
+        hint: options.ceremonyDialStartTierProvenance,
+    });
     const effectiveDeferrals = mergeCeremonyDialDeferrals(deferrals, ceremonyDialSelection);
     const skipFatPath = ceremonyDialSelection.profile.skipFatPath;
     const { head: gitHeadValue, error: gitError } = gitHead(projectRoot, runGit);
@@ -831,7 +840,13 @@ export function runSessionStart(projectRoot, options = {}) {
     const quickSteps = recordDeferredSteps(QUICK_STEPS, effectiveDeferrals, instant);
     const gatedSteps = recordDeferredSteps(GATED_STEPS, effectiveDeferrals, instant);
     const lines = [];
-    lines.push(formatCeremonyDialStatusLine(ceremonyDialSelection));
+    lines.push(formatCeremonyDialStatusLine(ceremonyDialSelection, {
+        startTierProvenance,
+    }));
+    const pinBypassLine = formatCeremonyDialPinBypassLine(startTierProvenance);
+    if (pinBypassLine !== null) {
+        lines.push(pinBypassLine);
+    }
     if (provisionalDial.reasons.length > 0 && options.ceremonyDial === undefined) {
         lines.push(`[deft ceremony-dial] provisional: ${provisionalDial.reasons.join("; ")}`);
     }
@@ -919,6 +934,8 @@ export function runSessionStart(projectRoot, options = {}) {
     else {
         stepTimings.push({ name: "branch_policy", duration_ms: 0, skipped: true });
     }
+    // Standing disclosure is independent of branch_policy deferral (#3314 / Greptile).
+    pushCoverageCheckResumeDisclosure(lines, projectRoot);
     // #3214 / #3156: verify_tools is mutation readiness — always run, even under
     // rapid/minimal. Dial skipFatPath only lightens *ceremony* (triage welcome,
     // optional network, staleness tickler), never readiness gates.
@@ -1182,20 +1199,12 @@ export function runSessionStart(projectRoot, options = {}) {
     if (consentPrompt.length > 0) {
         lines.push(consentPrompt.trimEnd());
     }
-    // #3189: skippable coverageDebt/checkResume project-decision nudge (fail-open; never blocks).
-    try {
-        const coverageNudge = maybeFormatCoverageCheckResumeNudge({ projectRoot });
-        if (coverageNudge.length > 0) {
-            lines.push(coverageNudge.trimEnd());
-        }
-    }
-    catch {
-        // best-effort operator advisory — session start must not abort
-    }
     const writeStarted = performance.now();
     const coldSessionId = (options.newSessionId ?? randomUUID)();
     const dialDict = {
         ...ceremonyDialToDict(ceremonyDialSelection),
+        start_tier: ceremonyDialSelection.depth,
+        start_tier_provenance: startTierProvenance,
         provisional: {
             taskSize: provisionalDial.taskSize,
             modelTier: provisionalDial.modelTier,
@@ -1274,6 +1283,19 @@ export function runSessionStart(projectRoot, options = {}) {
                     }
                     : {}),
             });
+            emitter.emitKnownToolTurnDenominator();
+            // #3319: evaluate escalate-on-evidence only when #3274 is live. A pin
+            // emits nothing so never-evaluated stays distinguishable from declined.
+            if (!isCeremonyStartTierPinned(startTierProvenance)) {
+                emitCeremonyDialEscalationEvaluation({
+                    projectRoot,
+                    sessionId: coldSessionId,
+                    env: options.env,
+                    evaluation: evaluateSessionStartCeremonyDialEscalation({
+                        selection: ceremonyDialSelection,
+                    }),
+                });
+            }
         }
         catch {
             // fail-open

package/dist/session/toolchain-preflight.d.ts

@@ -8,9 +8,12 @@
  * Never bootstraps tooling the PRODUCT does not need. Failures name cause and
  * remedy without embedding env values.
  */
+import { type CheckGateSpec } from "../check/gate-lists.js";
 export declare const TOOLCHAIN_PREFLIGHT_TOOLS: readonly ["task", "pnpm", "node", "git"];
 export type ToolchainPreflightTool = (typeof TOOLCHAIN_PREFLIGHT_TOOLS)[number];
 export type ToolchainPreflightStatus = "ok" | "missing" | "degraded";
+/** How a missing tool affects check dispatch (#3335). */
+export type ToolchainPreflightImpact = "none" | "degraded";
 export interface ToolchainPreflightFinding {
     readonly tool: ToolchainPreflightTool | "cli_dist";
     readonly present: boolean;
@@ -18,6 +21,11 @@ export interface ToolchainPreflightFinding {
     readonly cause: string | null;
     /** Operator/agent remedy command or instruction. */
     readonly remedy: string | null;
+    /**
+     * Missing-tool impact. `none` = present false but no install remedy and
+     * check does not skip CLI-native gates (#3335).
+     */
+    readonly impact?: ToolchainPreflightImpact | null;
 }
 export interface ToolchainPreflightResult {
     readonly status: ToolchainPreflightStatus;
@@ -46,6 +54,13 @@ export interface ToolchainPreflightOptions {
      * a global `deft`/`directive` is on PATH.
      */
     readonly probeCliDist?: boolean;
+    /** Active check composition. Defaults from consumer vs framework context. */
+    readonly composedGates?: readonly CheckGateSpec[];
+    /**
+     * Consumer deposit (not framework source). When omitted, inferred from
+     * frameworkRoot vs projectRoot (#3335 / #3324).
+     */
+    readonly consumerDeposit?: boolean;
 }
 /**
  * Gates that specifically need a package manager / built dist.