@ngockhoale/ukit 3.3.3 → 3.4.1

package/template_project/.claude/hooks/skill-router.sh

@@ -174,7 +174,9 @@ INPUT_FILE="$UKIT_INPUT_FILE" PROJECT_ROOT="$PROJECT_ROOT" STATE_FILE="$STATE_FI
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const os = require('os');
 const { pathToFileURL } = require('url');
+const { spawn } = require('child_process');
 
 // Wall-clock watchdog. This hook runs on the UserPromptSubmit/PreToolUse hot path but has
 // no host-side process-group kill: when indexed-context resolution hangs (a wedged import,
@@ -342,6 +344,282 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     };
   }
 
+  // TASK-004 (BL-006): shared route resolver — the same module route-task.mjs
+  // uses, so hook state and helper state compute identical rigor/fastPath/
+  // riskFloor/resumable/decision-shadow fields. Loaded lazily via pathToFileURL
+  // (cache-utils pattern); any load/derive failure degrades to null so routing
+  // never breaks over advisory fields. Path is resolved lazily because
+  // `projectRoot` is declared below (TDZ).
+  let routeResolverModule = null;
+  let routeResolverLoadAttempted = false;
+  async function loadRouteResolver() {
+    if (!routeResolverLoadAttempted) {
+      routeResolverLoadAttempted = true;
+      try {
+        const routeResolverPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'route-resolver.mjs');
+        if (await pathExists(routeResolverPath)) {
+          routeResolverModule = await import(pathToFileURL(routeResolverPath).href);
+        }
+      } catch {
+        routeResolverModule = null;
+      }
+    }
+    return routeResolverModule;
+  }
+
+  // TASK-007 (BL-009): playbook registry — same lazy pathToFileURL pattern as
+  // the shared resolver. Loaded once per hook run; failure degrades to null so
+  // routing never blocks on playbook resolution.
+  let playbookRegistryModule = null;
+  let playbookRegistryLoadAttempted = false;
+  async function loadPlaybookRegistry() {
+    if (!playbookRegistryLoadAttempted) {
+      playbookRegistryLoadAttempted = true;
+      try {
+        const registryPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'playbook-registry.mjs');
+        if (await pathExists(registryPath)) {
+          playbookRegistryModule = await import(pathToFileURL(registryPath).href);
+        }
+      } catch {
+        playbookRegistryModule = null;
+      }
+    }
+    return playbookRegistryModule;
+  }
+
+  // BL-019 (SPEC FR-001): measured tier module — same lazy pathToFileURL
+  // pattern. A missing module/failure degrades to null so the static map
+  // stays authoritative and routing never blocks on the artifact read.
+  let tierSelectionModule = null;
+  let tierSelectionLoadAttempted = false;
+  async function loadTierSelection() {
+    if (!tierSelectionLoadAttempted) {
+      tierSelectionLoadAttempted = true;
+      try {
+        const modulePath = path.join(projectRoot, '.claude', 'ukit', 'index', 'tier-selection.mjs');
+        if (await pathExists(modulePath)) {
+          tierSelectionModule = await import(pathToFileURL(modulePath).href);
+        }
+      } catch {
+        tierSelectionModule = null;
+      }
+    }
+    return tierSelectionModule;
+  }
+
+  // BL-013: session-history extractor — same lazy pathToFileURL pattern as the
+  // shared resolver. Async extraction (fsp tail read ≤16KiB) so a stalled mount
+  // never parks the event loop under the armed deadline (BUG-C21-04 posture);
+  // a missing module or any failure degrades to null and routing continues.
+  let historyExtractorModule = null;
+  let historyExtractorLoadAttempted = false;
+  async function loadHistoryExtractor() {
+    if (!historyExtractorLoadAttempted) {
+      historyExtractorLoadAttempted = true;
+      try {
+        const extractorPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'session-history-extractor.mjs');
+        if (await pathExists(extractorPath)) {
+          historyExtractorModule = await import(pathToFileURL(extractorPath).href);
+        }
+      } catch {
+        historyExtractorModule = null;
+      }
+    }
+    return historyExtractorModule;
+  }
+
+  // One bounded extraction per route, reused by provisional/cached/final
+  // emissions. routeFingerprint is only known post-route; markers whose only
+  // key is the fingerprint of a rerun-identical route match via the previous
+  // state's fingerprint when requestKey still matches.
+  async function extractRouteHistorySignals({ requestKey: routeRequestKey = null, routeFingerprint = null } = {}) {
+    try {
+      const extractor = await loadHistoryExtractor();
+      if (!extractor || typeof extractor.extractHistorySignalsAsync !== 'function') {
+        return null;
+      }
+      return await extractor.extractHistorySignalsAsync({
+        transcriptPath,
+        routeFingerprint: routeFingerprint
+          ?? (routeRequestKey && previous?.requestKey === routeRequestKey
+            ? previous?.fingerprint ?? null
+            : null),
+        requestKey: routeRequestKey,
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  // BL-017 (SPEC FR-005): hook-path decision-shadow emission. The decision
+  // plane must see every route, not just helper-path ones — a detached
+  // `route-task.mjs --decision-shadow` child replays the same batched shadow
+  // the helper runs inline and appends decisions.tsv receipts. Fire-and-
+  // forget (`detached` + `unref`, stdio ignored): route output is already
+  // persisted by the caller, the child inherits the 3s adapter cap via
+  // config, and every typed failure degrades to deterministic fallback rows.
+  // Only ever spawned when the resolved plane stage is not 'off'; a spawn
+  // error is advisory — the route stands.
+  function fireRouteDecisionShadow({ decisionShadowFields = null, targetFile = null } = {}) {
+    try {
+      if (!decisionShadowFields || decisionShadowFields.stage === 'off') {
+        return;
+      }
+      const routeTaskPath = process.env.HOOK_DIR
+        ? path.resolve(process.env.HOOK_DIR, '..', 'ukit', 'index', 'route-task.mjs')
+        : path.join(projectRoot, '.claude', 'ukit', 'index', 'route-task.mjs');
+      const args = [
+        routeTaskPath,
+        '--decision-shadow',
+        '--root', projectRoot,
+      ];
+      if (targetFile) {
+        args.push('--target-file', String(targetFile));
+      }
+      const child = spawn(process.execPath, args, {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env,
+      });
+      child.unref();
+    } catch {
+      // Fire-and-forget: a spawn failure must never block or break routing.
+    }
+  }
+
+
+  async function buildSharedRouteFields({
+    historySignals = null,
+    routingContext = {},
+    activeSkills = [],
+    contextRecommendation = null,
+    verificationRecommendation = null,
+  } = {}) {
+    try {
+      const resolver = await loadRouteResolver();
+      if (!resolver || typeof resolver.deriveRouteFields !== 'function') {
+        // BL-013: a missing resolver must not drop the extracted history
+        // struct — return the bounded bundle alone so the merge below still
+        // lands counters/enums on route state.
+        return historySignals ? { historySignals } : null;
+      }
+      const fields = resolver.deriveRouteFields({
+        promptText: routingContext.promptText || '',
+        commandText: routingContext.commandText || '',
+        targetFile: routingContext.targetFile || null,
+        intentMode: routingContext.intentMode || null,
+        taskType: routingContext.taskType || null,
+        executionMode: routingContext.executionMode || null,
+        riskSignals: Array.isArray(routingContext.riskSignals)
+          ? routingContext.riskSignals
+          : [],
+        activeSkillIds: activeSkills
+          .map((item) => (item && typeof item === 'object' ? item.id : item))
+          .filter((id) => typeof id === 'string' && id),
+        verificationRecommendation,
+        contextPreview: contextRecommendation?.preview ?? contextRecommendation ?? null,
+        executionScores: routingContext.executionScores ?? {},
+        historySignals,
+        lastExplicitUserPromptText: routingContext.lastExplicitUserPromptText ?? null,
+        config: runtimeConfig,
+      });
+      // TASK-007 (BL-009): playbook resolution merges into the same field
+      // bundle the hook spreads into routeSummary — hook and helper emit the
+      // identical playbookId/workGroup. Missing registry degrades to
+      // playbookId: null (the state still carries the field for parity).
+      const playbook = { playbookId: null, workGroup: null, playbookReason: null, playbookLoad: null, path: null, fastPathKind: null };
+      try {
+        const registry = await loadPlaybookRegistry();
+        if (registry && typeof registry.resolvePlaybookRoute === 'function') {
+          const resolution = await registry.resolvePlaybookRoute({
+            promptText: routingContext.promptText || '',
+            commandText: routingContext.commandText || '',
+            targetFile: routingContext.targetFile || null,
+            executionMode: routingContext.executionMode || null,
+            intentMode: routingContext.intentMode || null,
+            escalationTriggers: fields?.escalationTriggers ?? [],
+            projectRoot,
+            homeDir: os.homedir(),
+          });
+          playbook.playbookId = resolution.playbookId ?? null;
+          playbook.workGroup = resolution.workGroup ?? null;
+          playbook.playbookReason = resolution.reason ?? null;
+          playbook.playbookLoad = resolution.playbookLoad ?? null;
+          // BL-010: direct/handoff path + the ARCH fast-path enum —
+          // `fastPathKind`, never `fastPath`: the spread above must leave the
+          // resolver's FR-004 fastPath eligibility object intact (M03).
+          playbook.path = resolution.path ?? null;
+          playbook.fastPathKind = resolution.fastPath ?? null;
+        }
+      } catch {
+        playbook.playbookReason = 'registry-error';
+      }
+      return { ...fields, ...playbook };
+    } catch {
+      return null; // resolver failure must never break routing
+    }
+  }
+  // TASK-004 (BL-006): merge the shared-resolver output into a routeSummary
+  // with the same key-presence semantics the helper path emits:
+  //  - resolved groups + rigor/resumable/escalationTriggers/decisionShadow ride
+  //    the schema-stage gate (absent entirely when routeSchema is off);
+  //  - fastPath/riskFloor only land when non-null (their own stage gates).
+  function mergeResolverFields(routeSummary, fields, { onlyMissing = false } = {}) {
+    if (!routeSummary || !fields) {
+      return;
+    }
+    const merged = fields.resolved && typeof fields.resolved === 'object'
+      ? {
+          ...fields.resolved,
+          rigor: fields.rigor ?? null,
+          resumable: fields.resumable ?? null,
+          escalationTriggers: fields.escalationTriggers ?? [],
+          decisionShadow: fields.decisionShadowFields ?? null,
+        }
+      : null;
+    if (merged && (!onlyMissing || routeSummary.routeVersion === undefined)) {
+      Object.assign(routeSummary, merged);
+    }
+    for (const key of ['fastPath', 'riskFloor']) {
+      if (fields[key] != null
+          && (!onlyMissing || routeSummary[key] === undefined || routeSummary[key] === null)) {
+        routeSummary[key] = fields[key];
+      }
+    }
+    // BL-013: bounded history counters land whenever extraction produced a
+    // struct — counters/enums only, additive-nullable, never transcript text.
+    if (fields.historySignals != null
+        && (!onlyMissing || routeSummary.historySignals === undefined || routeSummary.historySignals === null)) {
+      routeSummary.historySignals = fields.historySignals;
+    }
+    // TASK-007 (BL-009): playbook fields always land (null included) so hook
+    // state and helper state carry the identical playbookId/workGroup shape.
+    if (fields.playbookId !== undefined || fields.workGroup !== undefined) {
+      if (!onlyMissing || routeSummary.playbookId === undefined) {
+        routeSummary.playbookId = fields.playbookId ?? null;
+        routeSummary.workGroup = fields.workGroup ?? null;
+        // BL-010: route path + ARCH fast-path enum (`fastPathKind` — the
+        // `fastPath` key 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 the helper's
+        // deriveTaskRoute merge so schema-off/no-match routes stay clean.
+        if (fields.workGroup != null) {
+          routeSummary.path = fields.path ?? null;
+          routeSummary.fastPathKind = fields.fastPathKind ?? null;
+        } else {
+          delete routeSummary.path;
+          delete routeSummary.fastPathKind;
+        }
+      }
+      if (routeSummary.playbookReason === undefined) {
+        routeSummary.playbookReason = fields.playbookReason ?? null;
+      }
+      if (routeSummary.playbookLoad === undefined) {
+        routeSummary.playbookLoad = fields.playbookLoad ?? null;
+      }
+    }
+  }
+
   async function existsSkill(projectRoot, relativePath) {
     return pathExists(path.join(projectRoot, relativePath));
   }
@@ -1661,31 +1939,222 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     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 and by the question-shape
+  // gate below (question + no order → consult).
+  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' is a polite request marker, not a status tag;
+      // also EXCLUDED are wh-led modals ("which files should I update") —
+      // a selection ask is a plan, not a yes/no consult. Strips run LAST
+      // so a real imperative mid-sentence ("sửa file X cho tôi") 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({
@@ -1739,6 +2208,15 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       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)
@@ -1756,25 +2234,25 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       || /^(?: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.
+    // 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?" mutating while
+    // "lỗi này chưa nhỉ" / "should I fix the hook?" consult. A targetFile
+    // still vetoes.
     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);
     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) {
@@ -2394,12 +2872,50 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       executionScores: routeSummary.executionScores || null,
       approachSelector: routeSummary.approachSelector || null,
       executionContract: routeSummary.executionContract || null,
+      // TASK-007 (BL-009): playbook fields survive compaction — identical
+      // playbookId/workGroup to what route-task.mjs compactRouteSummary emits.
+      // BL-010: direct/handoff path + fast-path enum survive compaction too —
+      // verification-guard + eval fixtures read them off persisted 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 } : {}),
       completionState: routeSummary.completionState || null,
       continuationState: routeSummary.continuationState || null,
       delegateHint: routeSummary.delegateHint || null,
       nextActionType: routeSummary.nextActionType || null,
       nextActionCommand: routeSummary.nextActionCommand || null,
       helperHint: routeSummary.helperHint || null,
+      // TASK-004 (BL-006): shared-resolver fields, identical to what
+      // route-task.mjs / taskRouting.js routeSummary emits on the helper path.
+      rigor: routeSummary.rigor ?? null,
+      fastPath: routeSummary.fastPath ?? null,
+      riskFloor: routeSummary.riskFloor ?? null,
+      resumable: routeSummary.resumable ?? null,
+      decisionShadow: routeSummary.decisionShadow ?? null,
+      escalationTriggers: Array.isArray(routeSummary.escalationTriggers)
+        ? routeSummary.escalationTriggers
+        : [],
+      // BL-013: bounded history counters survive compaction — identical to the
+      // helper's compactRouteSummary; conditional so absent stays byte-identical.
+      ...(routeSummary.historySignals ? { historySignals: routeSummary.historySignals } : {}),
+      // BL-019: the applied measured tier survives compaction — additive so
+      // no-map routes keep the pre-BL-019 compact shape (identical to
+      // route-task.mjs compactRouteSummary).
+      ...(routeSummary.measuredTier != null ? { measuredTier: routeSummary.measuredTier } : {}),
+      ...(routeSummary.routeVersion !== undefined
+        ? {
+            routeVersion: routeSummary.routeVersion,
+            intent: routeSummary.intent ?? null,
+            execution: routeSummary.execution ?? null,
+            evidence: routeSummary.evidence ?? null,
+            ceremonyBudget: routeSummary.ceremonyBudget ?? null,
+            capabilityPolicy: routeSummary.capabilityPolicy ?? null,
+            escalation: routeSummary.escalation ?? null,
+          }
+        : {}),
     };
   }
 
@@ -2421,17 +2937,52 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
         prompt: routingContext.lastExplicitUserPromptText || '',
         adapter: routingContext.adapter || 'claude',
       }),
