@ngockhoale/ukit 3.3.2 → 3.4.0

package/src/index/taskRouting.js

@@ -10,13 +10,73 @@ import {
   CONTRACT_RISK_PROFILES,
   EXECUTION_CONTRACTS,
   EXECUTION_MODE_ORDER,
-  MODEL_TIER_BY_CONTRACT,
-  ROUTE_EFFORTS,
-  resolveModelTier,
 } from '../core/executionContracts.js';
-import { resolveModelRoles, readMergedRuntimeConfig, resolveConfigStage } from '../core/runtimeConfig.js';
+import { resolveModelRoles, readMergedRuntimeConfig, resolveConfigStage, resolveSubagentOrchestratorStage } from '../core/runtimeConfig.js';
 import { runShadowDecisions } from '../decision/shadow.js';
 import { resolvePlaybook } from '../core/userPlaybooks.js';
+import { resolvePlaybookRoute, loadRegistry } from './playbookRegistry.js';
+import { extractHistorySignalsAsync } from './sessionHistoryExtractor.js';
+import { applyMeasuredTier } from './tierSelection.js';
+import { createDecisionClient } from '../decision/client.js';
+import {
+  applyFixLoopEscalation,
+  isFixLoopEscalationDue,
+} from './fixLoopEscalation.js';
+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,
+  resolveRouteSchemaStage,
+  resolveRouteStage,
+  deriveRiskFloor,
+  formatRiskFloorSegment,
+  deriveCeremonyLimits,
+  formatLimitsSegment,
+  deriveFastPath,
+  formatFastPathSegment,
+  isDeliveryOnlyRequest,
+  buildCompletionState,
+  validateResolvedRoute,
+  compactResolvedRoute,
+  deriveRouteFields,
+  resolveDecisionPlaneStage,
+} from './routeResolver.js';
+
+// TASK-004 (BL-006): the derivation primitives this file used to carry inline
+// now live in routeResolver.js — the canonical half of the shared resolver the
+// hook path consumes via route-resolver.mjs. 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,
+  resolveRouteSchemaStage,
+  resolveRouteStage,
+  deriveRiskFloor,
+  formatRiskFloorSegment,
+  deriveCeremonyLimits,
+  formatLimitsSegment,
+  deriveFastPath,
+  formatFastPathSegment,
+  buildCompletionState,
+  validateResolvedRoute,
+  compactResolvedRoute,
+  deriveRouteFields,
+};
 
 // --- v3 route-side advisory blocks (docs/pstack/SPEC-playbook-todo.md, ------------------
 // SPEC-principle-index.md, SPEC-model-roles.md). All three are additive stdout text —
