@ngockhoale/ukit 3.3.2 → 3.4.0

package/template_project/.claude/ukit/index/route-task.mjs

@@ -33,7 +33,90 @@ import {
 } from '../runtime/memory-policy.mjs';
 import { resolveRecordFreshness } from '../runtime/memory-freshness.mjs';
 import { resolveMemoryStage } from '../runtime/memory-flags.mjs';
-
+import {
+  ROUTE_VERSION,
+  ROUTE_CONTRACT_VERSION,
+  ROUTE_SCHEMA_STAGES,
+  ROUTE_INTENT_KINDS,
+  ROUTE_MUTABILITIES,
+  ROUTE_RIGOR_LEVELS,
+  ROUTE_MODEL_TIERS,
+  ROUTE_RISK_FLOORS,
+  ROUTE_RISK_REASON_CODES,
+  ROUTE_EXECUTION_MODES,
+  ROUTE_EFFORTS,
+  resolveRouteSchemaStage,
+  resolveRouteStage,
+  resolveResumableRunStage,
+  resolveDecisionPlaneStage,
+  resolveDecisionFamilyStage,
+  buildExecutionContract,
+  resolveModelTier,
+  isSharedImpactFile,
+  deriveRiskFloor,
+  formatRiskFloorSegment,
+  deriveCeremonyLimits,
+  formatLimitsSegment,
+  deriveFastPath,
+  formatFastPathSegment,
+  isDeliveryOnlyRequest,
+  buildCompletionState,
+  buildResolvedRouteFields,
+  validateResolvedRoute,
+  compactResolvedRoute,
+  resumableTaskBoundary,
+  buildShadowDecisionQuestions,
+  ROUTE_SHADOW_QUESTIONS,
+  deriveRouteFields,
+} from './route-resolver.mjs';
+import { applyMeasuredTier, loadTierMap } from './tier-selection.mjs';
+import { resolvePlaybookRoute, loadRegistry } from './playbook-registry.mjs';
+import { extractHistorySignalsAsync } from './session-history-extractor.mjs';
+import {
+  applyFixLoopEscalation,
+  isFixLoopEscalationDue,
+} from './fix-loop-escalation.mjs';
+
+// TASK-004 (BL-006): the derivation primitives this file used to carry inline now
+// live in route-resolver.mjs — the same module skill-router.sh imports, so both
+// router surfaces compute identical fields. Exported names stay identical via
+// re-export (tests and the Codex instruction path import them from here).
+export {
+  ROUTE_VERSION,
+  ROUTE_CONTRACT_VERSION,
+  ROUTE_SCHEMA_STAGES,
+  ROUTE_INTENT_KINDS,
+  ROUTE_MUTABILITIES,
+  ROUTE_RIGOR_LEVELS,
+  ROUTE_MODEL_TIERS,
+  ROUTE_RISK_FLOORS,
+  ROUTE_RISK_REASON_CODES,
+  ROUTE_EXECUTION_MODES,
+  ROUTE_EFFORTS,
+  resolveRouteSchemaStage,
+  resolveRouteStage,
+  resolveResumableRunStage,
+  resolveDecisionPlaneStage,
+  resolveDecisionFamilyStage,
+  buildExecutionContract,
+  resolveModelTier,
+  isSharedImpactFile,
+  deriveRiskFloor,
+  formatRiskFloorSegment,
+  deriveCeremonyLimits,
+  formatLimitsSegment,
+  deriveFastPath,
+  formatFastPathSegment,
+  isDeliveryOnlyRequest,
+  buildCompletionState,
+  buildResolvedRouteFields,
+  validateResolvedRoute,
+  compactResolvedRoute,
+  resumableTaskBoundary,
+  buildShadowDecisionQuestions,
+  ROUTE_SHADOW_QUESTIONS,
+  deriveRouteFields,
+};
 const {
   resolveContext,
   buildCodeIndex,
@@ -71,56 +154,6 @@ function deriveContextDocs({ taskType = null, intentMode = null } = {}) {
   return unique(docs).slice(0, CONTEXT_DOCS_MAX);
 }
 
-// --- M01.1: additive ResolvedTaskRoute v1 (docs/pstack/CONTRACTS.md C01) -------------------
-// Literal mirror of the canonical block in src/index/taskRouting.js — this file cannot
-// import from src/, so the copy is locked by tests/consistency/executionContractSync.test.js.
-// Emitted only when `routing.routeSchema.stage` (runtime config, default "off") is not
-// "off". All fields are additive on top of the existing routeSummary shape — legacy
-// top-level fields are never removed or renamed, so older consumers keep working.
-export const ROUTE_VERSION = 1;
-export const ROUTE_CONTRACT_VERSION = 1;
-export const ROUTE_SCHEMA_STAGES = new Set(['off', 'shadow', 'canary', 'default']);
-export const ROUTE_INTENT_KINDS = new Set(['informational', 'delivery', 'mutation', 'investigation', 'review']);
-export const ROUTE_MUTABILITIES = new Set(['read-only', 'mutating', 'mixed']);
-export const ROUTE_RIGOR_LEVELS = new Set(['R0', 'R1', 'R2', 'R3', 'R4']);
-export const ROUTE_MODEL_TIERS = new Set(['lite', 'code', 'smart']);
-export const ROUTE_RISK_FLOORS = new Set(['none', 'high-risk']);
-export const ROUTE_EFFORTS = new Set(['low', 'medium', 'high']);
-// SPEC §5 FR-003: fixed table order — codes are emitted and printed in this order.
-// The first six raise the floor to 'high-risk'; the last two are informational only.
-export const ROUTE_RISK_REASON_CODES = Object.freeze([
-  'security-sensitive',
-  'shared-impact',
-  'public-contract',
-  'schema-change',
-  'destructive-action',
-  'cross-engine',
-  'established-precedent',
-  'explicit-local-target',
-]);
-const ROUTE_RISK_FLOOR_RAISING_CODES = new Set(ROUTE_RISK_REASON_CODES.slice(0, 6));
-const ROUTE_RISK_ENGINES = ['claude code', 'codex', 'omp'];
-
-// FR-004 (M01.3'): Fast Path eligibility vocabulary. The suppressed list is fixed
-// text per SPEC — deliberately not configurable. Reasons are the informational
-// risk codes (the last two ROUTE_RISK_REASON_CODES entries) present on the route.
-const FAST_PATH_MODES = new Set(['tiny-fix', 'local-fix']);
-const FAST_PATH_SUPPRESSED = Object.freeze(['design', 'smart', 'subagents', 'broad-verify']);
-const FAST_PATH_REASON_CODES = new Set(ROUTE_RISK_REASON_CODES.slice(6));
-// 'informational' is a real router emission (no completion contract) even though it is
-// not part of the seven-lane execution-mode ladder.
-export const ROUTE_EXECUTION_MODES = [
-  'tiny-fix',
-  'local-fix',
-  'local-build',
-  'find-cause',
-  'shared-edit',
-  'map-impact',
-  'review-release',
-  'informational',
-];
-const ROUTE_ESCALATION_CEILING = 'review-release';
-const ROUTE_GOAL_MAX_LENGTH = 240;
 
 // --- v3 route-side advisory blocks (docs/pstack/SPEC-playbook-todo.md, ------------------
 // SPEC-principle-index.md, SPEC-model-roles.md). Literal mirror of the canonical block in
@@ -142,29 +175,33 @@ If the user says "new task", re-route — do not treat the message as the next s
    "might help" is a hypothesis, not a fix; it does not ship.
 4. Verify on the same surface: the original repro now passes. "Inconclusive" or
    wrong-surface is not a pass. A unit test shows branch behavior, not bug absence.
-5. Keep the rejected hypotheses — one line each, why ruled out.
+5. Keep the rejected hypotheses — one line each, why ruled out. When rejections on
+   this same defect cross the fix-loop threshold, stop retrying this lane —
+   escalate to runtime-forensics (live symptom) or a deeper debug/verify lane.
 Reply: what was broken, root cause, fix, how verified — paste failing-then-passing
 repro output verbatim.
 Ask the human only for: irreversible writes, a genuine preference call no experiment settles, or a real dead end. Everything else: do it, report it.`,
-  'issue-implementation': `You own this task. Normalize the goal, build, verify.
+  'feature-implementation': `You own this task. Normalize the goal, build, verify.
 If the user says "new task", re-route — do not treat the message as the next step.
 1. State the done condition as a checkable predicate before writing code.
 2. Find the established analog — follow it unless you name why it does not fit.
+   (Skippable only when you can name why no analog exists.)
 3. Name the data shape and its organizing structure before writing logic.
 4. Implement the smallest change satisfying the predicate.
 5. Verify against the predicate on the real artifact — not "it compiles".
 6. Widen once: check the impact surface the route named, no broader.
 Reply: what changed, the predicate, the evidence it now holds.
-Ask the human only for: irreversible writes, a genuine preference call no experiment settles, or a real dead end. Everything else: do it, report it.`,
+Ask the human only for: irreversible writes, a genuine preference call no experiment
+settles, or a real dead end. Everything else: do it, report it.`,
 });
 
 // Lane → policy (§2.2). tiny-fix/local-fix stay lean (Fast Path); review-release and
 // informational carry no policy.
 export const WORKFLOW_POLICY_BY_MODE = Object.freeze({
   'find-cause': 'bug-fix',
-  'local-build': 'issue-implementation',
-  'shared-edit': 'issue-implementation',
-  'map-impact': 'issue-implementation',
+  'local-build': 'feature-implementation',
+  'shared-edit': 'feature-implementation',
+  'map-impact': 'feature-implementation',
 });
 
 // SPEC-principle-index §2.1: ~16-line index, one line per principle; group headers are
@@ -279,450 +316,6 @@ export function formatModelRolesBlock(roles = null) {
 fast-worker→${resolved['fast-worker']}, vision→${resolved.vision}. Delegate via role name; inherit-parent = same model as parent.`;
 }
 