+      // TASK-004 (BL-006): shared-resolver fields so audit rows carry the same
+      // rigor/fastPath/riskFloor/resumable/shadow data the helper path emits.
+      rigor: routeSummary.rigor ?? null,
+      fastPath: routeSummary.fastPath ?? null,
+      riskFloor: routeSummary.riskFloor ?? null,
+      resumable: routeSummary.resumable ?? null,
+      decisionShadow: routeSummary.decisionShadow ?? null,
+      escalationTriggers: Array.isArray(routeSummary.escalationTriggers)
+        ? routeSummary.escalationTriggers
+        : [],
       targetFile: 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 parity with route-task.mjs: resolved active-skill ids for the
+      // skill-accuracy roll-ups. Telemetry only — excluded from dedupeKey.
+      skillIds: (state?.activeSkills || [])
+        .map((item) => (item && typeof item === 'object' ? item.id : item))
+        .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),
       nextActionType: routeSummary.nextActionType || null,
       nextMilestone: routeSummary?.continuationState?.nextMilestone || null,
-      repeatCount: routeSummary?.continuationState?.repeatCount || null,
+      // TASK-007 (BL-009): playbook route fields — identical to the helper's
+      // buildRouteAuditEntry; BL-010/011/012 read playbookId off the route row.
+      playbookId: routeSummary.playbookId ?? null,
+      workGroup: routeSummary.workGroup ?? null,
+      playbookLoad: routeSummary.playbookLoad ?? null,
+      // BL-010: direct/handoff path + fast-path enum on the audit row so the
+      // eval join can assert `direct, fastPath=small-feature` (E-01).
+      path: routeSummary.path ?? null,
+      fastPathKind: routeSummary.fastPathKind ?? null,
       rescueMode: routeSummary?.continuationState?.rescueMode || null,
       wideningBlocked: routeSummary?.continuationState?.wideningBlocked || null,