@@ -38,29 +98,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
@@ -147,480 +211,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) -------------------
-// 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']);
-// 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_ORDER ladder.
-export const ROUTE_EXECUTION_MODES = [...EXECUTION_MODE_ORDER, 'informational'];
-const ROUTE_ESCALATION_CEILING = 'review-release';
-const ROUTE_GOAL_MAX_LENGTH = 240;
-
-// 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-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 = buildRouteSignalText(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;
-}
-
-
-// @decision-point route.intent-kind.v1 — intent kind is a registered
-// consequential decision (DECISION_REGISTRY); this deterministic mapping is
-// its fallback policy implementation.
-// 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 = buildRouteSignalText(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,
-  };
-}
 
 
 export async function deriveTaskRoute({
@@ -637,6 +227,24 @@ export async function deriveTaskRoute({
   // TASK-004 (FR-008/FR-009): decision-plane runtime seam — transport/env/
   // hostCapabilities overrides for the shadow evaluator. Unused at stage off.
   decisionPlaneOptions = null,
+  // BL-013: optional transcript pointer + caller-known route keys for the
+  // bounded history extractor. Absent → historySignals degrades (zeroed struct
+  // with degraded:true), never throws, ≤50ms tail read.
+  transcriptPath = null,
+  // BL-018: prior emission for the same route — the fix-loop escalation's
+  // exhaustion check reads its escalatedLane. Absent → first emission.
+  previousRouteSummary = null,
+  // BL-018: injected seams for the lane-deepening decision + registry check
+  // ({ask, appendReceipt, runtimeForensicsPresent}); absent → real client +
+  // real registry. decisions.tsv rows are a caller concern on this surface.
+  escalationDecision = null,
+  // C89 TASK-005 (SPEC §6): injected seams for the typed delegation-advice
+  // consult ({ask, appendReceipt, override}); absent → real decision client
+  // when the decision plane is enabled, otherwise a typed local outcome.
+  // decisions.tsv rows are a caller concern on this surface.
+  roleAdviceDecision = null,
+  requestKey = null,
+  routeFingerprint = null,
 } = {}) {
   const absoluteRoot = path.resolve(rootDir);
   // M01.1: additive route-schema stage. Absent config / absent key / unknown value all
@@ -768,6 +376,14 @@ export async function deriveTaskRoute({
     ? await checkHandoffBudget(absoluteRoot)
     : null;
   const worklogBudget = await checkWorklogBudget(absoluteRoot);
+  // BL-013: bounded session-history signals — extracted once per route on the
+  // hook-provided transcript path and merged into the route record. Degraded
+  // input yields the zeroed struct; the route still resolves.
+  const historySignals = await extractHistorySignalsAsync({
+    transcriptPath,
+    routeFingerprint,
+    requestKey,
+  });
   // SPEC FR-009: the lane's workflow policy resolves through the playbook layer —
   // project playbook > user playbook > builtin. resolvePlaybook already falls back to
   // the builtin table, so a null result only means the lane has no policy at all.
@@ -798,9 +414,100 @@ export async function deriveTaskRoute({
     routeSchemaStage,
     runtimeConfig: resolvedRuntimeConfig,
     resolvedWorkflowPolicy,
+    historySignals,
   });
+  // TASK-007 (BL-009): playbook resolution rides the same route signals the
+  // shared resolver just derived — the registry degrades to playbookId: null +
+  // reason and never blocks the route. Merged at resolve time so hook and
+  // helper emit the identical playbookId/workGroup.
+  const playbookResolution = await resolvePlaybookRoute({
+    promptText: normalizedPrompt,
+    commandText: normalizedCommand,
+    targetFile: normalizedTarget,
+    executionMode,
+    escalationTriggers: routeSummary?.escalationTriggers ?? [],
+    projectRoot: absoluteRoot,
+    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.
+  // The keys only land when a routing-table row claimed the prompt (workGroup
+  // non-null): no-match/degraded routes keep the PLAYBOOK_ROUTE_KEYS-only
+  // shape so stage-off routes never grow stray keys.
+  if (playbookResolution.workGroup != null) {
+    routeSummary.path = playbookResolution.path;
+    routeSummary.fastPathKind = playbookResolution.fastPath;
+  } else {
+    delete routeSummary.path;
+    delete routeSummary.fastPathKind;
+  }
   const approachSelector = routeSummary?.approachSelector ?? null;
 
+  // BL-018 (SPEC FR-006): fix-loop escalation — the same transition the hook
+  // path runs in route-task.mjs. 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. Additive
+  // escalatedLane/escalateReason/escalatedVerificationDepth fields — identical
+  // names on both surfaces.
+  const laneEscalationDue = isFixLoopEscalationDue({
+    historySignals: routeSummary.historySignals,
+    config: resolvedRuntimeConfig,
+  });
+  if (laneEscalationDue) {
+    const escalationClient = escalationDecision?.ask
+      ? null
+      : createDecisionClient({
+          config: resolvedRuntimeConfig,
+          transport: decisionPlaneOptions?.transport,
+          env: decisionPlaneOptions?.env,
+          projectRoot: absoluteRoot,
+          homeDir,
+          now: decisionPlaneOptions?.now,
+        });
+    await applyFixLoopEscalation({
+      routeSummary,
+      routingContext: {
+        promptText: normalizedPrompt,
+        commandText: normalizedCommand,
+        targetFile: normalizedTarget,
+        taskType: inferredTaskType,
+        intentMode,
+      },
+      previousRouteSummary,
+      // Same-loop join key for the escalation record — the caller supplies it
+      // (the same routeFingerprint the history extractor joins on); absent →
+      // the record is stamped fingerprint-less and can never bind a prior
+      // emission's exhaustion (escalate fresh, never fabricate 'blocked').
+      routeFingerprint,
+      config: resolvedRuntimeConfig,
+      ask: escalationDecision?.ask
+        ?? (escalationClient ? ({ batch }) => escalationClient.requestBatch(batch) : null),
+      appendReceipt: escalationDecision?.appendReceipt ?? null,
+      runtimeForensicsPresent: escalationDecision?.runtimeForensicsPresent
+        ?? await (async () => {
+          try {
+            const records = await loadRegistry({ projectRoot: absoluteRoot, homeDir });
+            return records.some((record) => record?.frontmatterValid && record?.playbookId === 'runtime-forensics');
+          } catch {
+            return false;
+          }
+        })(),
+    });
+  }
+
+  // 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'. Absent/corrupt
+  // artifact → static stays; never throws.
+  await applyMeasuredTier({ projectRoot: absoluteRoot, routeSummary });
+
   // TASK-004 (SPEC §5 FR-008/FR-009): decision-plane hook. Stage resolves via
   // the shared resolver — absent/malformed → 'off' → zero cost, byte-identical
   // route. shadow → redacted receipt only (deterministic policy authoritative);
@@ -840,6 +547,40 @@ export async function deriveTaskRoute({
   }
 
 
+  // C89 TASK-005 (SPEC §6 FR-04): typed delegation advice consult — the
+  // optional unic-decision round only ever answers the owner-bounded role
+  // question; the deterministic fields the route already carries stay
+  // authoritative and every failure records a typed advice.model outcome.
+  // The consult seam defaults to the same decision client the plane uses.
+  if (routeSummary?.delegationAdvice) {
+    try {
+      const roleAdviceClient = !roleAdviceDecision?.ask
+        && resolveDecisionPlaneStage(resolvedRuntimeConfig) !== 'off'
+        ? createDecisionClient({
+            config: resolvedRuntimeConfig,
+            transport: decisionPlaneOptions?.transport,
+            env: decisionPlaneOptions?.env,
+            projectRoot: absoluteRoot,
+            homeDir,
+            now: decisionPlaneOptions?.now,
+          })
+        : null;
+      await applyRoleAdviceConsult({
+        routeSummary,
+        config: resolvedRuntimeConfig,
+        ask: roleAdviceDecision?.ask
+          ?? (roleAdviceClient ? ({ batch }) => roleAdviceClient.requestBatch(batch) : null),
+        appendReceipt: roleAdviceDecision?.appendReceipt ?? null,
+        override: roleAdviceDecision?.override ?? null,
+        now: decisionPlaneOptions?.now ?? (() => Date.now()),
+      });
+    } catch (error) {
+      degradedWarnings.push(
+        `role-advice consult: unavailable (${error?.message ?? String(error)})`,
+      );
+    }
+  }
+
   return {
     activeSkills,
     routingContext: {
@@ -867,6 +608,9 @@ export async function deriveTaskRoute({
 }
 
 export function buildRouteSummary({
+  // BL-013: precomputed bounded history struct — merged additively via the
+  // shared resolver below. Absent/null → no field, byte-identical route.
+  historySignals = null,
   activeSkills = [],
   routingContext = {},
   contextRecommendation = null,
@@ -926,21 +670,51 @@ export 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
@@ -948,36 +722,7 @@ export 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
@@ -1040,12 +785,26 @@ export function buildRouteSummary({
     approachSelector,
     executionContract,
     completionState,
+    // 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,
+        }
+      : {}),
     // M01.1 additive C01 groups — present only when routing.routeSchema.stage != "off".
     ...(resolvedRouteFields ?? {}),
     // FR-003 additive top-level field — present only when a risk stage is on.
     ...(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,
@@ -1069,6 +828,10 @@ export function buildRouteSummary({
     // TASK-004 additive field — present only when a caller supplies a
     // decision-plane result (stage != 'off').
     ...(decisionPlane ? { decisionPlane } : {}),
+    // 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: summaryLine || 'task=unknown',
   };
 }
@@ -1195,34 +958,226 @@ 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. A bare
+  // imperative wearing a question mark ("sửa file cho tôi?") keeps its lane.
+  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. 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);
 }
 
 
+
 // @decision-point preflight.execution-lane.v1 — the execution lane is a
 // registered preflight decision; this deterministic ladder is its
 // 'deterministic-route' fallback policy implementation.
@@ -1274,31 +1229,43 @@ 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.
+    || /\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?" consult. A targetFile still vetoes.
+  // C85-019b: leading interrogative alone does NOT consult — "How do I fix X?"
+  // still carries the verb (a how-to ask is handled below by the no-mutation
+  // residue path when the verb is genuinely absent). Consult requires either
+  // a leading interrogative or a question tail AND no surviving imperative.
   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 (isInformationalPrompt({ promptText, commandText, scores })) {
     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)
@@ -1492,38 +1459,6 @@ function buildApproachSelectorResult({
   };
 }
 
-function buildCompletionState({ executionMode = null, verificationRecommendation = null } = {}) {
-  if (!executionMode) {
-    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,
   completionState = null,
@@ -2105,6 +2040,254 @@ function deriveDelegationRecommendation({
   return null;
 }
 
+// --- C89 TASK-005 (SPEC §6 FR-04, §11): typed delegation advice (shadow) ------
+// 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.
+export const DELEGATION_ADVICE_POLICY_VERSION = 'role-advice.v1';
+export 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).
+export const DELEGATION_ADVICE_ROLES = Object.freeze(['retriever', 'reasoner', 'reviewer']);
+export 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' },
+});
+
+/**
+ * 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 deriveContextIntent({ promptText, commandText, targetFile, selectedIds }) {
   if (promptText.trim()) {
     return promptText.trim();