-// Stage keys treat absence as "off" (MIGRATION_ROLLBACK named-keys table). Unknown or
-// malformed values degrade to "off" — the conservative reading that keeps the route
-// byte-identical to the pre-M01.1 shape.
-export function resolveRouteSchemaStage(config = null) {
-  const stage = config?.routing?.routeSchema?.stage;
-  return ROUTE_SCHEMA_STAGES.has(stage) ? stage : 'off';
-}
-
-// FR-002: generic stage resolver — every routing.<key>.stage shares the same
-// absent/malformed → 'off' contract. resolveRouteSchemaStage stays as the
-// routeSchema-specific spelling of this helper.
-export function resolveRouteStage(config = null, key) {
-  const stage = config?.routing?.[key]?.stage;
-  return ROUTE_SCHEMA_STAGES.has(stage) ? stage : 'off';
-}
-
-// FR-008 (M07): decision-plane stage resolvers — same absent/malformed → 'off'
-// contract as routing.* stages. `decisionPlane.enabled === false` is the global
-// emergency disable and reads as 'off' regardless of stage keys.
-export function resolveDecisionPlaneStage(config = null) {
-  const plane = config?.decisionPlane;
-  if (!plane || typeof plane !== 'object' || plane.enabled === false) return 'off';
-  return ROUTE_SCHEMA_STAGES.has(plane.stage) ? plane.stage : 'off';
-}
-
-// Per-family override wins over the global stage; absence inherits it.
-export function resolveDecisionFamilyStage(config = null, family) {
-  const globalStage = resolveDecisionPlaneStage(config);
-  const override = config?.decisionPlane?.families?.[family]?.stage;
-  return ROUTE_SCHEMA_STAGES.has(override) ? override : globalStage;
-}
-
-// FR-003 (M01.2'): derive the additive riskFloor from hard signals. Codes are
-// collected in ROUTE_RISK_REASON_CODES table order; the floor is 'high-risk' iff
-// any of the first six (floor-raising) codes fired — informational codes never
-// raise it. Detectors read the normalized signal text (same source the mode
-// ladder uses) plus the raw target path and context preview.
-export function deriveRiskFloor({
-  promptText = '',
-  commandText = '',
-  targetFile = null,
-  executionMode = null,
-  activeSkillIds = [],
-  contextPreview = null,
-} = {}) {
-  const signalText = buildNormalizedRouteSignalText(promptText, commandText);
-  const target = String(targetFile || '');
-  const skillIds = Array.isArray(activeSkillIds) ? activeSkillIds : [];
-  const codes = [];
-  if (
-    /\b(auth|security|token|permission|secret|credential|password|vulnerab|exploit|xss|injection)\b/i.test(signalText)
-    || skillIds.includes('discover-security')
-  ) {
-    codes.push('security-sensitive');
-  }
-  if (isSharedImpactFile(targetFile) || executionMode === 'shared-edit' || executionMode === 'map-impact') {
-    codes.push('shared-impact');
-  }
-  if (
-    /(^|\/)(package\.json|manifests\/|.*\.d\.ts$|(^|\/)api\/|openapi|swagger)/i.test(target)
-    || /\b(public api|breaking change|api contract|semver)\b/i.test(signalText)
-  ) {
-    codes.push('public-contract');
-  }
-  if (
-    /(^|\/)(migrations?|db|database|prisma|schema)/i.test(target)
-    || /\b(migration|migrate|schema|alter table|add column|drop column)\b/i.test(signalText)
-  ) {
-    codes.push('schema-change');
-  }
-  if (/\b(delete|drop|truncate|destroy|wipe|uninstall|rm -rf|purge)\b/i.test(signalText)) {
-    codes.push('destructive-action');
-  }
-  const engineHits = ROUTE_RISK_ENGINES.filter(
-    (name) => new RegExp(`\\b${name}\\b`, 'i').test(signalText),
-  ).length;
-  if (
-    /\bcross[- ]engine\b|\ball engines\b/i.test(signalText)
-    || engineHits >= 2
-    || /^template_project\/\.(claude|codex|omp)\//i.test(target)
-  ) {
-    codes.push('cross-engine');
-  }
-  if ((contextPreview?.analogFiles?.length ?? 0) > 0 || (contextPreview?.styleFiles?.length ?? 0) > 0) {
-    codes.push('established-precedent');
-  }
-  if (target && !isSharedImpactFile(targetFile)) {
-    codes.push('explicit-local-target');
-  }
-  return {
-    floor: codes.some((code) => ROUTE_RISK_FLOOR_RAISING_CODES.has(code)) ? 'high-risk' : 'none',
-    codes,
-  };
-}
-
-// Route-line segment (FR-003): on 'high-risk' only the floor-raising codes print;
-// on 'none' the informational codes do. Empty list → no segment at all.
-function formatRiskFloorSegment(riskFloor = null) {
-  if (!riskFloor) {
-    return null;
-  }
-  const printed = riskFloor.floor === 'high-risk'
-    ? riskFloor.codes.filter((code) => ROUTE_RISK_FLOOR_RAISING_CODES.has(code))
-    : riskFloor.codes;
-  return printed.length > 0 ? `risk=${riskFloor.floor}(${printed.join(',')})` : null;
-}
-
-// FR-001 (M01.2' limits fragment): compile the contract's numeric budget keys
-// into an advisory map. Only finite numbers survive — a non-numeric or missing
-// key is simply absent. Zero is a real budget ("no read passes"), never
-// filtered. Same key set as the ceremonyBudget.limits builder below.
-export function deriveCeremonyLimits(executionContract = null) {
-  if (executionContract === null || typeof executionContract !== 'object') {
-    return {};
-  }
-  return Object.fromEntries(
-    ['maxReadPasses', 'maxContextPulls', 'maxReadPassesBeforeReassess']
-      .filter((key) => Number.isFinite(executionContract[key]))
-      .map((key) => [key, executionContract[key]]),
-  );
-}
-
-// Route-line segment (FR-002): fixed reads,ctx,reassess order; only present
-// keys print. Empty/absent map → null so the segment never appears.
-export function formatLimitsSegment(limits = null) {
-  if (limits === null || typeof limits !== 'object') {
-    return null;
-  }
-  const parts = [
-    ['reads', 'maxReadPasses'],
-    ['ctx', 'maxContextPulls'],
-    ['reassess', 'maxReadPassesBeforeReassess'],
-  ]
-    .filter(([, key]) => Number.isFinite(limits[key]))
-    .map(([label, key]) => `${label}:${limits[key]}`);
-  return parts.length > 0 ? `limits=${parts.join(',')}` : null;
-}
-
-// FR-004 (M01.3'): Fast Path eligibility predicate. Returns null when no riskFloor
-// was supplied — eligibility must never be derived without the floor check, so a
-// missing floor means "not computed", not "none". Eligible iff the lane is
-// tiny-fix/local-fix, exactly one local target is known, the floor is 'none',
-// a bounded verification path exists (targeted commands or the tiny-fix
-// 'minimal-or-targeted' contract policy), and the target is not shared-impact.
-export function deriveFastPath({
-  executionMode = null,
-  targetFile = null,
-  riskFloor = null,
-  verificationRecommendation = null,
-  contextPreview = null,
-} = {}) {
-  if (!riskFloor) {
-    return null;
-  }
-  const reasons = (riskFloor.codes ?? []).filter((code) => FAST_PATH_REASON_CODES.has(code));
-  const hasLocalTarget = Boolean(targetFile) || contextPreview?.primaryTargets?.length === 1;
-  const hasBoundedVerification = (verificationRecommendation?.commands?.length ?? 0) > 0
-    || buildExecutionContract(executionMode)?.verificationPolicy === 'minimal-or-targeted';
-  const eligible = FAST_PATH_MODES.has(executionMode)
-    && hasLocalTarget
-    && riskFloor.floor === 'none'
-    && hasBoundedVerification
-    && !isSharedImpactFile(targetFile);
-  return {
-    eligible,
-    suppressed: eligible ? [...FAST_PATH_SUPPRESSED] : [],
-    reasons,
-  };
-}
-
-// Route-line segment (FR-004): emitted only for eligible routes — ineligible
-// routes keep the routeSummary.fastPath field for telemetry but stay silent.
-function formatFastPathSegment(fastPath = null) {
-  if (!fastPath?.eligible) {
-    return null;
-  }
-  const reasons = fastPath.reasons?.length ? ` (${fastPath.reasons.join(',')})` : '';
-  return `fastPath=on | suppress: ${FAST_PATH_SUPPRESSED.join(',')}${reasons}`;
-}
-
-// A bare delivery command ("push this to git", "đẩy bộ này lên git") performs no
-// repository mutation the ledger could ever receipt. With no edit/review/debug/build
-// signal present, routing it to an investigation lane fabricates write debt and the
-// completion gate then demands an edit that cannot exist. Extracted from
-// deriveExecutionMode so the C01 intent.kind mapping can reuse the identical predicate
-// (delivery-only → 'delivery') instead of duplicating the regexes.
-function isDeliveryOnlyRequest({ signalText = '', scores = {}, targetFile = null } = {}) {
-  const signalRaw = String(signalText || '').toLowerCase();
-  const deliveryWordSignal = /\bgit\s+push\b/.test(signalRaw)
-    || /\bpush\b[^\n]{0,60}\b(?:git|github|gitlab|remote|origin|repo)\b/.test(signalRaw)
-    || /\b(?:git|github|gitlab|remote|origin|repo)\b[^\n]{0,60}\bpush\b/.test(signalRaw)
-    || /\bday\b(?:\s+\S+){0,3}?\s+len\b/.test(signalRaw);
-  return deliveryWordSignal
-    && scores.editCertainty === 0
-    && !scores.implementSignal
-    && !scores.reviewSignal
-    && !scores.debugSignal
-    && !scores.failureSignal
-    && !scores.impactSignal
-    && !scores.buildSignal
-    && !scores.directTransformSignal
-    && !scores.smallFixSignal
-    && !scores.sharedRisk
-    && !targetFile;
-}
-
-// CONTRACTS.md "Intent vocabulary mapping": taskType informs mode priors, not
-// intent.kind; intentMode maps to kind as question/explanation → informational,
-// ship/deliver → delivery, code change → mutation, root-cause/diagnosis →
-// investigation, review/audit → review.
-function deriveRouteIntentKind({ executionMode = null, intentMode = null, deliveryOnly = false } = {}) {
-  if (executionMode === 'find-cause') return 'investigation';
-  if (executionMode === 'review-release') return 'review';
-  if (executionMode === 'informational') return deliveryOnly ? 'delivery' : 'informational';
-  if (executionMode) return 'mutation';
-  if (intentMode === 'review-specific') return 'review';
-  if (intentMode === 'debug-specific') return 'investigation';
-  if (intentMode === 'implement-specific' || intentMode === 'docs-specific') return 'mutation';
-  return 'informational';
-}
-
-// Existing read-only vs mutating classification: only the informational lane carries
-// no write debt; every contract lane is mutating.
-function deriveRouteMutability(executionMode = null) {
-  return executionMode && executionMode !== 'informational' ? 'mutating' : 'read-only';
-}
-
-function compactRouteGoal(text = '') {
-  const goal = String(text || '').trim();
-  if (!goal) return null;
-  return goal.length > ROUTE_GOAL_MAX_LENGTH ? `${goal.slice(0, ROUTE_GOAL_MAX_LENGTH)}…` : goal;
-}
-
-// Builds the additive C01 groups for one resolved route. rigor stays null until
-// M01.2 derives it; ceremonyBudget/capabilityPolicy are empty shaped objects M02/M01.2
-// populate; escalation.current mirrors the selected mode.
-function buildResolvedRouteFields({
-  routingContext = {},
-  activeSkillIds = [],
-  executionMode = null,
-  executionContract = null,
-  completionState = null,
-  riskFloor = null,
-} = {}) {
-  // Decision table v2 (FR-001/FR-002): tier + effort resolve together from the
-  // contract lane and the additive riskFloor. The router cannot observe host
-  // binding capabilities, so the emitted pair is advisory text by definition.
-  const tierDecision = resolveModelTier({ executionMode, riskFloor });
-  const signalText = buildNormalizedRouteSignalText(routingContext.promptText, routingContext.commandText);
-  const deliveryOnly = isDeliveryOnlyRequest({
-    signalText,
-    scores: routingContext.executionScores ?? {},
-    targetFile: routingContext.targetFile ?? null,
-  });
-  return {
-    routeVersion: ROUTE_VERSION,
-    intent: {
-      kind: deriveRouteIntentKind({
-        executionMode,
-        intentMode: routingContext.intentMode ?? null,
-        deliveryOnly,
-      }),
-      mutability: deriveRouteMutability(executionMode),
-      goal: compactRouteGoal(routingContext.lastExplicitUserPromptText ?? routingContext.promptText),
-      doneConditions: [],
-    },
-    execution: {
-      mode: executionMode,
-      rigor: null,
-      riskFloor: riskFloor?.floor ?? null,
-      phase: null,
-      contractVersion: ROUTE_CONTRACT_VERSION,
-      modelTier: tierDecision.tier,
-      effort: tierDecision.effort,
-    },
-    evidence: {
-      observations: [],
-      riskSignals: riskFloor?.codes ?? [],
-      activationReasons: [],
-      suppressionReasons: [],
-      completionRequirements: unique(completionState?.missingEvidence ?? []),
-    },
-    ceremonyBudget: {
-      policyVersion: ROUTE_CONTRACT_VERSION,
-      rigor: null,
-      limits: riskFloor
-        ? Object.fromEntries(
-            ['maxReadPasses', 'maxContextPulls', 'maxReadPassesBeforeReassess']
-              .filter((key) => typeof executionContract?.[key] === 'number')
-              .map((key) => [key, executionContract[key]]),
-          )
-        : {},
-      consumed: {},
-      exceptions: [],
-    },
-    capabilityPolicy: {
-      policyVersion: ROUTE_CONTRACT_VERSION,
-      required: [],
-      recommended: [],
-      suppressed: [],
-      activeSkillIds: unique(activeSkillIds),
-    },
-    escalation: {
-      current: { mode: executionMode, rigor: null },
-      ceiling: ROUTE_ESCALATION_CEILING,
-      triggers: [],
-      history: [],
-    },
-  };
-}
-
-// Plain-JS validator for the additive C01 groups. Returns { valid, errors }; it never
-// throws and never inspects legacy fields — old consumers may carry anything else.
-export function validateResolvedRoute(route = null) {
-  const errors = [];
-  const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
-  if (!isObject(route)) {
-    return { valid: false, errors: ['route must be an object.'] };
-  }
-  if (route.routeVersion !== ROUTE_VERSION) {
-    errors.push(`routeVersion must be ${ROUTE_VERSION}.`);
-  }
-  if (!isObject(route.intent)) {
-    errors.push('intent must be an object.');
-  } else {
-    if (!ROUTE_INTENT_KINDS.has(route.intent.kind)) {
-      errors.push(`intent.kind must be one of: ${[...ROUTE_INTENT_KINDS].join(', ')}.`);
-    }
-    if (!ROUTE_MUTABILITIES.has(route.intent.mutability)) {
-      errors.push(`intent.mutability must be one of: ${[...ROUTE_MUTABILITIES].join(', ')}.`);
-    }
-    if (route.intent.goal !== null && typeof route.intent.goal !== 'string') {
-      errors.push('intent.goal must be a string or null.');
-    }
-    if (!Array.isArray(route.intent.doneConditions)) {
-      errors.push('intent.doneConditions must be an array.');
-    }
-  }
-  if (!isObject(route.execution)) {
-    errors.push('execution must be an object.');
-  } else {
-    if (route.execution.mode !== null && !ROUTE_EXECUTION_MODES.includes(route.execution.mode)) {
-      errors.push(`execution.mode must be null or one of: ${ROUTE_EXECUTION_MODES.join(', ')}.`);
-    }
-    if (route.execution.rigor !== null && !ROUTE_RIGOR_LEVELS.has(route.execution.rigor)) {
-      errors.push(`execution.rigor must be null or one of: ${[...ROUTE_RIGOR_LEVELS].join(', ')}.`);
-    }
-    if (route.execution.riskFloor !== null && !ROUTE_RISK_FLOORS.has(route.execution.riskFloor)) {
-      errors.push(`execution.riskFloor must be null or one of: ${[...ROUTE_RISK_FLOORS].join(', ')}.`);
-    }
-    if (route.execution.contractVersion !== ROUTE_CONTRACT_VERSION) {
-      errors.push(`execution.contractVersion must be ${ROUTE_CONTRACT_VERSION}.`);
-    }
-    if (route.execution.modelTier !== null && !ROUTE_MODEL_TIERS.has(route.execution.modelTier)) {
-      errors.push(`execution.modelTier must be null or one of: ${[...ROUTE_MODEL_TIERS].join(', ')}.`);
-    }
-    if (route.execution.effort !== null && route.execution.effort !== undefined
-      && !ROUTE_EFFORTS.has(route.execution.effort)) {
-      errors.push(`execution.effort must be null or one of: ${[...ROUTE_EFFORTS].join(', ')}.`);
-    }
-  }
-  if (!isObject(route.evidence)) {
-    errors.push('evidence must be an object.');
-  } else {
-    for (const key of ['observations', 'riskSignals', 'activationReasons', 'suppressionReasons', 'completionRequirements']) {
-      if (!Array.isArray(route.evidence[key])) {
-        errors.push(`evidence.${key} must be an array.`);
-      }
-    }
-    if (Array.isArray(route.evidence.riskSignals)
-      && route.evidence.riskSignals.some(
-        (code) => typeof code !== 'string' || !ROUTE_RISK_REASON_CODES.includes(code),
-      )) {
-      errors.push(`evidence.riskSignals entries must be one of: ${ROUTE_RISK_REASON_CODES.join(', ')}.`);
-    }
-  }
-  if (!isObject(route.ceremonyBudget)) {
-    errors.push('ceremonyBudget must be an object.');
-  } else {
-    if (route.ceremonyBudget.rigor !== null && !ROUTE_RIGOR_LEVELS.has(route.ceremonyBudget.rigor)) {
-      errors.push(`ceremonyBudget.rigor must be null or one of: ${[...ROUTE_RIGOR_LEVELS].join(', ')}.`);
-    }
-    if (!isObject(route.ceremonyBudget.limits)) {
-      errors.push('ceremonyBudget.limits must be an object.');
-    }
-    if (!isObject(route.ceremonyBudget.consumed)) {
-      errors.push('ceremonyBudget.consumed must be an object.');
-    }
-    if (!Array.isArray(route.ceremonyBudget.exceptions)) {
-      errors.push('ceremonyBudget.exceptions must be an array.');
-    }
-  }
-  if (!isObject(route.capabilityPolicy)) {
-    errors.push('capabilityPolicy must be an object.');
-  } else {
-    for (const key of ['required', 'recommended', 'suppressed', 'activeSkillIds']) {
-      if (!Array.isArray(route.capabilityPolicy[key])) {
-        errors.push(`capabilityPolicy.${key} must be an array.`);
-      }
-    }
-  }
-  if (!isObject(route.escalation)) {
-    errors.push('escalation must be an object.');
-  } else {
-    if (!isObject(route.escalation.current)) {
-      errors.push('escalation.current must be an object.');
-    } else {
-      if (route.escalation.current.mode !== null && !ROUTE_EXECUTION_MODES.includes(route.escalation.current.mode)) {
-        errors.push(`escalation.current.mode must be null or one of: ${ROUTE_EXECUTION_MODES.join(', ')}.`);
-      }
-      if (route.escalation.current.rigor !== null && !ROUTE_RIGOR_LEVELS.has(route.escalation.current.rigor)) {
-        errors.push(`escalation.current.rigor must be null or one of: ${[...ROUTE_RIGOR_LEVELS].join(', ')}.`);
-      }
-    }
-    if (!Array.isArray(route.escalation.triggers)) {
-      errors.push('escalation.triggers must be an array.');
-    }
-    if (!Array.isArray(route.escalation.history)) {
-      errors.push('escalation.history must be an array.');
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-// Compact serialization whitelist (C01 compatibility rule): adapter/runtime consumers
-// get a bounded view that may omit verbose evidence but never mode, rigor, required
-// completion evidence, or escalation state. Returns null for legacy (stage-off)
-// summaries so compact output stays byte-identical when the schema stage is off.
-export function compactResolvedRoute(routeSummary = null) {
-  if (!routeSummary || typeof routeSummary !== 'object' || routeSummary.routeVersion == null) {
-    return null;
-  }
-  return {
-    routeVersion: routeSummary.routeVersion,
-    intent: routeSummary.intent ?? null,
-    execution: routeSummary.execution ?? null,
-    evidence: {
-      completionRequirements: unique(routeSummary.evidence?.completionRequirements ?? []),
-    },
-    ceremonyBudget: routeSummary.ceremonyBudget ?? null,
-    capabilityPolicy: routeSummary.capabilityPolicy ?? null,
-    escalation: routeSummary.escalation ?? null,
-  };
-}
 const STOPWORDS = new Set([
   'the', 'a', 'an', 'and', 'or', 'to', 'for', 'of', 'with', 'in', 'on', 'is', 'are',
   'this', 'that', 'it', 'as', 'by', 'be', 'use', 'using', 'implement', 'fix', 'task',
@@ -1432,6 +1025,16 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
     previousContextSnapshot,
     recentOutputSnapshot,
   });
+  // BL-013: bounded history signals from the caller-supplied transcript
+  // pointer (input.transcriptPath / UKIT_TRANSCRIPT_PATH). Degrades to the
+  // zeroed struct when absent — never throws, never extends the budget.
+  const historySignals = await extractHistorySignalsAsync({
+    transcriptPath: normalizedInput.transcriptPath
+      ?? process.env.UKIT_TRANSCRIPT_PATH
+      ?? null,
+    routeFingerprint: normalizedInput.routeFingerprint ?? null,
+    requestKey,
+  });
   const helperCacheSnapshot = await readHelperCacheSnapshot({
     rootDir: absoluteRoot,
     indexGeneratedAtMs,
@@ -1449,10 +1052,17 @@ export async function routeTask(input = {}, { signal = null, deadlineMs = null,
     useIndexedContext,
     previousContextSnapshot,
     recentOutputSnapshot,
-    previousRouteSummary: null,
+    previousRouteSummary: normalizedInput.previousRouteSummary ?? null,
     escalationConfig,
+    // BL-018: caller-injected seams — the in-process entry accepts a prior
+    // emission (exhaustion check) and a stubbed decision/registrar for tests.
+    escalationDecision: normalizedInput.escalationDecision ?? null,
+    // C89 TASK-005: typed delegation-advice consult seam (same {ask,
+    // appendReceipt, override} contract as src deriveTaskRoute).
+    roleAdviceDecision: normalizedInput.roleAdviceDecision ?? null,
     sessionId: normalizedInput.sessionId ?? null,
     indexGeneratedAtMs,
+    historySignals,
   });
   const sharedState = createSharedRouteState({
     route,
@@ -1491,6 +1101,19 @@ async function main() {
   const routeCachePath = path.join(rootDir, '.claude', 'ukit', 'route-cache.json');
   const routeAuditPath = path.join(rootDir, '.ukit', 'storage', 'cache', 'route-audit.json');
   const persistedPreviousState = await readJson(sharedStatePath, {});
+  // BL-017 (SPEC FR-005): detached hook-path shadow pass — skill-router.sh
+  // spawns this fire-and-forget per emitted route. Self-deadline so a wedged
+  // import/read can never leave an orphan (same watchdog posture as the hook).
+  if (args.includes('--decision-shadow')) {
+    setTimeout(() => process.exit(0), DECISION_SHADOW_TIMEOUT_CAP_MS * 3).unref();
+    await runHookPathDecisionShadow({
+      rootDir,
+      statePath: sharedStatePath,
+      targetFile: readFlagValue(args, '--target-file') ?? null,
+    });
+    return;
+  }
+
   const sessionId = normalizeSessionId(readFlagValue(args, '--session-id'));
   const previousStateOwnershipBlocked = hasRouteStateOwner(persistedPreviousState)
     && !isRouteStateCompatible(persistedPreviousState, sessionId);
@@ -1574,6 +1197,20 @@ async function main() {
     previousContextSnapshot,
     recentOutputSnapshot,
   });
+  // BL-013: bounded session-history signals from the transcript pointer
+  // (--transcript flag or UKIT_TRANSCRIPT_PATH env; absent → degraded zeroed
+  // struct). Extracted once here so provisional/cached/final emissions carry
+  // the identical counters/enums — never raw transcript text.
+  const transcriptPath = readFlagValue(args, '--transcript')
+    ?? process.env.UKIT_TRANSCRIPT_PATH
+    ?? null;
+  const historySignals = await extractHistorySignalsAsync({
+    transcriptPath,
+    routeFingerprint: previousState?.requestKey === requestKey
+      ? previousState?.fingerprint ?? null
+      : null,
+    requestKey,
+  });
   const reusableState = reuseSharedRouteState({
     previousState,
     requestKey,
@@ -1594,6 +1231,15 @@ async function main() {
   const canPersistCachedRouteState = !cachedRouteStateOwnershipBlocked;
 
   if (reusableState) {
+    // BL-013: refresh the bounded counters on a same-requestKey reuse — the
+    // emitted state always carries current signals even when the route body
+    // is reused verbatim.
+    if (historySignals && reusableState.routeSummary) {
+      reusableState.routeSummary = {
+        ...reusableState.routeSummary,
+        historySignals,
+      };
+    }
     printRouteState(reusableState);
     return;
   }
@@ -1635,11 +1281,43 @@ async function main() {
       } else {
         delete rescuedRouteSummary.riskEscalation;
       }
+      // BL-013: refresh the bounded counters on a cached-route reuse — identical
+      // merge rule as the prior-state reuse above.
+      if (historySignals) {
+        rescuedRouteSummary.historySignals = historySignals;
+      }
       applyRescueBiasToRouteSummary(rescuedRouteSummary);
       applyEscalationToRouteSummary(rescuedRouteSummary, {
         config: escalationConfig,
         targetFile: cachedRouteState.routingContext?.targetFile ?? null,
       });
+      // BL-018: re-run the fix-loop transition on the rescued summary — a
+      // refreshed fixLoopCount may trip, escalate, or exhaust (BLOCKED); the
+      // cached summary doubles as the previous emission for exhaustion.
+      if (isFixLoopEscalationDue({ historySignals: rescuedRouteSummary.historySignals, config: escalationConfig })) {
+        // Same fingerprint the persisted sharedState carries below — the
+        // escalation record stamps it so the next emission's same-loop join
+        // (exhaustion/blocked-terminal/preserve) binds only this route.
+        const rescuedRouteFingerprint = buildRouteStateFingerprint({
+          ...cachedRouteState,
+          requestKey,
+          routeSummary: rescuedRouteSummary,
+        });
+        await applyFixLoopEscalation({
+          routeSummary: rescuedRouteSummary,
+          routingContext: cachedRouteState.routingContext ?? {},
+          previousRouteSummary: cachedRouteState.routeSummary,
+          routeFingerprint: rescuedRouteFingerprint,
+          config: escalationConfig,
+          ask: ({ batch }) => askFixLoopEscalationDecision({
+            rootDir,
+            config: escalationConfig,
+            batch,
+          }),
+          appendReceipt: (receipt) => appendDecisionReceipt(rootDir, receipt),
+          runtimeForensicsPresent: await runtimeForensicsRegistered({ projectRoot: rootDir }),
+        });
+      }
       appendRiskEscalationSegment(rescuedRouteSummary);
     }
     const sharedState = {
@@ -1688,6 +1366,7 @@ async function main() {
     escalationConfig,
     sessionId,
     indexGeneratedAtMs,
+    historySignals,
   });
   await seedHelperCaches({
     rootDir,
@@ -1878,62 +1557,6 @@ async function prepareTaskRoute({
 const UNIC_DECISION_CLI_PATH = path.join(__routeTaskDir, 'unic-decision.mjs');
 const DECISION_SHADOW_TIMEOUT_CAP_MS = 3000;
 
-// Route-side shadow questions — mirror of the DECISION_REGISTRY entries owned
-// by taskRouting outside the preflight bundle (src/decision/registry.js).
-// Candidates are protocol-local labels, not user-facing prose.
-const ROUTE_SHADOW_QUESTIONS = Object.freeze([
-  {
-    decisionKey: 'route.intent-kind.v1',
-    family: 'route',
-    kind: 'choice',
-    instruction: 'Intent kind for the route: informational | mutation | investigation | review | delivery.',
-    candidates: ['informational', 'mutation', 'investigation', 'review', 'delivery'],
-  },
-  {
-    decisionKey: 'route.rigor.v1',
-    family: 'rigor',
-    kind: 'score',
-    instruction: 'R0-R4 rigor recommendation inside deterministic floors.',
-    candidates: ['r0', 'r1', 'r2', 'r3', 'r4'],
-  },
-  {
-    decisionKey: 'resume.next-action.v1',
-    family: 'resume',
-    kind: 'choice',
-    instruction: 'Next resumable action at the continuation boundary.',
-    // deriveNextAction vocabulary (read from source); the rescue-bias override
-    // 'execute-current-milestone' can overwrite nextActionType post-derivation —
-    // baseline compare then scores 'disagree', which is a real signal, not noise.
-    candidates: [
-      'ask-user-confirmation',
-      'run-primary-verification',
-      'run-fallback-verification',
-      'pull-indexed-context',
-      'read-skill-instructions',
-      'inspect-structure',
-    ],
-  },
-  {
-    decisionKey: 'verify.depth.v1',
-    family: 'verify',
-    kind: 'choice',
-    instruction: 'Verification depth among allowed levels.',
-    candidates: ['sanity', 'targeted', 'impact', 'full'],
-  },
-  // NOT wired — recorded per migration-backlog review:
-  //   capability.impact.v1 — noul kind; no threshold baseline exists on
-  //     routeSummary (capabilityPolicy.recommended is unpopulated upstream), so
-  //     the question has no comparison value.
-  //   learn.candidate-class.v1 — reserved for the memoryV2 `decision` plane
-  //     (memoryFlags.js), not the route boundary.
-]);
-
-// Only families whose resolved stage is not 'off' get a question.
-export function buildShadowDecisionQuestions(config = null) {
-  return ROUTE_SHADOW_QUESTIONS
-    .filter((q) => resolveDecisionFamilyStage(config, q.family) !== 'off')
-    .map(({ family, ...question }) => question);
-}
 
 // Probability → band for receipts. Bands only; raw probabilities never leave
 // the adapter result.
@@ -1946,6 +1569,11 @@ function probabilityBand(value) {
 
 // Deterministic baselines the shadow answers are compared against. Only fields
 // the deterministic route already computes; null baseline → 'unknown'.
+// BL-017: the adopted families map to the fields the route already resolved —
+// playbook-select → playbookId ('none' when unrouted), laneDeepening →
+// executionMode. The review/cross-check/verification-depth baselines are
+// produced by later wave modules; until then their baseline stays null and
+// receipts record bands + agreement 'unknown' — real data, not fabricated.
 function shadowBaselineFor(decisionKey, routeSummary) {
   if (decisionKey === 'route.intent-kind.v1') return routeSummary?.intent?.kind ?? null;
   if (decisionKey === 'route.rigor.v1') return routeSummary?.execution?.rigor ?? null;
@@ -1960,6 +1588,17 @@ function shadowBaselineFor(decisionKey, routeSummary) {
       ?? routeSummary?.resolvedVerificationPlan?.depth
       ?? null;
   }
+  if (decisionKey === 'playbook.select.v1') {
+    return routeSummary?.playbookId ?? 'none';
+  }
+  if (decisionKey === 'lane.deepening.v1') {
+    return routeSummary?.executionMode ?? null;
+  }
+  // BL-019: the deterministic pick is the effective tier — measuredTier when
+  // the promoted map already owns the route, else the static modelTier.
+  if (decisionKey === 'tier.selection.v1') {
+    return routeSummary?.measuredTier ?? routeSummary?.executionContract?.modelTier ?? null;
+  }
   return null;
 }
 
@@ -1976,8 +1615,9 @@ function answerCandidateLabel(answer, question) {
 
 // Fold a CLI batch result into the redacted receipt shape (FR-009):
 // {decisionKeys, probabilityBands, outcomeClass, checkpoint, latencyClass,
-//  fallbackCode, agreement}. Never carries state text, prompts, or secrets.
-function buildDecisionShadowReceipt({ stage, result, routeSummary, questions = [] }) {
+// fallbackCode, agreement, batchId}. Never carries state text, prompts, or
+// secrets.
+function buildDecisionShadowReceipt({ stage, result, routeSummary, questions = [], batchId = null }) {
   const questionByKey = new Map(questions.map((q) => [q.decisionKey, q]));
   const answers = Array.isArray(result?.answers) ? result.answers : [];
   const probabilityBands = {};
@@ -2006,9 +1646,69 @@ function buildDecisionShadowReceipt({ stage, result, routeSummary, questions = [
     latencyClass: result?.latencyClass ?? 'unknown',
     fallbackCode: result?.fallbackCode ?? null,
     agreement,
+    batchId,
   };
 }
 
+// BL-017 (SPEC FR-005): per-question receipt rows — one decisions.tsv append
+// per enabled question in the batch, all sharing `batchId` (carried inside the
+// checkpoint cell: the receipt signature is consumed unchanged). An answered
+// question scores its own agreement against the deterministic baseline; an
+// adapter miss keeps fallbackCode 'no-answer' rather than dropping the row —
+// a silent gap is how coverage numbers go stale. Typed failures ride kind
+// 'fallback' so the deterministic policy visibly stayed in force.
+async function appendPerQuestionShadowReceipts({
+  rootDir,
+  stage,
+  result,
+  routeSummary,
+  questions,
+  batchId,
+  appendDecisionImpl,
+  now,
+}) {
+  const append = appendDecisionImpl ?? appendDecisionReceipt;
+  const answers = Array.isArray(result?.answers) ? result.answers : [];
+  const answerByKey = new Map(
+    answers
+      .filter((a) => a?.decisionKey && a?.validationStatus === 'valid')
+      .map((a) => [a.decisionKey, a]),
+  );
+  const outcomeClass = result?.status ?? 'unavailable';
+  const kind = outcomeClass === 'unavailable' ? 'fallback' : 'shadow';
+  const checkpointCell = `${result?.checkpoint ?? 'no-checkpoint'} batch=${batchId}`;
+  for (const question of questions) {
+    const answer = answerByKey.get(question.decisionKey) ?? null;
+    let agreement = 'unknown';
+    if (answer) {
+      const label = answerCandidateLabel(answer, question);
+      const baseline = shadowBaselineFor(question.decisionKey, routeSummary);
+      if (label !== null && baseline !== null && baseline !== undefined) {
+        agreement = label.toLowerCase() === String(baseline).toLowerCase()
+          ? 'agree'
+          : 'disagree';
+      }
+    }
+    const fallbackCode = result?.fallbackCode ?? (answer ? null : 'no-answer');
+    try {
+      await append(rootDir, {
+        kind,
+        boundary: 'route',
+        stage,
+        outcomeClass,
+        checkpoint: checkpointCell,
+        latencyClass: result?.latencyClass ?? 'unknown',
+        decisionKeys: [question.decisionKey],
+        agreement,
+        fallbackCode,
+        now: now(),
+      });
+    } catch {
+      // Receipt loss is advisory — never fail the route over telemetry.
+    }
+  }
+}
+
 /**
  * Run the decision-plane shadow adapter for a finalized route. Returns the
  * redacted receipt, or null when the plane is off / no family is enabled.
@@ -2041,8 +1741,12 @@ export async function runRouteDecisionShadow({
       : DECISION_SHADOW_TIMEOUT_CAP_MS) + 1000,
     DECISION_SHADOW_TIMEOUT_CAP_MS + 1000,
   );
+  const batchId = `route-shadow-${now().toString(36)}-${crypto.randomBytes(3).toString('hex')}`;
+  // BL-017: historySignals feed laneDeepening/verificationDepth features —
+  // bounded counters only (BL-013 contract: never transcript text).
+  const hist = routeSummary?.historySignals ?? null;
   const batch = {
-    batchId: `route-shadow-${now().toString(36)}`,
+    batchId,
     boundary: 'route',
     deadlineMs: Math.max(500, timeoutMs - 1000),
     statePacket: {
@@ -2052,6 +1756,15 @@ export async function runRouteDecisionShadow({
       targetClass: routingContext.targetFile ? 'file-target' : 'no-target',
       execution: routeSummary?.executionMode ? { mode: routeSummary.executionMode } : {},
       riskSignals: routeSummary?.riskFloor?.codes ?? [],
+      history: hist
+        ? {
+            priorAttemptCount: Math.max(0, Math.trunc(hist.priorAttemptCount ?? 0) || 0),
+            fixLoopCount: Math.max(0, Math.trunc(hist.fixLoopCount ?? 0) || 0),
+            sameSymptomReask: hist.sameSymptomReask === true,
+            correctionEvents: Math.max(0, Math.trunc(hist.correctionEvents ?? hist.correctionCount ?? 0) || 0),
+            degraded: hist.degraded === true,
+          }
+        : null,
     },
     questions,
   };
@@ -2088,27 +1801,145 @@ export async function runRouteDecisionShadow({
     };
   }
 
-  const receipt = buildDecisionShadowReceipt({ stage, result, routeSummary, questions });
-  // Append-only receipt row (decisions.tsv): codes/bands only via the ledger's
-  // typed receipt writer (statically imported above alongside recordLedgerEvent).
+  const receipt = buildDecisionShadowReceipt({
+    stage,
+    result,
+    routeSummary,
+    questions,
+    batchId,
+  });
+  // BL-017: batched emission — one append-only decisions.tsv row per enabled
+  // question sharing batchId; codes/bands only via the ledger's typed receipt
+  // writer (statically imported above alongside recordLedgerEvent). Receipt
+
+  // append failures stay advisory inside the helper.
+  await appendPerQuestionShadowReceipts({
+    rootDir,
+    stage,
+    result,
+    routeSummary,
+    questions,
+    batchId,
+    appendDecisionImpl,
+    now,
+  });
+  // BL-019 (SPEC FR-001): the measured-vs-static A/B row — logged once per
+  // route whenever a derived tier-map.json exists and the tier-selection
+  // family isn't stage-off (inherited shadow stage). The raw map pick is
+  // logged even on 'hold' (the A/B collection is the point); the static tier
+  // is rebuilt from the contract literal so a promoted modelTier can't fake
+  // its own baseline. Bounded cells only — tier names + counts + promotion.
+  if (resolveDecisionFamilyStage(config, 'tier-selection') !== 'off') {
+    try {
+      const tierMap = await loadTierMap(rootDir);
+      if (tierMap) {
+        const staticTier = buildExecutionContract(routeSummary?.executionMode)?.modelTier
+          ?? routeSummary?.executionContract?.modelTier
+          ?? null;
+        const measuredPick = tierMap.byMode?.[routeSummary?.executionMode] ?? null;
+        const append = appendDecisionImpl ?? appendDecisionReceipt;
+        await append(rootDir, {
+          kind: 'shadow',
+          boundary: 'tier-selection',
+          stage,
+          outcomeClass: 'tier-ab',
+          checkpoint: `batch=${batchId} promotion=${tierMap.decision} joined=${tierMap.joinedRoutes} agreement=${(tierMap.agreement ?? 0).toFixed(2)} static=${staticTier ?? 'unknown'} measured=${measuredPick ?? 'none'}`,
+          latencyClass: 'fast',
+          decisionKeys: ['tier.selection.v1'],
+          agreement: staticTier && measuredPick
+            ? (measuredPick === staticTier ? 'agree' : 'disagree')
+            : 'unknown',
+          fallbackCode: measuredPick ? null : 'no-measured-pick',
+          now: now(),
+        });
+      }
+    } catch {
+      // Receipt loss is advisory — never fail the route over telemetry.
+    }
+  }
+  return receipt;
+}
+
+// BL-018 (SPEC FR-006): the bounded-question `ask` seam — one batch through
+// the installed unic-decision CLI (the same adapter the shadow pass spawns).
+// Shared by the fix-loop escalation (answer consumed) and the C89-005
+// role-advice consult (answer recorded as suggest-only shadow). Every failure
+// degrades to a typed 'unavailable' result → deterministic fallback, never a
+// throw.
+async function askUnicDecisionBatch({
+  rootDir = process.cwd(),
+  config = null,
+  batch = null,
+  spawnImpl = spawnSync,
+} = {}) {
   try {
-    const append = appendDecisionImpl ?? appendDecisionReceipt;
-    await append(rootDir, {
-      kind: 'shadow',
-      boundary: 'route',
-      stage,
-      outcomeClass: receipt.outcomeClass,
-      checkpoint: receipt.checkpoint,
-      latencyClass: receipt.latencyClass,
-      decisionKeys: receipt.decisionKeys,
-      agreement: receipt.agreement,
-      fallbackCode: receipt.fallbackCode,
-      now: now(),
+    const cliPath = process.env.UKIT_DECISION_CLI_PATH || UNIC_DECISION_CLI_PATH;
+    const timeoutMs = Math.min(
+      Math.max(500, (Number.isFinite(batch?.deadlineMs) ? batch.deadlineMs : 2000) + 1000),
+      DECISION_SHADOW_TIMEOUT_CAP_MS + 1000,
+    );
+    const spawned = spawnImpl(
+      process.execPath,
+      [cliPath, '--root', rootDir],
+      {
+        cwd: rootDir,
+        input: JSON.stringify(batch),
+        encoding: 'utf8',
+        timeout: timeoutMs,
+      },
+    );
+    if (spawned && !spawned.error && spawned.status === 0 && spawned.stdout) {
+      return JSON.parse(spawned.stdout);
+    }
+    return { status: 'unavailable', fallbackCode: 'adapter-spawn-failed', answers: [] };
+  } catch {
+    return { status: 'unavailable', fallbackCode: 'adapter-spawn-failed', answers: [] };
+  }
+}
+
+// Whether a `runtime-forensics` playbook file resolves through the registry —
+// BL-023 owns the file; until it lands every install degrades to 'missing'
+// and the lane-deepening still applies (SPEC §14).
+async function runtimeForensicsRegistered({ projectRoot = null } = {}) {
+  try {
+    const records = await loadRegistry({ projectRoot, homeDir: os.homedir() });
+    return records.some((record) => record?.frontmatterValid && record?.playbookId === 'runtime-forensics');
+  } catch {
+    return false;
+  }
+}
+// BL-017 (SPEC FR-005, hook path): the detached shadow pass skill-router.sh
+// spawns per emitted route (`node route-task.mjs --decision-shadow --root R`).
+// It re-reads the persisted route state + merged config and replays the same
+// stage-gated adapter batch the helper path runs inline — receipts land via
+// appendDecisionReceipt; the deterministic route was already written by the
+// parent so nothing here can rewrite it. Fire-and-forget: swallows every
+// failure (typed fallback rows still land through runRouteDecisionShadow),
+// prints nothing, exits 0.
+async function runHookPathDecisionShadow({
+  rootDir,
+  statePath,
+  targetFile = null,
+} = {}) {
+  try {
+    const state = await readJson(statePath, null);
+    const routeSummary = state?.routeSummary ?? null;
+    if (!routeSummary || typeof routeSummary !== 'object') return;
+    const config = await readMergedConfig(rootDir);
+    const routingContext = {
+      ...(state?.routingContext ?? {}),
+      targetFile,
+    };
+    await runRouteDecisionShadow({
+      rootDir,
+      config,
+      routeSummary,
+      routingContext,
     });
   } catch {
-    // Receipt loss is advisory — never fail the route over telemetry.
+    // Detached child: a failed shadow pass is observable via decisions.tsv
+    // fallback receipts or absence — never propagated.
   }
-  return receipt;
 }
 
 // --- M04.1 resumable run emit (TASK-007, SPEC §5 FR-013..FR-015) --------------
@@ -2119,24 +1950,6 @@ export async function runRouteDecisionShadow({
 // I/O — the route stays byte-identical. Every failure is advisory: routing never
 // fails over run-state persistence.
 
-// Same absent/malformed → 'off' contract as the routing.* stage resolvers; the
-// stage key lives under continuity.resumableRun (TASK-001 config block).
-export function resolveResumableRunStage(config = null) {
-  const stage = config?.continuity?.resumableRun?.stage;
-  return ROUTE_SCHEMA_STAGES.has(stage) ? stage : 'off';
-}
-
-// The logical task boundary is the explicit user prompt — a new prompt means a
-// new task, so the persisted record resets instead of merging stale plans.
-// Hashed: prompt text never persists (C10 redaction contract).
-function resumableTaskBoundary(routingContext = {}) {
-  const text = String(
-    routingContext.lastExplicitUserPromptText ?? routingContext.promptText ?? '',
-  ).trim();
-  return text
-    ? crypto.createHash('sha256').update(text).digest('hex').slice(0, 32)
-    : 'no-prompt';
-}
 
 // Session-scoped when a session id exists (one record file per session, reset by
 // taskBoundary); prompt-scoped otherwise so concurrent anonymous routes never
@@ -2251,7 +2064,16 @@ export async function emitResumableRun({
     const status = write.ok
       ? 'written'
       : (write.journaled ? 'journaled' : `skipped-${write.reason ?? 'unknown'}`);
-    const pointer = { taskId, taskBoundary, stage, status };
+    // TASK-007 (BL-009): playbook route fields ride the ledger row so
+    // outcomes/audit can join the routed playbook for this run.
+    const pointer = {
+      taskId,
+      taskBoundary,
+      stage,
+      status,
+      playbookId: routeSummary?.playbookId ?? null,
+      workGroup: routeSummary?.workGroup ?? null,
+    };
     // Ledger pointer event — same fail-closed journal discipline; advisory only.
     try {
       await recordLedgerEvent(
@@ -2279,6 +2101,13 @@ async function finalizeTaskRoute({
   projectVerification = null,
   cachedContextResult = null,
   cachedVerificationPlan = null,
+  // BL-018: injected decision/registrar seams — hook callers leave both null
+  // (real adapter + real registry); tests stub them for deterministic lanes.
+  escalationDecision = null,
+  // C89 TASK-005: injected seam for the typed delegation-advice consult
+  // ({ask, appendReceipt, override}); absent → the real unic-decision CLI
+  // spawn when the decision plane is enabled, else a typed local outcome.
+  roleAdviceDecision = null,
   useIndexedContext = true,
   previousContextSnapshot = null,
   recentOutputSnapshot = null,
@@ -2286,6 +2115,9 @@ async function finalizeTaskRoute({
   escalationConfig = null,
   sessionId = null,
   indexGeneratedAtMs = null,
+  // BL-013: precomputed bounded history struct from the caller's transcript
+  // extraction — merged into the route record additively + decisions.tsv.
+  historySignals = null,
 } = {}) {
   const absoluteRoot = path.resolve(rootDir);
   const activeSkills = preparedRoute?.activeSkills ?? [];
@@ -2358,7 +2190,47 @@ async function finalizeTaskRoute({
     routeSchemaStage: resolveRouteSchemaStage(escalationConfig),
     runtimeConfig: escalationConfig,
     resolvedWorkflowPolicy,
+    historySignals,
   });
+  // TASK-007 (BL-009): playbook resolution rides the same route signals —
+  // the registry degrades to playbookId: null + reason and never blocks the
+  // route. Same merge the hook performs via mergeResolverFields.
+  try {
+    const playbookResolution = await resolvePlaybookRoute({
+      promptText: routingContext.promptText,
+      commandText: routingContext.commandText,
+      targetFile: routingContext.targetFile ?? null,
+      executionMode: routingContext.executionMode ?? null,
+      intentMode: routingContext.intentMode ?? null,
+      escalationTriggers: routeSummary?.escalationTriggers ?? [],
+      projectRoot: absoluteRoot,
+      homeDir: os.homedir(),
+    });
+    routeSummary.playbookId = playbookResolution.playbookId;
+    routeSummary.workGroup = playbookResolution.workGroup;
+    routeSummary.playbookReason = playbookResolution.reason;
+    routeSummary.playbookLoad = playbookResolution.playbookLoad;
+    // BL-010 (ARCH Task Contract): `path` = direct|handoff; `fastPathKind` is
+    // the ARCH `none|small-feature|bug-fix` enum — named Kind because
+    // routeSummary.fastPath already carries the FR-004 eligibility object.
+    // Keys land only when a routing-table row claimed the prompt (workGroup
+    // non-null) — identical key-presence to deriveTaskRoute so schema-off /
+    // no-match routes never grow stray keys.
+    if (playbookResolution.workGroup != null) {
+      routeSummary.path = playbookResolution.path;
+      routeSummary.fastPathKind = playbookResolution.fastPath;
+    } else {
+      delete routeSummary.path;
+      delete routeSummary.fastPathKind;
+    }
+  } catch {
+    routeSummary.playbookId = null;
+    routeSummary.workGroup = null;
+    routeSummary.playbookReason = 'registry-error';
+    routeSummary.playbookLoad = null;
+    delete routeSummary.path;
+    delete routeSummary.fastPathKind;
+  }
   routeSummary.continuationState = advanceContinuationState(
     routeSummary.continuationState,
     previousRouteSummary?.continuationState ?? null,
@@ -2378,10 +2250,79 @@ async function finalizeTaskRoute({
     delete routeSummary.riskEscalation;
   }
   applyRescueBiasToRouteSummary(routeSummary);
+  // BL-019 (SPEC FR-001): fold the persisted measured map into the route —
+  // measuredTier is always emitted (nullable); the authoritative modelTier
+  // follows the map ONLY when tier-map.json says 'promote'. Runs before the
+  // escalation re-derives tierLane so the printed lane reflects the final
+  // tier; never throws (absent/corrupt artifact → static stays).
+  await applyMeasuredTier({ projectRoot: absoluteRoot, routeSummary });
   applyEscalationToRouteSummary(routeSummary, {
     config: escalationConfig,
     targetFile: routingContext.targetFile ?? null,
   });
+  // BL-018 (SPEC FR-006): fix-loop escalation. historySignals.fixLoopCount is
+  // fingerprint-joined (same routeFingerprint/requestKey, never session-wide);
+  // at debugLoopThreshold the lane deepens via the laneDeepening/
+  // verificationDepth question, endpoint-down → deterministic fallback
+  // (fallback:tier-bump), deeper-lane exhaustion → BLOCKED. Runs after the
+  // tier-bump application so both fallback surfaces coexist honestly.
+  // Computed now — BEFORE the escalation writes its additive fields — so the
+  // stamped escalatedRouteFingerprint is exactly the fingerprint
+  // createSharedRouteState persists on this emission (the fingerprint payload
+  // excludes the escalation fields, so pre- and post-escalation agree).
+  const routeFingerprint = buildRouteStateFingerprint({
+    activeSkills,
+    routingContext,
+    previousContext: previousContextSnapshot,
+    recentOutput: recentOutputSnapshot,
+    routeSummary,
+  });
+  const laneEscalationDue = isFixLoopEscalationDue({
+    historySignals: routeSummary.historySignals,
+    config: escalationConfig,
+  });
+  if (laneEscalationDue) {
+    await applyFixLoopEscalation({
+      routeSummary,
+      routingContext,
+      previousRouteSummary,
+      routeFingerprint,
+      config: escalationConfig,
+      ask: escalationDecision?.ask
+        ?? (({ batch }) => askUnicDecisionBatch({
+          rootDir: absoluteRoot,
+          config: escalationConfig,
+          batch,
+        })),
+      appendReceipt: escalationDecision?.appendReceipt
+        ?? ((receipt) => appendDecisionReceipt(absoluteRoot, receipt)),
+      runtimeForensicsPresent: escalationDecision?.runtimeForensicsPresent
+        ?? await runtimeForensicsRegistered({ projectRoot: absoluteRoot }),
+    });
+  }
+  // ledger's typed receipt writer (consumed signature, ledger unchanged).
+  // Emitted only when extraction actually ran on a transcript pointer — a
+  // route with no transcript (missing-transcript-path) stays byte-identical:
+  // no receipt, no history row. A real but unreadable transcript still lands
+  // a degraded receipt so coverage is measurable. Never carries text.
+  if (routeSummary.historySignals && routeSummary.historySignals.reason !== 'missing-transcript-path') {
+    try {
+      const hist = routeSummary.historySignals;
+      await appendDecisionReceipt(absoluteRoot, {
+        kind: 'shadow',
+        boundary: 'route-history',
+        stage: 'deterministic',
+        outcomeClass: hist.degraded ? 'degraded' : 'ok',
+        checkpoint: `hist prior=${hist.priorAttemptCount ?? 0} loop=${hist.fixLoopCount ?? 0} reask=${hist.sameSymptomReask ? 'yes' : 'no'} corrections=${hist.correctionEvents ?? 0}`,
+        latencyClass: 'fast',
+        decisionKeys: ['history.signals'],
+        agreement: 'n/a',
+        fallbackCode: hist.degraded ? (hist.reason ?? 'degraded') : null,
+      });
+    } catch {
+      // Receipt loss is advisory — never fail the route over telemetry.
+    }
+  }
   appendRiskEscalationSegment(routeSummary);
   // M07 (TASK-005): stage-gated decision-plane shadow call. 'off' → null and
   // nothing else happens (byte-identical route); any other stage → bounded
@@ -2395,6 +2336,34 @@ async function finalizeTaskRoute({
   if (decisionShadow) {
     routeSummary.decisionPlane = decisionShadow;
   }
+  // C89 TASK-005 (SPEC §6 FR-04): typed delegation advice consult — the
+  // optional unic-decision round only ever answers the owner-bounded role
+  // question through the installed CLI; the deterministic fields the route
+  // already carries stay authoritative, every failure records a typed
+  // advice.model outcome, and the decisions.tsv row lands via
+  // appendDecisionReceipt (never silent).
+  if (routeSummary?.delegationAdvice) {
+    try {
+      const roleAdviceAsk = roleAdviceDecision?.ask
+        ?? (resolveDecisionPlaneStage(escalationConfig) !== 'off'
+          ? (({ batch }) => askUnicDecisionBatch({
+              rootDir: absoluteRoot,
+              config: escalationConfig,
+              batch,
+            }))
+          : null);
+      await applyRoleAdviceConsult({
+        routeSummary,
+        config: escalationConfig,
+        ask: roleAdviceAsk,
+        appendReceipt: roleAdviceDecision?.appendReceipt
+          ?? ((receipt) => appendDecisionReceipt(absoluteRoot, receipt)),
+        override: roleAdviceDecision?.override ?? null,
+      });
+    } catch {
+      // Advisory consult — never fail or mutate the route over a shadow ask.
+    }
+  }
   // M04.1 (TASK-007): stage-gated resumable-run emit. 'off' → null and nothing
   // else happens (byte-identical route); any other stage → the C10 record is
   // persisted/updated under .ukit/storage/runs/ and a bounded pointer lands on
@@ -2443,6 +2412,18 @@ function printRouteState(state) {
   if (recentOutputDisplay) {
     console.log(`recent-output: ${recentOutputDisplay}`);
   }
+  // BL-013: bounded history line — counters/enums only, never transcript text.
+  // Printed whenever extraction ran (a degraded struct still reports honestly).
+  if (state.routeSummary?.historySignals) {
+    const hist = state.routeSummary.historySignals;
+    console.log(
+      `history: prior=${hist.priorAttemptCount ?? 0}`
+      + ` loop=${hist.fixLoopCount ?? 0}`
+      + ` reask=${hist.sameSymptomReask ? 'yes' : 'no'}`
+      + ` corrections=${hist.correctionEvents ?? 0}`
+      + (hist.degraded ? ` degraded=${hist.reason ?? 'unknown'}` : ''),
+    );
+  }
   console.log(`summary: ${compactSummary}`);
   if (state.routeSummary?.executionContract?.modelTier) {
     console.log(`modelTier: ${state.routeSummary.executionContract.modelTier}`);
@@ -2456,6 +2437,14 @@ function printRouteState(state) {
       console.log(`escalationReason: ${state.routeSummary.escalationReason}`);
     }
   }
+  // BL-018: the deeper lane surface — 'blocked' is the exhaustion verdict,
+  // otherwise a lane from FIX_LOOP_LANE_CANDIDATES.
+  if (state.routeSummary?.escalatedLane) {
+    console.log(`escalatedLane: ${state.routeSummary.escalatedLane}`);
+    if (state.routeSummary.escalateReason) {
+      console.log(`escalateReason: ${state.routeSummary.escalateReason}`);
+    }
+  }
   if (state.routeSummary?.visionLane) {
     console.log(`visionLane: ${state.routeSummary.visionLane}`);
     if (state.routeSummary.visionModel) {
@@ -2479,6 +2468,12 @@ function printRouteState(state) {
   }
   // v3 advisory blocks (SPEC-playbook-todo / SPEC-principle-index / SPEC-model-roles):
   // additive stdout text, byte-stable for unchanged config.
+  // TASK-007 (BL-009): playbook surface — the instruction-mediated load cue
+  // Codex and print consumers read. playbookId only prints when a playbook
+  // resolved; the degrade reason stays machine-side on the route record.
+  if (state.routeSummary?.playbookId) {
+    console.log(`playbook: ${state.routeSummary.playbookId} — read playbooks/${state.routeSummary.playbookId}.md and run its steps verbatim`);
+  }
   if (state.routeSummary?.workflowPolicyName) {
     console.log(`workflow: ${state.routeSummary.workflowPolicyName} — copy steps verbatim into your todo list; skipped steps keep skip:<reason>`);
   }
@@ -3352,6 +3347,265 @@ function deriveDelegationRecommendation({
 
   return null;
 }
+// --- C89 TASK-005 (SPEC §6 FR-04, §11): typed delegation advice (shadow) ------
+// Lockstep mirror of src/index/taskRouting.js — wraps the single route owner
+// (deriveDelegationRecommendation above); never a second router, never a
+// spawn path. Gated on `subagentOrchestrator.roleAdvice.stage`
+// ('off'/malformed → null, zero cost); any other stage emits the typed
+// advisory struct. The optional unic-decision consult
+// (applyRoleAdviceConsult) only ever answers an owner-bounded enum question;
+// deterministic fields stay authoritative and every failure records a typed
+// outcome on advice.model — never silent.
+const DELEGATION_ADVICE_POLICY_VERSION = 'role-advice.v1';
+const DELEGATION_ADVICE_DECISION_KEY = 'route.delegation-role.v1';
+// SPEC §6 initial role vocabulary — maps onto existing frontmatter agents,
+// no new agent file (retriever/reviewer reserved for role-bearing lanes;
+// C89-006 consumes role+contextMode only as advisory unless host-verified).
+const DELEGATION_ADVICE_ROLES = Object.freeze(['retriever', 'reasoner', 'reviewer']);
+const DELEGATION_ADVICE_CONTEXT_MODES = Object.freeze(['isolated', 'curated']);
+
+// Delegation hint → {role, contextMode, reasonCode}. The owner hints all carry
+// reasoning work; the noisy debug lane needs isolation from the noisy loop,
+// the plan/feature lanes need the curated indexed bundle.
+const DELEGATION_HINT_ROLES = Object.freeze({
+  'ukit-small-task-maintainer': { role: 'reasoner', contextMode: 'isolated', reasonCode: 'small-task-maintenance' },
+  'subagent-driven-development': { role: 'reasoner', contextMode: 'curated', reasonCode: 'planned-batch-execution' },
+  'bug-debugger': { role: 'reasoner', contextMode: 'isolated', reasonCode: 'noisy-debug-loop' },
+  'feature-implementer': { role: 'reasoner', contextMode: 'curated', reasonCode: 'broad-implementation-lane' },
+});
+
+// Mirror of runtimeConfig.js resolveSubagentOrchestratorStage — resolves
+// `subagentOrchestrator.<key>.stage`; absent/malformed config or a bad key
+// resolves 'off' so a bad config can never promote a slice.
+function resolveSubagentOrchestratorStage(config = null, key = 'telemetry') {
+  if (typeof key !== 'string' || key.trim() === '') return 'off';
+  const node = config?.subagentOrchestrator?.[key];
+  const stage = node?.stage;
+  return ROUTE_SCHEMA_STAGES.has(stage) ? stage : 'off';
+}
+
+/**
+ * Typed delegation advice (SPEC §6 FR-04). Reads the deterministic
+ * `deriveDelegationRecommendation` verdict and annotates it as the typed
+ * shadow receipt {delegate, role, contextMode, confidence, reasonCodes,
+ * policyVersion, enforcement} — plus the audit fields hint/stage.
+ *
+ * `enforcement` is 'advisory' on every shipped host: this lane never spawns
+ * and C89-006 owns the host-capability check that could one day mark a lane
+ * 'enforced'. Trivial work resolves local by the deterministic fast path —
+ * the same `null` the owner returns, typed.
+ *
+ * @returns {object|null} null when the roleAdvice stage is off/malformed.
+ */
+export function deriveTypedDelegationAdvice({
+  activeSkills = [],
+  routingContext = {},
+  contextRecommendation = null,
+  verificationRecommendation = null,
+  autonomyLevel = 'balanced',
+  riskFloor = null,
+  config = null,
+} = {}) {
+  const stage = resolveSubagentOrchestratorStage(config, 'roleAdvice');
+  if (stage === 'off') {
+    return null;
+  }
+
+  const recommendation = deriveDelegationRecommendation({
+    activeSkills,
+    routingContext,
+    contextRecommendation,
+    verificationRecommendation,
+    autonomyLevel,
+  });
+
+  const hint = recommendation?.hint ?? null;
+  const reasonCodes = [];
+  if (routingContext.taskType === 'trivial') {
+    reasonCodes.push('trivial-fast-path');
+  } else if (hint && DELEGATION_HINT_ROLES[hint]) {
+    reasonCodes.push(DELEGATION_HINT_ROLES[hint].reasonCode);
+  } else if (recommendation) {
+    reasonCodes.push('owner-recommendation');
+  } else {
+    reasonCodes.push('no-delegation-signal');
+  }
+  if (riskFloor?.floor === 'high-risk') {
+    reasonCodes.push('risk-floor-high-risk');
+  }
+
+  const delegate = hint !== null;
+  let role = null;
+  let contextMode = null;
+  if (delegate) {
+    if (routingContext.executionMode === 'review-release') {
+      // SPEC §6: reviewer lanes default isolated — the reviewer receives the
+      // task requirements/diff/tests/evidence, not implementer narrative.
+      role = 'reviewer';
+      contextMode = 'isolated';
+      reasonCodes.push('review-release-lane');
+    } else {
+      const mapped = DELEGATION_HINT_ROLES[hint] ?? { role: 'reasoner', contextMode: 'curated' };
+      role = mapped.role;
+      contextMode = mapped.contextMode;
+    }
+  }
+
+  const confidence = routingContext.taskType === 'trivial'
+    ? 0.95
+    : delegate ? 0.9 : 0.6;
+
+  return {
+    delegate,
+    role,
+    contextMode,
+    confidence,
+    reasonCodes,
+    policyVersion: DELEGATION_ADVICE_POLICY_VERSION,
+    enforcement: 'advisory',
+    stage,
+    hint,
+  };
+}
+
+function delegationRiskFloorSignals(routeSummary) {
+  const codes = routeSummary?.riskFloor?.codes;
+  return Array.isArray(codes) ? codes : [];
+}
+
+/**
+ * Optional bounded consult + recorded override for the typed advice (SPEC §6).
+ * The unic-decision question is one owner-bounded choice over the role
+ * shortlist — enum-only, redacted, never tools/spawn. Any auth rejection,
+ * timeout, invalid or off-shortlist answer lands on `advice.model` as a typed
+ * outcome; the deterministic fields are never rewritten and no receipt write
+ * is silent (appendReceipt seam fires whenever a consult ran).
+ *
+ * The main-agent override is recorded verbatim (role + reason) when the role
+ * is in the enum — stored for the later accepting lane; it never mutates the
+ * deterministic advice. The hard risk floor is deterministic state on the
+ * advice itself, so conflicting model noise can never flip a local route.
+ *
+ * Returns true when the route was annotated (a consult ran or an override was
+ * recorded); false when no advice exists or the consult never ran.
+ */
+export async function applyRoleAdviceConsult({
+  routeSummary = null,
+  config = null,
+  ask = null,
+  appendReceipt = null,
+  override = null,
+  now = () => Date.now(),
+} = {}) {
+  const advice = routeSummary?.delegationAdvice;
+  if (!advice || typeof advice !== 'object') {
+    return false;
+  }
+
+  if (override && typeof override === 'object'
+    && DELEGATION_ADVICE_ROLES.includes(override.role)
+    && typeof override.reason === 'string' && override.reason.trim()) {
+    advice.override = { role: override.role, reason: override.reason.trim() };
+  }
+
+  const emit = (receipt) => {
+    if (typeof appendReceipt !== 'function') return;
+    try {
+      const pending = appendReceipt(receipt);
+      if (pending?.catch) pending.catch(() => {});
+    } catch {
+      // Receipt loss is advisory — the typed advice stands regardless.
+    }
+  };
+
+  // Local routes never consult — there is no role to suggest and the
+  // deterministic fast path needs no shadow annotation.
+  if (advice.delegate !== true || typeof advice.role !== 'string') {
+    return true;
+  }
+
+  // An explicit ask seam is the consult consent; the ambient path only builds
+  // a client when the decision plane itself is enabled, so a role-advice-only
+  // config never triggers endpoint work.
+  const explicitAsk = typeof ask === 'function';
+  if (!explicitAsk && resolveDecisionPlaneStage(config) === 'off') {
+    return true;
+  }
+
+  // Owner-bounded shortlist: the model may only answer inside the
+  // deterministic candidate set — a singleton when the owner has one role.
+  const candidates = [advice.role];
+  const batch = {
+    batchId: `role-advice-${now().toString(36)}`,
+    boundary: 'role-advice',
+    deadlineMs: Math.max(
+      500,
+      Number.isFinite(config?.decisionPlane?.timeoutMs) ? config.decisionPlane.timeoutMs : 2000,
+    ),
+    statePacket: {
+      stateVersion: 1,
+      taskClass: routeSummary?.routingContext?.taskType ?? 'unknown',
+      execution: routeSummary?.executionMode ? { mode: routeSummary.executionMode } : {},
+      riskSignals: delegationRiskFloorSignals(routeSummary),
+    },
+    questions: [
+      {
+        decisionKey: DELEGATION_ADVICE_DECISION_KEY,
+        kind: 'choice',
+        instruction: 'Pick the delegation role from the owner-bounded shortlist.',
+        candidates,
+      },
+    ],
+  };
+
+  let result = null;
+  try {
+    result = await ask({ batch });
+  } catch {
+    result = null;
+  }
+  if (!result) {
+    result = { status: 'unavailable', fallbackCode: 'ask-failed', answers: [] };
+  }
+
+  // Fold the typed outcome: only a valid in-shortlist answer becomes a
+  // suggestion; everything else keeps suggestedRole null with a fallback code.
+  const answers = Array.isArray(result.answers) ? result.answers : [];
+  let suggestedRole = null;
+  for (const answer of answers) {
+    if (answer?.decisionKey !== DELEGATION_ADVICE_DECISION_KEY) continue;
+    if (answer?.validationStatus !== 'valid') continue;
+    const value = typeof answer?.value === 'string' ? answer.value.trim() : null;
+    if (value && candidates.includes(value)) {
+      suggestedRole = value;
+    }
+  }
+  const outcomeClass = typeof result.status === 'string' ? result.status : 'unavailable';
+  advice.model = {
+    status: outcomeClass,
+    suggestedRole,
+    agreement: suggestedRole === null
+      ? 'unknown'
+      : suggestedRole === advice.role ? 'agree' : 'disagree',
+    fallbackCode: result.fallbackCode
+      ?? (suggestedRole === null && outcomeClass === 'accepted' ? 'off-shortlist' : null),
+  };
+
+  emit({
+    kind: outcomeClass === 'unavailable' ? 'fallback' : 'shadow',
+    boundary: 'role-advice',
+    stage: advice.stage,
+    outcomeClass,
+    checkpoint: `role-advice batch=${batch.batchId}`,
+    latencyClass: result.latencyClass ?? 'unknown',
+    decisionKeys: [DELEGATION_ADVICE_DECISION_KEY],
+    agreement: advice.model.agreement,
+    fallbackCode: advice.model.fallbackCode,
+    now: now(),
+  });
+  return true;
+}
+
 
 function buildRouteSummary({
   activeSkills = [],
@@ -3363,6 +3617,9 @@ function buildRouteSummary({
   routeSchemaStage = 'off',
   runtimeConfig = null,
   resolvedWorkflowPolicy = null,
+  // BL-013: precomputed bounded history struct — merged additively via the
+  // shared resolver below. Absent/null → no field, byte-identical route.
+  historySignals = null,
 } = {}) {
   const autonomyLevel = routingContext.autonomyLevel ?? 'balanced';
   const delegationRecommendation = deriveDelegationRecommendation({
@@ -3417,21 +3674,51 @@ function buildRouteSummary({
     nextActionType: nextAction?.type ?? null,
     completionState,
   });
-  // FR-003 (M01.2'): riskFloor is a top-level additive field emitted whenever ANY
-  // of rigor/fastPath/escalation stages is on — fastPath/escalation consumers read
-  // it even when routeSchema is off. All three off → absent, byte-identical route.
-  const riskStageOn = ['rigor', 'fastPath', 'escalation']
-    .some((key) => resolveRouteStage(runtimeConfig, key) !== 'off');
-  const riskFloor = riskStageOn
-    ? deriveRiskFloor({
-        promptText: routingContext.promptText,
-        commandText: routingContext.commandText,
-        targetFile: routingContext.targetFile ?? null,
-        executionMode,
-        activeSkillIds: activeSkills.map((entry) => entry.id),
-        contextPreview: contextRecommendation?.preview ?? null,
-      })
-    : null;
+  // TASK-004 (BL-006): one shared resolver derives the deterministic route
+  // fields — the identical object skill-router.sh merges into hook state.
+  // The explicit routeSchemaStage param remains authoritative for the resolved
+  // groups (callers may force it independent of runtimeConfig); every other
+  // stage read comes from runtimeConfig inside deriveRouteFields.
+  const routeFields = deriveRouteFields({
+    promptText: routingContext.promptText,
+    commandText: routingContext.commandText,
+    targetFile: routingContext.targetFile ?? null,
+    intentMode: routingContext.intentMode ?? null,
+    taskType,
+    executionMode,
+    activeSkillIds: activeSkills.map((entry) => entry.id),
+    verificationRecommendation,
+    contextPreview: contextRecommendation?.preview ?? null,
+    executionScores: routingContext.executionScores ?? {},
+    lastExplicitUserPromptText: routingContext.lastExplicitUserPromptText ?? null,
+    historySignals,
+    config: routeSchemaStage === 'off'
+      ? runtimeConfig
+      : {
+          ...(runtimeConfig && typeof runtimeConfig === 'object' ? runtimeConfig : {}),
+          routing: {
+            ...(runtimeConfig?.routing && typeof runtimeConfig.routing === 'object'
+              ? runtimeConfig.routing
+              : {}),
+            routeSchema: { stage: routeSchemaStage },
+          },
+        },
+  });
+  const riskFloor = routeFields.riskFloor;
+  const fastPath = routeFields.fastPath;
+  const resolvedRouteFields = routeFields.resolved;
+  // C89 TASK-005 (SPEC §6/§11): typed delegation advice shadow — additive,
+  // gated on subagentOrchestrator.roleAdvice.stage ('off' → null, route
+  // byte-identical). Wraps the deterministic owner verdict; never spawns.
+  const delegationAdvice = deriveTypedDelegationAdvice({
+    activeSkills,
+    routingContext,
+    contextRecommendation,
+    verificationRecommendation,
+    autonomyLevel,
+    riskFloor,
+    config: runtimeConfig,
+  });
   const riskSegment = formatRiskFloorSegment(riskFloor);
   // FR-003 (M01.2' limits fragment): the rigor advisory — emitted whenever
   // rigor.stage is on, independent of fastPath/escalation. Stage off → no
@@ -3439,36 +3726,7 @@ function buildRouteSummary({
   const limitsSegment = resolveRouteStage(runtimeConfig, 'rigor') !== 'off'
     ? formatLimitsSegment(deriveCeremonyLimits(executionContract))
     : null;
-  // FR-004 (M01.3'): fastPath is emitted whenever its own stage is on — the field
-  // is always set then (eligible or not) so telemetry/harness can read it; the
-  // route-line segment prints only for eligible routes.
-  const fastPathStage = resolveRouteStage(runtimeConfig, 'fastPath');
-  const fastPath = fastPathStage !== 'off'
-    ? {
-        eligible: false,
-        suppressed: [],
-        reasons: [],
-        ...deriveFastPath({
-          executionMode,
-          targetFile: routingContext.targetFile ?? null,
-          riskFloor,
-          verificationRecommendation,
-          contextPreview: contextRecommendation?.preview ?? null,
-        }),
-        stage: fastPathStage,
-      }
-    : null;
   const fastPathSegment = formatFastPathSegment(fastPath);
-  const resolvedRouteFields = routeSchemaStage !== 'off'
-    ? buildResolvedRouteFields({
-        routingContext,
-        activeSkillIds: activeSkills.map((entry) => entry.id),
-        executionMode,
-        executionContract,
-        completionState,
-        riskFloor,
-      })
-    : null;
   const helperHint = compactHelperHint(
     compactHelperLane
       ? contextRecommendation?.command
@@ -3527,6 +3785,16 @@ function buildRouteSummary({
     executionMode,
     executionScores,
     executionCandidates,
+    // TASK-004 resolver fields — the schema-off contract requires these keys be
+    // absent entirely, so they ride the same `resolved` gate (schema stage != off).
+    ...(resolvedRouteFields
+      ? {
+          rigor: routeFields.rigor,
+          resumable: routeFields.resumable,
+          escalationTriggers: routeFields.escalationTriggers,
+          decisionShadow: routeFields.decisionShadowFields,
+        }
+      : {}),
     approachSelector,
     executionContract,
     tierLane,
@@ -3537,6 +3805,10 @@ function buildRouteSummary({
     ...(riskFloor ? { riskFloor } : {}),
     // FR-004 additive top-level field — present only when fastPath stage is on.
     ...(fastPath ? { fastPath } : {}),
+    // BL-013 additive top-level field — present only when the caller supplied
+    // a history struct (extraction ran, possibly degraded). Null/absent keeps
+    // the route byte-identical for callers without a transcript.
+    ...(routeFields.historySignals ? { historySignals: routeFields.historySignals } : {}),
     continuationState,
     autonomyLevel,
     continuousExecution,
@@ -3562,6 +3834,10 @@ function buildRouteSummary({
       ...(routingContext.visionModel ? { visionModel: routingContext.visionModel } : {}),
       ...(routingContext.visionAdvisory ? { visionAdvisory: routingContext.visionAdvisory } : {}),
     } : {}),
+    // C89 TASK-005 additive field — typed delegation advice shadow; present
+    // only when subagentOrchestrator.roleAdvice.stage != 'off' (conditional
+    // spread keeps the stage-off route byte-identical).
+    ...(delegationAdvice ? { delegationAdvice } : {}),
     line: line || 'task=unknown',
   };
 }
@@ -3680,33 +3956,225 @@ function isInformationalPrompt({
   const strongQuestion = raw.includes('?')
     || /^(what|how|when|which|where|who|is|are|does|do|did|can|could|would|should|will)\b/.test(raw)
     || /(là\s+(?:[^\s]+\s+){0,2}gì|thế nào|như thế nào|bao nhiêu|khi nào|bao giờ|ở đâu)/.test(raw);
+  // C85-019: consult-shaped questions overrule subject-matter signal scores.
+  // "should I fix X?", "X chưa nhỉ?", "có nên/có cần sửa không?" mention
+  // mutation vocabulary as SUBJECT — the ask is a decision/answer, not an
+  // order. Tight on purpose: modal-subject inversion restricted to
+  // should/shall (decision asks) — "how do I fix…?" and "bạn có thể sửa…
+  // giúp tôi không?" are work-shaped questions, not consults.
+  const folded = raw.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/\u0111/g, 'd');
+  const politeAsk = /\b(?:giup|giuong|ho|dum)\b[^\n?,;]{0,60}\b(?:khong|không)\s*[?!.]?\s*$/.test(folded)
+    || /\bcho\b[^\n?,;]{0,60}\b(?:khong|không)\s*[?!.]?\s*$/.test(folded);
+  const consultShape = /(?:^|[.!;\n]\s*)(?:should|shall)\s+(?:i|we)\s+(?!(?:i|we)\s)/.test(folded)
+    || /\b(?:co|có)\s+(?:nen|can|phai)\s+/.test(folded)
+    || /\b(?:chua|duoc khong|dung khong|khong nhi|nhi|roi)\s*[.!?]*\s*$/.test(folded)
+    || (!politeAsk && /\b(?:khong|không)\s*[?.!]?\s*$/.test(folded))
+    || /\bchi\s+(?:hoi|tu\s+van|giai\s+thich|xem)\b/.test(folded);
   if (scores) {
-    if (
+    if (!consultShape && (
       scores.implementSignal
       || scores.reviewSignal
       || scores.debugSignal
       || scores.impactSignal
       || scores.smallFixSignal
       || scores.directTransformSignal
-    ) {
+    )) {
       return false;
     }
-    if (scores.failureSignal && !strongQuestion) {
+    if (scores.failureSignal && !strongQuestion && !consultShape) {
       return false;
     }
   }
+  // C85-019: consult-shape also overrides the vocabulary vetoes — the
+  // mutation/debug/lỗi words are the question's SUBJECT, not the ask.
   const implementWords = /(?<![A-Za-z0-9_])(implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|sửa|thêm|tạo|xóa|đổi|thay thế|cập nhật|viết|build|chạy|cài)(?![A-Za-z0-9_])/.test(raw);
-  if (implementWords) return false;
+  if (implementWords && !consultShape) return false;
   const investigationWords = /\b(why|debug|triage|root cause|investigate|tại sao)\b/.test(raw);
-  if (investigationWords) return false;
+  if (investigationWords && !consultShape) return false;
   // \b never matches around 'lỗi' (diacritics are not \w), so test it as a plain
   // substring: an error report is informational only when phrased as a question.
-  if (raw.includes('lỗi') && !strongQuestion) return false;
+  if (raw.includes('lỗi') && !strongQuestion && !consultShape) return false;
   const reviewWords = /\b(review|audit|verify)\b/.test(raw);
-  if (reviewWords) return false;
-  return questionSignal;
+  if (reviewWords && !consultShape) return false;
+  // C85-019: consult shape is itself a question signal (Vietnamese tails like
+  // "chưa"/"rồi" never match the Latin interrogative regex above).
+  return questionSignal || consultShape;
+}
+
+// TASK-C85-019: an explicit no-change/advisory assertion overrides the signal
+// scores. A report or advisory question carrying fix vocabulary as SUBJECT
+// MATTER ("không tạo thay đổi", "giữ nguyên mã", "do not change anything",
+// "chỉ tư vấn") still fires implementSignal/smallFixSignal/failureSignal, which
+// used to route the turn mutating so the completion gate demanded an Edit the
+// user explicitly declined. The override fires only when an assertion phrase is
+// present AND no unambiguous implement order survives outside the
+// negated/advisory/quoted/report clauses: "sửa file X nhưng giữ nguyên Y"
+// keeps its mutation lane because 'sửa file X' is outside the keep-clause,
+// while "hook cần được cấu hình để chỉ yêu cầu bằng chứng sửa file" is a
+// description of the hook's behavior, not an order. Folded (diacritic-free)
+// text is matched so both Vietnamese spellings work. Interrogative-deontic
+// forms ("should I…?", "có cần sửa…?") count as advisory requests, not orders;
+// a bare "không biết…chưa" uncertainty is NOT an assertion and stays on the
+// plain question path.
+function hasAdvisoryOnlyAssertion({ promptText = '', commandText = '' } = {}) {
+  const folded = `${promptText ?? ''}\n${commandText ?? ''}`
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/\u0111/g, 'd');
+  const trimmed = folded.trim();
+  if (!trimmed) return false;
+  const advisoryAssertion = /\b(?:do\s+not|don't|dont)\s+(?:change|edit|fix|modify|alter|touch)\b/
+    .test(trimmed)
+    || /\bno\s+(?:changes?|edits?|updates?|modifications?)\b/.test(trimmed)
+    || /\bkeep\s+[^\n.,;]{0,60}\b(?:unchanged|as\s+is|the\s+same|intact)\b/.test(trimmed)
+    || /\badvisory\s+only\b/.test(trimmed)
+    || /\bonly\s+(?:advis|ask|question|answer|explain|consult|report)/.test(trimmed)
+    || /\bjust\s+(?:advis|ask|question|answer|explain|consult|report)/.test(trimmed)
+    || /(?:^|[.,;\n]\s*)(?:should|shall)\s+(?:i|we|you)\b/.test(trimmed)
+    || /\bgiu\s+nguyen\b/.test(trimmed)
+    || /\bmuon\s+giu\b/.test(trimmed)
+    || /\bkhong\s+(?:can\s+|muon\s+|phai\s+)?(?:sua|thay\s+doi|tao\s+thay\s+doi|edit|fix|chinh\s+sua|trien\s+khai|cap\s+nhat)\b/
+      .test(trimmed)
+    || /\bdung\s+(?:sua|thay\s+doi|edit|chinh)\b/.test(trimmed)
+    || /\bchi\s+(?:tu\s+van|hoi|giai\s+thich|xem|la\s+cau\s+hoi)\b/.test(trimmed)
+    || /\bco\s+(?:can|nen)\s+sua\b/.test(trimmed)
+    // C89-008 (user-reported 9-stop loop): a waiting/no-change turn asserts the
+    // answer is advisory — "đang chờ kết quả test QAS, không có gì cần sửa" —
+    // but matches none of the shapes above and is not question-shaped, so it
+    // escaped every informational gate and the stop hook demanded an Edit the
+    // honest turn could never produce. 'không có gì' needs its own trigger —
+    // the generic 'không (cần) sửa' pattern cannot skip the 'có gì' gap.
+    || /\bkhong\s+co\s+gi\s+(?:can|phai|de|dang|con)\s+(?:sua|thay\s+doi|lam|chinh|edit|fix)\b/.test(trimmed)
+    || /\bnothing\s+(?:to\s+(?:fix|edit|change|update|modify|do)|needs?\s+(?:fixing|editing|changing|updating))\b/.test(trimmed)
+    || /\bdang\s+(?:cho|doi)\b/.test(trimmed)
+    || /\b(?:waiting|awaiting)\s+(?:for|on)\b/.test(trimmed)
+    || /\bchua\s+(?:can|nen|phai)\s+(?:sua|thay\s+doi|lam|chinh|edit|fix)\b/.test(trimmed)
+    || /\b(?:cho|doi)\s+(?:ket\s+qua|bao\s+cao|feedback|phe\s+duyet|duyet|phien\s+ban|ci|test|qas|review|build|deploy|approval|xong)\b/.test(trimmed);
+  if (!advisoryAssertion) return false;
+  // Strip quoted spans and every clause class that can carry mutation
+  // vocabulary without being an order: the advisory/negated assertions
+  // themselves, conditional or purpose clauses (nếu/để/cho/if), reported
+  // demands of another agent (yêu cầu/ép/bắt/requires/forced), passive
+  // necessity descriptions (cần được cấu hình/must be configured), and the
+  // ledger's own evidence-class names. Whatever mutation verb remains after
+  // the strip is an actual implement order and vetoes the advisory route.
+  // C85-019c: clause strips must stop BEFORE a conjunction-joined imperative
+  // — "giữ nguyên header và sửa lỗi login" keeps 'và sửa lỗi' as a surviving
+  // order; an unbounded [^.,;\n]* swallows it and the order escapes the gate.
+  // TAIL = lazy strip ending before 'và'/'and' (folded va|and) or EOS.
+  const TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and)\\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
+  // C89-008: WAIT_TAIL ends a waiting-clause strip before any coordinating
+  // conjunction ('và/and/nhưng/rồi/then/later/sau đó') followed by anything up
+  // to a mutation verb, or at punctuation/EOS — "đang chờ kết quả nhưng sửa
+  // file này" keeps 'sửa file này' as a surviving order.
+  const WAIT_TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and|nhung|roi|then|later|sau\\s+do)\\s+[^.,;\\n]*?\\b(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
+  const residue = trimmed
+    .replace(/"[^"\n]*"|«[^»\n]*»/g, ' ')
+    .replace(/\bwrite-evidence\b|\bverification-evidence\b|\bimpact-evidence\b|\broot-cause\b/g, ' ')
+    .replace(new RegExp(`\\bgiu\\s+nguyen\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bmuon\\s+giu\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bkhong\\s+(?!chi\\b)${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bdung\\s+${TAIL}`, 'g'), ' ')
+    // C89-008: a waiting clause narrates what the TURN waits on, not what the
+    // request orders — verbs inside it ("chờ sửa xong", "waiting for the fix")
+    // belong to the wait, not to the implement order.
+    .replace(new RegExp(`\\bdang\\s+(?:cho|doi)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:waiting|awaiting)\\s+(?:for|on)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:cho|doi)\\s+(?:ket\\s+qua|bao\\s+cao|feedback|phe\\s+duyet|duyet|phien\\s+ban|ci|test|qas|review|build|deploy|approval|xong)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bnothing\\s+(?:to|needs?)\\b${TAIL}`, 'g'), ' ')
+    // 'chưa cần/nên/phải sửa' defers the change — same class as 'không cần
+    // sửa' but 'chưa' is not covered by the 'không' strip above. WAIT_TAIL
+    // bounds it so '…nhưng sửa phần này' keeps the surviving order.
+    .replace(new RegExp(`\\bchua\\s+(?:can|nen|phai)\\s+${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:de|cho)\\s+${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:yeu\\s+cau|doi\\s+hoi|ep\\s+phai|bat\\s+buoc|bat\\s+phai)\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:demand(?:ed|s)?|require(?:d|s)?|forcing|forced|forcibly|must|has\\s+to|have\\s+to)\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|not|never|no)\\s+(?!only\\b)${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:can|nen|phai|duoc)\\s+(?:duoc\\s+)?(?:sua|cau\\s+hinh|thay\\s+doi|cap\\s+nhat|edit|fix|config)\\b${TAIL}`, 'g'), ' ')
+    .replace(/\bco\s+(?:can|nen)\s+sua\b[^.,;\n?]*/g, ' ')
+    .replace(/(?:^|[.,;\n]\s*)(?:should|shall)\s+(?:i|we|you)\b[^.,;\n?]*/g, ' ')
+    .replace(/\bchi\s+(?:tu\s+van|hoi|giai\s+thich|xem|la\s+cau\s+hoi|can|la)\b[^.,;\n]*/g, ' ')
+    .replace(/\b(?:just|only|simply)\s+(?:advis\w*|asking?|a\s+question|answering?|explaining?|consulting|reporting)\b[^.,;\n]*/g, ' ')
+    .replace(/\badvisory\s+only\b[^.,;\n]*/g, ' ')
+    .replace(new RegExp(`\\bkeep\\s+[^\\n.,;]{0,60}\\b(?:unchanged|as\\s+is|the\\s+same|intact)\\b${TAIL}`, 'g'), ' ');
+  const mutationOrder = /(?<![A-Za-z0-9_])(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![A-Za-z0-9_])/.test(residue);
+  return !mutationOrder;
+}
+// C85-019: mutation vocabulary ≠ mutation order. The same residue logic the
+// advisory gate uses — quotes, negated clauses, conditionals (nếu/để/cho/if),
+// reported demands (yêu cầu/ép/requires), necessity phrases (cần được/must be),
+// evidence-class names — decides whether ANY surviving verb is an imperative.
+// Used by hasAdvisoryOnlyAssertion (assertion + no order → advisory) and by
+// the question-shape gate below (question + no order → consult, even when the
+// subject vocabulary fires debug/failure/implement signal scores).
+function hasMutationOrder({ promptText = '', commandText = '' } = {}) {
+  const folded = `${promptText ?? ''}\n${commandText ?? ''}`
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/\u0111/g, 'd');
+  const trimmed = folded.trim();
+  if (!trimmed) return false;
+  // C85-019c: clause strips must stop BEFORE a conjunction-joined imperative
+  // — "giữ nguyên header và sửa lỗi login" keeps 'và sửa lỗi' as a surviving
+  // order; an unbounded [^.,;\n]* swallows it and the order escapes the gate.
+  // TAIL = lazy strip ending before 'và'/'and' (folded va|and) or EOS.
+  const TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and)\\s+(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
+  // C89-008: WAIT_TAIL ends a waiting-clause strip before a coordinating
+  // conjunction ('và/and/nhưng/rồi/then/later/sau đó') followed by anything up
+  // to a mutation verb, or at punctuation/EOS.
+  const WAIT_TAIL = '[^.,;\\n]*?(?=\\s+(?:va|and|nhung|roi|then|later|sau\\s+do)\\s+[^.,;\\n]*?\\b(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\\s+the|cap\\s+nhat|viet|chay|cai|chinh|trien\\s+khai|cau\\s+hinh)(?![A-Za-z0-9_])|[.,;]|\\s*$)';
+  const residue = trimmed
+    .replace(/"[^"\n]*"|«[^»\n]*»/g, ' ')
+    .replace(/\bwrite-evidence\b|\bverification-evidence\b|\bimpact-evidence\b|\broot-cause\b/g, ' ')
+    .replace(new RegExp(`\\bgiu\\s+nguyen\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bmuon\\s+giu\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bkhong\\s+(?!chi\\b)${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bdung\\s+${TAIL}`, 'g'), ' ')
+    // C89-008: a waiting clause narrates what the TURN waits on, not what the
+    // request orders — verbs inside it belong to the wait.
+    .replace(new RegExp(`\\bdang\\s+(?:cho|doi)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:waiting|awaiting)\\s+(?:for|on)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:cho|doi)\\s+(?:ket\\s+qua|bao\\s+cao|feedback|phe\\s+duyet|duyet|phien\\s+ban|ci|test|qas|review|build|deploy|approval|xong)\\b${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\bnothing\\s+(?:to|needs?)\\b${TAIL}`, 'g'), ' ')
+    // 'chưa cần/nên/phải sửa' defers the change — WAIT_TAIL bounds it so a
+    // '…nhưng sửa phần này' order survives.
+    .replace(new RegExp(`\\bchua\\s+(?:can|nen|phai)\\s+${WAIT_TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:neu|if)\\s+${TAIL}`, 'g'), ' ')
+    // C85-019b: a "khi <subject> <verb>" when-clause is temporal context —
+    // "khi tôi cài hệ thống này" narrates WHEN something happens; the verb
+    // inside it is never the order.
+    .replace(new RegExp(`\\bkhi\\s+(?:toi|ta|ban|no|anh|chi|he|she|we)\\s+[^.,;\\n?]*?(?=\\s+(?:va|and)\\b|\\s*$)`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:de|cho)\\s+${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:yeu\\s+cau|doi\\s+hoi|ep\\s+phai|bat\\s+buoc|bat\\s+phai)\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:demand(?:ed|s)?|require(?:d|s)?|forcing|forced|forcibly|must|has\\s+to|have\\s+to)\\b${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:do\\s+not|don't|dont|not|never|no)\\s+(?!only\\b)${TAIL}`, 'g'), ' ')
+    .replace(new RegExp(`\\b(?:can|nen|phai|duoc)\\s+(?:duoc\\s+)?(?:sua|cau\\s+hinh|thay\\s+doi|cap\\s+nhat|edit|fix|config)\\b${TAIL}`, 'g'), ' ')
+    .replace(/\bco\s+(?:can|nen)\s+sua\b[^.,;\n?]*/g, ' ')
+    .replace(/(?:^|[.,;\n]\s*)(?:should|shall)\s+(?:i|we|you)\b[^.,;\n?]*/g, ' ')
+    .replace(/\bchi\s+(?:tu\s+van|hoi|giai\s+thich|xem|la\s+cau\s+hoi|can|la)\b[^.,;\n]*/g, ' ')
+    .replace(/\b(?:just|only|simply)\s+(?:advis\w*|asking?|a\s+question|answering?|explaining?|consulting|reporting)\b[^.,;\n]*/g, ' ')
+    .replace(/\badvisory\s+only\b[^.,;\n]*/g, ' ')
+    .replace(new RegExp(`\\bkeep\\s+[^\\n.,;]{0,60}\\b(?:unchanged|as\\s+is|the\\s+same|intact)\\b${TAIL}`, 'g'), ' ')
+    // C85-019b: question-tagged mutation verbs are asks, not orders. English:
+    // "<modal> I/we <verb>" (should I fix). Vietnamese: S-V-order status
+    // questions — "<verb> … (chưa|được không|rồi|nhỉ)?" means "has it been
+    // done", never "do it". EXCLUDED: "… giúp/cho/hộ/dùm tôi không?" — the
+    // 'không' there is a polite request marker, not a status tag, and the
+    // mutation verb is a real order; also EXCLUDED are wh-led modals
+    // ("which files should I update") — a selection ask is a plan, not a
+    // yes/no consult. These strips run LAST so a real imperative
+    // mid-sentence ("sửa file X cho tôi") still survives.
+    .replace(/\b(?<!\b(?:which|what|how)\s[^.,;?]{0,30})(?:should|shall)\s+(?:i|we)\s+[^\n?]*[?]?/g, ' ')
+    .replace(/[^\n.,;?]{0,80}\b(?:chua|duoc khong|dung khong|khong nhi|nhi|roi|a)\s*[?]?\s*$/g, ' ')
+    .replace(/^(?!.*\b(?:giup|giuong|cho|ho|dum)\b)[^\n.,;?]{0,80}\b(?:khong|không)\s*[?]?\s*$/g, ' ')
+    .replace(/\b(?:co|có)\s+(?:nen|can|phai)\s+[^\n?]*[?]?/g, ' ');
+  return /(?<![A-Za-z0-9_])(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|edit|sua|them|tao|xoa|doi|thay\s+the|cap\s+nhat|viet|chay|cai|chinh|trien\s+khai|cau\s+hinh)(?![A-Za-z0-9_])/.test(residue);
 }
 
+
 function deriveExecutionMode({
   promptText = '',
   commandText = '',
@@ -3739,6 +4207,15 @@ function deriveExecutionMode({
     return 'informational';
   }
 
+  // TASK-C85-019: an explicit no-change/advisory assertion beats every signal
+  // score — the prompt mentions mutation vocabulary as subject matter, not as
+  // an order. Checked before the review/delivery/consultation gates so an
+  // advisory turn never mints write or verification debt; a surviving
+  // imperative outside the negated clause still routes mutating.
+  if (hasAdvisoryOnlyAssertion({ promptText, commandText })) {
+    return 'informational';
+  }
+
   if (
     releaseVerificationContinuation
     || ((intentMode === 'review-specific' || explicitReviewLead) && !scores.implementSignal)
@@ -3756,25 +4233,27 @@ function deriveExecutionMode({
     || /^(?:lam sao|the nao|nhu the nao|nhu nao|vi sao|tai sao|khi nao|bao gio|bao nhieu|o dau|phai lam gi|lam gi|lam cach nao)\b/.test(foldedPromptText);
   const questionShapedPrompt = /\?\s*$/.test(trimmedPromptText)
     || leadingInterrogative
-    || /\b(?:la gi|duoc khong)\s*$/.test(foldedPromptText);
+    || /\b(?:la gi|duoc khong)\s*$/.test(foldedPromptText)
+    // C85-019: Vietnamese status/consult tails without a '?' — "… chưa",
+    // "… chưa nhỉ", "… không nhỉ", "… đúng không", "… à". A question about a
+    // defect must not mint the bug-fix floor's write/repro debt (user-reported
+    // lock on "Không biết … chưa nhỉ").
+    || /\b(?:chua|duoc khong|dung khong|khong nhi|khong|nhi)\s*[.!?]*\s*$/.test(foldedPromptText);
   // Implement verbs (Vietnamese included — the English-only scores above cannot see
   // them) mark an action order even when phrased as a question ("ban sua giup toi…?" is
   // an edit order, not a consultation). A leading interrogative overrides them:
   // "Lam sao ma do duoc khi toi cai…?" asks HOW something is done, it does not order
   // the action performed.
   const consultationImplementWords = /(?<![A-Za-z0-9_])(?:implement|apply|update|modify|add|create|ship|deliver|fix|refactor|remove|delete|rename|change|write|build|make|install|run|deploy|execute|sửa|thêm|tạo|xóa|đổi|thay thế|cập nhật|viết|chạy|cài)(?![A-Za-z0-9_])/.test(trimmedPromptText);
+  // C85-019: question shape + no surviving imperative = consult. The
+  // pre-C85-019 all-zero-scores clause consulted only when NOTHING in the
+  // prompt resembled work — impossible for a question about code. Replacing
+  // it with hasMutationOrder keeps "sửa file cho tôi?" (an order wearing a
+  // question mark) mutating while "lỗi này chưa nhỉ" / "should I fix the
+  // hook?" / "Không biết … đã khắc phục chưa" consult. A targetFile still
+  // vetoes: a named artifact is work, not a question.
   const consultationOnlySignal = questionShapedPrompt
-    && (leadingInterrogative || !consultationImplementWords)
-    && scores.editCertainty === 0
-    && !scores.implementSignal
-    && !scores.reviewSignal
-    && !scores.debugSignal
-    && !scores.failureSignal
-    && !scores.impactSignal
-    && !scores.buildSignal
-    && !scores.directTransformSignal
-    && !scores.smallFixSignal
-    && !scores.sharedRisk
+    && !hasMutationOrder({ promptText, commandText })
     && !targetFile;
   
   if (deliveryOnlySignal || consultationOnlySignal) {
@@ -3930,117 +4409,6 @@ function executionModeRank(mode = '') {
   return index >= 0 ? index : orderedModes.length;
 }
 
-function buildExecutionContract(executionMode = null) {
-  if (!executionMode) {
-    return null;
-  }
-
-  const contracts = {
-    'tiny-fix': {
-      modelTier: 'lite',
-      maxReadPasses: 0,
-      maxContextPulls: 0,
-      verificationPolicy: 'minimal-or-targeted',
-      completionRule: 'never-claim-done-without-write',
-      delegationPolicy: 'disallow',
-      completionEvidence: ['write-evidence'],
-    },
-    'local-fix': {
-      modelTier: 'code',
-      maxReadPasses: 1,
-      maxContextPulls: 1,
-      verificationPolicy: 'targeted-if-covered',
-      completionRule: 'require-write',
-      delegationPolicy: 'disallow',
-      completionEvidence: ['write-evidence'],
-    },
-    'local-build': {
-      modelTier: 'code',
-      maxReadPasses: 2,
-      maxContextPulls: 1,
-      verificationPolicy: 'targeted-if-covered',
-      completionRule: 'require-write-and-verification',
-      delegationPolicy: 'disallow-by-default',
-      completionEvidence: ['write-evidence', 'verification-evidence'],
-    },
-    'find-cause': {
-      modelTier: 'code',
-      maxReadPassesBeforeReassess: 3,
-      verificationPolicy: 'root-cause-then-targeted',
-      completionRule: 'never-claim-fixed-without-write-and-verification',
-      delegationPolicy: 'allow-specialized-debug-lane',
-      completionEvidence: ['write-evidence', 'verification-evidence'],
-    },
-    'shared-edit': {
-      modelTier: 'code',
-      maxReadPasses: 2,
-      maxContextPulls: 2,
-      verificationPolicy: 'targeted-then-widen-on-risk',
-      completionRule: 'require-write-and-verification',
-      delegationPolicy: 'allow-qualified-sidecar',
-      completionEvidence: ['write-evidence', 'verification-evidence'],
-      mirrorConsistencyRequired: true,
-    },
-    'map-impact': {
-      modelTier: 'code',
-      maxReadPasses: 3,
-      maxContextPulls: 3,
-      verificationPolicy: 'impact-first-then-targeted-then-widen-on-risk',
-      completionRule: 'require-impact-evidence-before-edit-claim',
-      delegationPolicy: 'allow-impact-sidecar',
-      completionEvidence: ['impact-evidence', 'write-evidence', 'verification-evidence'],
-      mirrorConsistencyRequired: true,
-    },
-    'review-release': {
-      modelTier: 'smart',
-      verificationPolicy: 'evidence-first',
-      completionRule: 'report-findings-not-implementation',
-      delegationPolicy: 'allow-review-sidecar',
-      completionEvidence: ['verification-evidence'],
-    },
-  };
-
-  return contracts[executionMode] ? { ...contracts[executionMode] } : null;
-}
-
-// Decision table v2 (V3_RESHAPE §5): the contracts table's modelTier column is the
-// base row; resolveModelTier adds the (riskFloor, hostCapabilities) columns.
-// Deterministic — no registry, no leases, no outbound capability calls.
-// Literal mirror of src/core/executionContracts.js resolveModelTier; parity is
-// locked by tests/consistency/executionContractSync.test.js.
-const MODEL_TIER_ORDER = ['lite', 'code', 'smart'];
-const MODEL_TIER_EFFORT = {
-  lite: 'low',
-  code: 'medium',
-  smart: 'high',
-};
-
-/**
- * Resolves {tier, effort, advisoryOnly} for a route. A 'high-risk' floor escalates
- * the tier one band (lite→code→smart, capped at smart) and forces effort 'high'.
- * Unknown mode → {tier:null, effort:null, advisoryOnly:true}. Missing/unknown
- * riskFloor → 'none'. Missing hostCapabilities → advisoryOnly:true (the route text
- * is all the host gets when it cannot bind model and effort).
- */
-export function resolveModelTier({
-  executionMode = null,
-  riskFloor = null,
-  hostCapabilities = null,
-} = {}) {
-  const baseTier = buildExecutionContract(executionMode)?.modelTier ?? null;
-  if (!baseTier) {
-    return { tier: null, effort: null, advisoryOnly: true };
-  }
-  const highRisk = riskFloor?.floor === 'high-risk';
-  const tier = highRisk
-    ? MODEL_TIER_ORDER[Math.min(MODEL_TIER_ORDER.indexOf(baseTier) + 1, MODEL_TIER_ORDER.length - 1)]
-    : baseTier;
-  return {
-    tier,
-    effort: highRisk ? 'high' : MODEL_TIER_EFFORT[tier],
-    advisoryOnly: !(hostCapabilities?.canBindModel === true && hostCapabilities?.canBindEffort === true),
-  };
-}
 
 function buildApproachSelectorResult({
   executionMode = null,
@@ -4105,37 +4473,6 @@ function buildApproachSelectorResult({
   };
 }
 
-function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
-  if (!executionMode || executionMode === 'informational') {
-    return null;
-  }
-
-  const contract = buildExecutionContract(executionMode);
-  const missingEvidence = [...(contract?.completionEvidence ?? [])];
-  const requiresVerification = missingEvidence.includes('verification-evidence');
-  if (
-    requiresVerification
-    && verificationRecommendation
-    && !(verificationRecommendation.commands?.length || verificationRecommendation.fallbackCommands?.length)
-  ) {
-    missingEvidence.push('verification-plan');
-  }
-
-  let reason = 'completion evidence is still required';
-  if (['tiny-fix', 'local-fix', 'local-build', 'shared-edit'].includes(executionMode)) {
-    reason = 'implement request has not produced an edit yet';
-  } else if (executionMode === 'review-release') {
-    reason = 'review/release evidence is still required before final claim';
-  } else if (executionMode === 'map-impact') {
-    reason = 'impact evidence is still required before safe completion claim';
-  }
-
-  return {
-    claimAllowed: false,
-    missingEvidence,
-    reason,
-  };
-}
 
 function buildContinuationState({
   nextActionType = null,
@@ -4588,26 +4925,6 @@ function buildHelperCommand({ commandNamespace = '.claude', scriptName, intent =
   return parts.join(' ');
 }
 
-const SHARED_IMPACT_PATTERNS = [
-  /^\.claude\/hooks\//,
-  /^\.claude\/ukit\//,
-  /^\.codex\//,
-  /^src\/index\//,
-  /^src\/core\/(runInstallPipeline|applyPlan|buildPlan|diffPlan|metadata|migrateLegacy|uninstall|runtimeConfig|runtimePaths)\.js$/,
-  /^src\/core\/(output|token|compact)\//,
-  /^template_project\/\.claude\/hooks\//,
-  /^template_project\/\.claude\/ukit\//,
-  /^manifests\/platform\.full\.yaml$/,
-  /^template_project\//,
-];
-
-function isSharedImpactFile(filePath) {
-  const normalized = String(filePath ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
-  if (!normalized) {
-    return false;
-  }
-  return SHARED_IMPACT_PATTERNS.some((pattern) => pattern.test(normalized));
-}
 
 function isTestLikeFile(filePath) {
   return /\.(test|spec)\.[a-z0-9]+$/i.test(filePath)
@@ -4851,7 +5168,7 @@ function isFlagOrValue(argv, index) {
   const arg = argv[index];
   if (!arg.startsWith('--')) {
     const prev = argv[index - 1];
-    return Boolean(prev && ['--root', '--target', '--type', '--tool-command', '--last-prompt', '--session-id', '--adapter'].includes(prev));
+    return Boolean(prev && ['--root', '--target', '--type', '--tool-command', '--last-prompt', '--session-id', '--adapter', '--transcript'].includes(prev));
   }
   return true;
 }
@@ -4942,21 +5259,17 @@ function buildStructuredRouteFingerprintPayload(route = {}) {
     approachContextPolicy: routeSummary?.approachSelector?.contextPolicy ?? null,
     approachVerificationPolicy: routeSummary?.approachSelector?.verificationPolicy ?? null,
     approachCompletionRule: routeSummary?.approachSelector?.completionRule ?? null,
-    continuationRequired: routeSummary?.continuationState?.required ?? null,
-    continuationReasons: unique(routeSummary?.continuationState?.reasons ?? []),
-    continuationMilestone: routeSummary?.continuationState?.nextMilestone ?? null,
-    continuationRepeatCount: routeSummary?.continuationState?.repeatCount ?? null,
-    continuationStuckRisk: routeSummary?.continuationState?.stuckRisk ?? null,
-    continuationRescueMode: routeSummary?.continuationState?.rescueMode ?? null,
-    delegateHint: routeSummary?.delegateHint ?? null,
-    nextActionType: routeSummary?.nextActionType ?? null,
-    nextActionCommand: routeSummary?.nextActionCommand ?? null,
-    helperHint: routeSummary?.helperHint ?? null,
     completionRule: routeSummary?.executionContract?.completionRule ?? null,
-    completionMissingEvidence: unique(routeSummary?.completionState?.missingEvidence ?? []),
-    primaryCommands: unique(routeSummary?.primaryCommands ?? []),
-    fallbackCommands: unique(routeSummary?.fallbackCommands ?? []),
     preferredOrder: unique(routeSummary?.preferredOrder ?? []),
+    // Fingerprint payload ends here — everything below was REMOVED (C85 fix
+    // round): continuation/next-action/helper/command fields derive from the
+    // LIVE session (prior context, ledger state, previousRouteSummary), so the
+    // same re-asked prompt fingerprinted differently every emission. An
+    // unstable routefp-v3 breaks every downstream join keyed on it —
+    // historySignals.fixLoopCount (BL-013), ledger routeFingerprint joins
+    // (BL-003/004), feedbackEvents re-route joins (BL-018), and the escalation
+    // same-loop key itself. The fingerprint is a "same-symptom" join key, not
+    // a dedupe key — stable request features only.
   };
 }
 
@@ -5113,6 +5426,17 @@ export function compactRouteSummary(routeSummary = null) {
     nextActionType: routeSummary.nextActionType ?? null,
     nextActionCommand: routeSummary.nextActionCommand ?? null,
     helperHint: routeSummary.helperHint ?? null,
+    // TASK-007 (BL-009): playbook fields survive compaction so
+    // skill-router-state.json and cached route states carry the identical
+    // playbookId/workGroup the helper emitted. BL-010 adds the direct/handoff
+    // path + the ARCH fast-path enum — the guard + eval fixtures read them
+    // off persisted route state.
+    playbookId: routeSummary.playbookId ?? null,
+    workGroup: routeSummary.workGroup ?? null,
+    path: routeSummary.path ?? null,
+    fastPathKind: routeSummary.fastPathKind ?? null,
+    ...(routeSummary.playbookReason ? { playbookReason: routeSummary.playbookReason } : {}),
+    ...(routeSummary.playbookLoad ? { playbookLoad: routeSummary.playbookLoad } : {}),
     // M04.1 (TASK-007): the resumable-run pointer survives compaction so
     // reinject-context resumes from the same taskId/boundary. Conditional
     // spread — stage-off output stays byte-identical (no key when absent).
@@ -5130,6 +5454,24 @@ export function compactRouteSummary(routeSummary = null) {
       escalatedTier: routeSummary.escalatedTier,
       escalationReason: routeSummary.escalationReason ?? null,
     } : {}),
+    // BL-019: the applied measured tier survives compaction — additive so
+    // stage-off/no-map routes keep the pre-BL-019 compact shape.
+    ...(routeSummary.measuredTier != null ? { measuredTier: routeSummary.measuredTier } : {}),
+    // BL-018 (SPEC FR-006): the fix-loop escalation fields survive compaction
+    // so persisted route state carries the deeper lane — the next emission's
+    // exhaustion check and the stop gate read them off this record.
+    // escalatedRouteFingerprint is the same-loop join key: the prior record
+    // only binds when its stamped fingerprint equals the next emission's.
+    ...(routeSummary.escalatedLane ? {
+      escalatedLane: routeSummary.escalatedLane,
+      escalateReason: routeSummary.escalateReason ?? null,
+      ...(routeSummary.escalatedRouteFingerprint != null ? {
+        escalatedRouteFingerprint: routeSummary.escalatedRouteFingerprint,
+      } : {}),
+      ...(routeSummary.escalatedVerificationDepth != null ? {
+        escalatedVerificationDepth: routeSummary.escalatedVerificationDepth,
+      } : {}),
+    } : {}),
     // FR-005: riskEscalation is the Stop-gate carrier (FR-006) — it must survive
     // skill-router-state.json compaction. Conditional spread keeps stage-off
     // output byte-identical (no key emitted when the field is absent).
@@ -5138,6 +5480,14 @@ export function compactRouteSummary(routeSummary = null) {
     // persisted route state keeps the redacted outcome. Conditional spread —
     // stage-off output stays byte-identical (no key emitted when absent).
     ...(routeSummary.decisionPlane ? { decisionPlane: routeSummary.decisionPlane } : {}),
+    // C89 TASK-005: the typed delegation advice survives compaction so
+    // persisted route state keeps the shadow verdict. Conditional spread —
+    // stage-off output stays byte-identical (no key emitted when absent).
+    ...(routeSummary.delegationAdvice ? { delegationAdvice: routeSummary.delegationAdvice } : {}),
+    // BL-013: bounded history counters survive compaction so persisted route
+    // state + cached routes keep the identical struct. Conditional spread —
+    // absent keeps output byte-identical.
+    ...(routeSummary.historySignals ? { historySignals: routeSummary.historySignals } : {}),
     // M01.1 compact whitelist (C01): grouped fields survive compaction minus verbose
     // evidence; absent entirely when the route schema stage is off.
     ...(compactResolvedRoute(routeSummary) ?? {}),
@@ -5204,6 +5554,15 @@ function buildRouteAuditEntry({ route = null, state = null } = {}) {
 
   return {
     ts: Date.now(),
+    // TASK-007 (BL-009): playbook route fields — join key for the playbook
+    // spine (BL-010/011/012 read playbookId off the route row). BL-010 adds
+    // the direct/handoff path + fast-path enum so the eval join can assert
+    // `direct, fastPath=small-feature` (E-01).
+    playbookId: routeSummary.playbookId ?? null,
+    workGroup: routeSummary.workGroup ?? null,
+    playbookLoad: routeSummary.playbookLoad ?? null,
+    path: routeSummary.path ?? null,
+    fastPathKind: routeSummary.fastPathKind ?? null,
     source: state?.source ?? 'task-route',
     requestKey: state?.requestKey ?? null,
     adapter: routingContext.adapter ?? 'claude',
@@ -5213,13 +5572,21 @@ function buildRouteAuditEntry({ route = null, state = null } = {}) {
     }),
     targetFile: route?.routingContext?.targetFile ?? null,
     taskType: routingContext.taskType ?? null,
+    // BL-003: the ledger-visible join key — execution-ledger.mjs stamps
+    // `routeFingerprint: routeState.fingerprint`, the same routefp-v3 digest
+    // this state's `fingerprint` field carries.
+    routeFingerprint: state?.fingerprint ?? null,
     // FR-202a (TASK-228): active-skill ids for phase-2 skill-accuracy roll-ups.
     // Telemetry only — deliberately excluded from dedupeKey/fingerprint inputs.
     skillIds: (route?.activeSkills ?? state?.activeSkills ?? [])
-      .map((s) => s?.id)
-      .filter(Boolean)
+      .map((s) => (s && typeof s === 'object' ? s.id : s))
+      .filter((id) => typeof id === 'string' && id)
       .slice(0, 8),
     executionMode: routeSummary.executionMode ?? null,
+    // BL-019: the effective tier the route ran under — the join buckets
+    // per-(mode,tier) reliability off this column. Telemetry only.
+    modelTier: routeSummary?.executionContract?.modelTier ?? null,
+    measuredTier: routeSummary?.measuredTier ?? null,
     competingMode: routeSummary?.approachSelector?.competingMode ?? null,
     competingScoreGap: routeSummary?.approachSelector?.competingScoreGap ?? null,
     candidateModes: candidateModes.slice(0, 3),
@@ -5228,6 +5595,14 @@ function buildRouteAuditEntry({ route = null, state = null } = {}) {
     repeatCount: routeSummary?.continuationState?.repeatCount ?? null,
     rescueMode: routeSummary?.continuationState?.rescueMode ?? null,
     wideningBlocked: routeSummary?.continuationState?.wideningBlocked ?? null,
+    // BL-018: the deeper lane the fix-loop escalation chose (or 'blocked') —
+    // the re-route feedback join keys on routeFingerprint, so a lane change
+    // like this one is exactly the event that collector was built to see.
+    escalatedLane: routeSummary?.escalatedLane ?? null,
+    escalateReason: routeSummary?.escalateReason ?? null,
+    // BL-013: bounded history counters on the audit row — same struct as the
+    // route record, identical to the hook's audit emission.
+    historySignals: routeSummary?.historySignals ?? null,
   };
 }
 
@@ -5296,7 +5671,39 @@ function mergeRouteAuditEntries(staged, parsed, newEntry) {
     seen.add(key);
     merged.push(item);
   }
-  return merged.slice(0, 40);
+  // BL-004: rows past the 40-entry cap are spilled to
+  // route-audit.segments.jsonl (append-only sidecar) instead of being dropped —
+  // consumers read ring + segments with requestKey dedupe.
+  return { entries: merged.slice(0, 40), evicted: merged.slice(40) };
+}
+
+function routeAuditSegmentsPath(filePath) {
+  return path.join(path.dirname(filePath), 'route-audit.segments.jsonl');
+}
+
+async function spillRouteAuditEntries(filePath, evicted) {
+  if (!evicted?.length) return;
+  try {
+    await fs.appendFile(
+      routeAuditSegmentsPath(filePath),
+      evicted.map((item) => JSON.stringify(item)).join('\n') + '\n',
+    );
+  } catch {
+    // Spill write failure degrades to the pre-BL-004 drop — the audit merge
+    // itself must never fail on telemetry sidecar I/O.
+  }
+}
+
+function spillRouteAuditEntriesSync(filePath, evicted) {
+  if (!evicted?.length) return;
+  try {
+    fsSync.appendFileSync(
+      routeAuditSegmentsPath(filePath),
+      evicted.map((item) => JSON.stringify(item)).join('\n') + '\n',
+    );
+  } catch {
+    // same degrade posture as the async spill above
+  }
 }
 
 function parseRouteAuditSidecar(raw) {
@@ -5391,10 +5798,10 @@ function foldRouteAuditSidecarSync(filePath) {
     } catch {
       parsed = { entries: [] };
     }
+    const { entries: folded, evicted } = mergeRouteAuditEntries(staged, parsed, null);
+    spillRouteAuditEntriesSync(filePath, evicted);
     const tmpPath = `${filePath}.exitfold-${process.pid}`;
-    fsSync.writeFileSync(tmpPath, JSON.stringify({
-      entries: mergeRouteAuditEntries(staged, parsed, null),
-    }));
+    fsSync.writeFileSync(tmpPath, JSON.stringify({ entries: folded }));
     fsSync.renameSync(tmpPath, filePath);
   } finally {
     try {
@@ -5456,9 +5863,9 @@ export async function appendRouteAuditEntry(filePath, entry) {
     }
 
     const parsed = await readJson(filePath, { entries: [] });
-    await writeJsonAtomic(filePath, {
-      entries: mergeRouteAuditEntries(sidecarEntries, parsed, entry),
-    });
+    const { entries: mergedEntries, evicted } = mergeRouteAuditEntries(sidecarEntries, parsed, entry);
+    await spillRouteAuditEntries(filePath, evicted);
+    await writeJsonAtomic(filePath, { entries: mergedEntries });
   });
   if (!result.ok) {
     // Fail-closed on the merge (CX-8): the entry stays staged in the sidecar —