+      // BL-013: bounded history counters on the audit row — identical to the
+      // helper's buildRouteAuditEntry emission.
+      historySignals: routeSummary.historySignals ?? null,
     };
   }
 
@@ -2538,6 +3089,9 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     // itself instead of silently losing data.
     const sidecarPath = `${filePath}.unlocked.jsonl`;
     const lockPath = `${filePath}.lock`;
+    // BL-004: ring overflow spills here — same directory, read by
+    // routeOutcomes/skillAccuracy alongside the ring.
+    const segmentsPath = path.join(path.dirname(filePath), 'route-audit.segments.jsonl');
 
     function entryDedupeKey(item) {
       return stableMachineDigest({
@@ -2574,7 +3128,23 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
         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) };
+    }
+
+    async function spillEvictedEntries(evicted) {
+      if (!evicted?.length) return;
+      try {
+        await fsp.appendFile(
+          segmentsPath,
+          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.
+      }
     }
 
     // Synchronous last-chance fold for the self-deadline kill path: process.on('exit')
@@ -2587,6 +3157,18 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     // handlers below (event loop is gone; async cannot run). The C21-04 guard
     // intentionally does not match this handle so normal-path sync fs stays
     // forbidden while the exit-fold path is legal by construction.
+    function spillEvictedEntriesSync(evicted) {
+      if (!evicted?.length) return;
+      try {
+        fsSync.appendFileSync(
+          segmentsPath,
+          evicted.map((item) => JSON.stringify(item)).join('\n') + '\n',
+        );
+      } catch {
+        // same degrade posture as the async spill above
+      }
+    }
+
     const fsSync = fs;
     function claimSidecarSync() {
       const claimedPath = `${sidecarPath}.claim-${process.pid}-${Date.now()}`;
@@ -2645,9 +3227,11 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
         try {
           parsed = JSON.parse(fsSync.readFileSync(filePath, 'utf8'));
         } catch {}
+        const { entries: folded, evicted } = mergeEntries(staged, parsed, null);
+        spillEvictedEntriesSync(evicted);
         const tmpPath = `${filePath}.exitfold-${process.pid}`;
         fsSync.writeFileSync(tmpPath, JSON.stringify({
-          entries: mergeEntries(staged, parsed, null),
+          entries: folded,
         }));
         fsSync.renameSync(tmpPath, filePath);
       } finally {
@@ -2693,8 +3277,10 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
         }
       }
 
+      const { entries: mergedEntries, evicted } = mergeEntries(sidecarEntries, parsed, entry);
+      await spillEvictedEntries(evicted);
       await writeJsonFileAtomic(filePath, JSON.stringify({
-        entries: mergeEntries(sidecarEntries, parsed, entry),
+        entries: mergedEntries,
       }));
     }, {
       onUnlocked: async (reason) => {
@@ -2830,6 +3416,13 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       : {})
     : storedPrevious;
   const runtimeConfig = await loadRuntimeConfig(projectRoot);
+  // BL-013: the hook/bridge payload's transcript pointer (ukit-bridge.js:217,228
+  // forwards transcriptPath; Claude Code payloads carry transcript_path). The
+  // extractor reads a bounded tail of this file — never the whole transcript.
+  const transcriptPathCandidate = payload.transcript_path ?? payload.transcriptPath;
+  const transcriptPath = transcriptPathCandidate === undefined || transcriptPathCandidate === null
+    ? null
+    : String(transcriptPathCandidate).trim() || null;
 
   const promptText = extractPrompt(payload);
   const commandText = payload.tool_input?.command || payload.command || '';
@@ -2866,7 +3459,8 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
   const now = Date.now();
   const debounceMs = 10 * 60 * 1000;
   const previousTs = Number(previous?.ts || 0);
-  const informationalNoTargetPrompt = isInformationalPrompt({ promptText, commandText }) && !filePath;
+  const informationalNoTargetPrompt = (isInformationalPrompt({ promptText, commandText })
+    || hasAdvisoryOnlyAssertion({ promptText, commandText })) && !filePath;
   // A delivery-only prompt ("push this to git", "đẩy bộ này lên git") starts a new,
   // mutation-free action and typically matches no skill. It must not inherit the
   // previous request's completion contract — carrying find-cause/map-impact debt
@@ -3036,6 +3630,10 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     routingContext,
     previousContextFingerprint: previousContext?.fingerprint || null,
   });
+  // BL-013: one bounded tail extraction per route — reused by the provisional,
+  // cached-reuse, and final emissions so all three carry identical counters.
+  // ≤50ms async read, never throws, null when the extractor module is absent.
+  const routeHistorySignals = await extractRouteHistorySignals({ requestKey });
   // Persist the completion contract BEFORE any cache import or indexed-context resolution.
   // Those later steps can take longer than the host's PreToolUse hook timeout. Previously a
   // timeout killed this process before its only state write, and completion-gate.sh then had
@@ -3050,6 +3648,15 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     previous?.routeSummary?.continuationState || null,
   );
   applyRescueBiasToRouteSummary(provisionalRouteSummary);
+  // TASK-004 (BL-006): merge shared-resolver fields into the provisional
+  // summary so even a timeout-killed route carries rigor/riskFloor/etc. The
+  // provisional pass runs before context/verification resolution, so it passes
+  // null previews; the final pass below recomputes with the full context.
+  mergeResolverFields(provisionalRouteSummary, await buildSharedRouteFields({
+    routingContext,
+    activeSkills: selected,
+    historySignals: routeHistorySignals,
+  }));
   const provisionalState = {
     ...(sessionId ? { sessionId } : {}),
     requestKey,
@@ -3108,6 +3715,18 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     if (rescuedRouteSummary) {
       applyRescueBiasToRouteSummary(rescuedRouteSummary);
     }
+    // TASK-004: cached summaries written before the resolver shipped (or after
+    // a resolver load failure) lack the shared fields — fill only what's
+    // missing, never overwrite a cached value.
+    let reusedSharedFields = null;
+    if (rescuedRouteSummary) {
+      reusedSharedFields = await buildSharedRouteFields({
+        routingContext,
+        activeSkills: selected,
+        historySignals: routeHistorySignals,
+      });
+      mergeResolverFields(rescuedRouteSummary, reusedSharedFields, { onlyMissing: true });
+    }
     const reusedState = {
       ...cachedRouteState,
       ...(sessionId ? { sessionId } : {}),
@@ -3125,9 +3744,20 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     await ensureDir(statePath);
     await writeJsonFileAtomic(statePath, JSON.stringify(reusedState));
     await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+      routingContext: reusedState.routingContext || {},
+      routeSummary: rescuedRouteSummary || {},
       state: reusedState,
     }));
 
+    // BL-017: detached decisions.tsv shadow emission for the reused route —
+    // receipts only; the persisted state above is the authoritative record.
+    fireRouteDecisionShadow({
+      decisionShadowFields: rescuedRouteSummary?.decisionShadow
+        ?? reusedSharedFields?.decisionShadowFields
+        ?? null,
+      targetFile: routingContext.targetFile ?? null,
+    });
+
     process.stdout.write(`[ukit-skill-router] Read skills: ${getActiveSkillPaths(reusedState.activeSkills || []).join(', ')}\n`);
     process.stdout.write(`[ukit-skill-router] Route: ${formatDisplayRouteSummary(reusedState.routeSummary, reusedState.routingContext)}\n`);
     const reusedNextDisplay = formatDisplayNextAction(reusedState.routeSummary);
@@ -3183,6 +3813,31 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
       previous?.routeSummary?.continuationState || null,
     );
     applyRescueBiasToRouteSummary(routeSummary);
+    // TASK-004 (BL-006): shared-resolver fields with full context — the same
+    // deriveRouteFields call route-task.mjs/taskRouting.js makes, so the hook
+    // state and helper state can no longer diverge.
+    const finalSharedFields = await buildSharedRouteFields({
+      routingContext,
+      activeSkills: selected,
+      contextRecommendation,
+      verificationRecommendation,
+      historySignals: routeHistorySignals,
+    });
+    mergeResolverFields(routeSummary, finalSharedFields);
+    // BL-019 (SPEC FR-001): fold the persisted measured map into the route —
+    // identical semantics to route-task.mjs finalizeTaskRoute / taskRouting.js
+    // deriveTaskRoute: measuredTier emitted additively; modelTier follows the
+    // map only when tier-map.json says 'promote'. Advisory — every failure
+    // degrades to the static map.
+    try {
+      const tierSelection = await loadTierSelection();
+      if (tierSelection && typeof tierSelection.applyMeasuredTier === 'function') {
+        await tierSelection.applyMeasuredTier({ projectRoot, routeSummary });
+      }
+    } catch {
+      // static map stays authoritative
+    }
+
 
   const fingerprint = buildRouteStateFingerprint({
     activeSkills: selected,
@@ -3218,6 +3873,17 @@ setTimeout(() => process.exit(0), HOOK_DEADLINE_MS).unref();
     routeSummary,
     state: sharedState,
   }));
+
+  // BL-017: detached decisions.tsv shadow emission — fire-and-forget child
+  // replays the batched adapter shadow against the persisted route state.
+  // Spawned only after the state write the child reads; a spawn failure is
+  // advisory and the route output below still emits unchanged.
+  fireRouteDecisionShadow({
+    decisionShadowFields: routeSummary?.decisionShadow
+      ?? finalSharedFields?.decisionShadowFields
+      ?? null,
+    targetFile: routingContext.targetFile ?? null,
+  });
   if (typeof cacheUtils?.writeRecentCacheEntry === 'function') {
     await cacheUtils.writeRecentCacheEntry(routeCachePath, compactRouteCacheState(sharedState), {
       maxEntries: cacheUtils.DEFAULT_RECENT_CACHE_MAX_ENTRIES,