@ngockhoale/ukit 3.4.29 → 3.4.31

package/src/index/impactContext.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { getArtifactPath, INDEX_ARTIFACTS } from './paths.js';
+import { getArtifactPath, INDEX_ARTIFACTS, isLikelyTestFilePath } from './paths.js';
 import { classifyImpactRisk, findMirrorCounterparts } from './impactCatalog.js';
 import { inferRelatedTestsFromArtifacts, loadRelatedTestArtifacts } from './relatedTests.js';
 import { importsNeedAliasContext, loadImportAliasContext, resolveImportSpecifier } from './importResolution.js';
@@ -98,10 +98,11 @@ export async function resolveImpactContext({
   const normalizedChangedFiles = unique(changedFiles.map(normalizePath));
   const normalizedChangedSymbols = unique(changedSymbols.map((symbol) => String(symbol ?? '').trim()));
 
-  const [callsArtifact, importsArtifact, filesArtifact, relatedArtifacts] = await Promise.all([
+  const [callsArtifact, importsArtifact, filesArtifact, symbolsArtifact, relatedArtifacts] = await Promise.all([
     readArtifact(absoluteRoot, INDEX_ARTIFACTS.calls),
     readArtifact(absoluteRoot, INDEX_ARTIFACTS.imports),
     readArtifact(absoluteRoot, INDEX_ARTIFACTS.files),
+    readArtifact(absoluteRoot, INDEX_ARTIFACTS.symbols),
     loadRelatedTestArtifacts({ rootDir: absoluteRoot }),
   ]);
   const callItems = safeItems(callsArtifact);
@@ -135,6 +136,15 @@ export async function resolveImpactContext({
     ...normalizedChangedSymbols,
     ...changedRecords.map((record) => record.symbol),
   ]);
+  // Global-registered symbols (window.X / app.config.globalProperties.$X /
+  // app.component(...)) are reachable without imports, so a bare-name call is
+  // already proof for them.
+  const changedGlobalSymbols = new Set(
+    safeItems(symbolsArtifact)
+      .filter((item) => item.type === 'global' && changedFileSet.has(normalizePath(item.filePath)))
+      .map((item) => item.name),
+  );
+  const candidateCallers = [];
   if (callerTargets.size > 0) {
     for (const record of callItems) {
       const matchedSymbol = (record.calls ?? []).find((name) => callerTargets.has(name));
@@ -146,7 +156,12 @@ export async function resolveImpactContext({
         continue;
       }
 
-      callers.push({ filePath: record.filePath, symbol: record.symbol, reason: `calls ${matchedSymbol}` });
+      candidateCallers.push({
+        filePath: record.filePath,
+        symbol: record.symbol,
+        reason: `calls ${matchedSymbol}`,
+        matchedSymbol,
+      });
     }
   }
 
@@ -179,48 +194,108 @@ export async function resolveImpactContext({
     }
   }
 
+  // Callers only count with proof: an import edge into a changed file
+  // (directly / re-export / alias), an explicit SQL reference record, or a
+  // global-registered changed symbol. Name-only matches are reported as
+  // unverifiedImpact instead of pretending exhaustive caller knowledge.
+  const importerSet = new Set(importers);
+  const isVerifiedCaller = (entry) => importerSet.has(entry.filePath)
+    || String(entry.filePath ?? '').toLowerCase().endsWith('.sql')
+    || changedGlobalSymbols.has(entry.matchedSymbol);
+  // Output rows keep the historical { filePath, symbol, reason } shape.
+  const toCallerRow = ({ filePath, symbol, reason }) => ({ filePath, symbol, reason });
+  const verifiedCallers = candidateCallers.filter(isVerifiedCaller).map(toCallerRow);
+  const unverifiedImpact = unique(
+    candidateCallers
+      .filter((entry) => !isVerifiedCaller(entry))
+      .map((entry) => entry.filePath),
+  );
+
   const candidateFiles = unique([
     ...normalizedChangedFiles,
     ...importers,
-    ...callers.map((item) => item.filePath),
+    ...verifiedCallers.map((item) => item.filePath),
     ...mirrorCounterparts.map((item) => item.filePath),
   ]);
-  const relatedTests = inferRelatedTestsFromArtifacts({
+  const relatedTestsFromArtifacts = inferRelatedTestsFromArtifacts({
     candidateFiles,
     analogsMap: relatedArtifacts.analogsMap,
     relationsMap: relatedArtifacts.relationsMap,
     limit: budget.maxTests,
   }).map((entry) => entry.filePath);
+  // Importer test files are related tests by definition: they import the
+  // changed file and live under a test directory.
+  const importerTestFiles = importers.filter((filePath) => isLikelyTestFilePath(filePath));
+  const relatedTests = unique([...importerTestFiles, ...relatedTestsFromArtifacts]);
 
   const recommendedTestFiles = unique([
     ...relatedTests,
     ...risk.riskLabels.flatMap((label) => RISK_TEST_RECOMMENDATIONS[label] ?? []),
   ]);
 
-  const dedupedCallers = dedupeCallers(callers).slice(0, budget.maxCallers);
+  // Stale-entry guard: a renamed/deleted file must not surface as impact.
+  // Only the capped output lists are stat-checked, so the cost stays bounded.
+  const existingRelatedTests = await filterExistingPaths(absoluteRoot, relatedTests);
+  const dedupedCallers = await filterExistingCallers(absoluteRoot, dedupeCallers(verifiedCallers));
+  const existingImporters = await filterExistingPaths(absoluteRoot, unique(importers));
+  const existingUnverifiedImpact = await filterExistingPaths(absoluteRoot, unverifiedImpact);
+
+  const dedupedCallerList = dedupedCallers.slice(0, budget.maxCallers);
+  const importerList = existingImporters.slice(0, budget.maxImporters);
+  const calleeList = unique(callees.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value));
+  const relatedTestList = existingRelatedTests.slice(0, budget.maxTests);
+  const unverifiedList = existingUnverifiedImpact.slice(0, budget.maxCallers);
 
   return {
     changedFiles: normalizedChangedFiles,
     changedSymbols: normalizedChangedSymbols,
     riskLabels: risk.riskLabels,
     requiresImpactCheck: risk.requiresImpactCheck,
-    callees: unique(callees.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallees),
-    callers: dedupedCallers,
-    importers: unique(importers).slice(0, budget.maxImporters),
+    callees: calleeList.slice(0, budget.maxCallees),
+    callers: dedupedCallerList,
+    importers: importerList,
     dependencies: unique(dependencies).slice(0, budget.maxImporters),
     mirrorCounterparts,
-    relatedTests,
+    relatedTests: relatedTestList,
     recommendedTestFiles,
+    unverifiedImpact: unverifiedList,
+    truncated: {
+      callers: Math.max(dedupedCallers.length - dedupedCallerList.length, 0),
+      importers: Math.max(existingImporters.length - importerList.length, 0),
+      callees: Math.max(calleeList.length - budget.maxCallees, 0),
+      relatedTests: Math.max(existingRelatedTests.length - relatedTestList.length, 0),
+      unverifiedImpact: Math.max(existingUnverifiedImpact.length - unverifiedList.length, 0),
+    },
     explanations: {
       callees: changedRecords.map((record) => `${record.filePath}:${record.symbol}`),
-      callers: dedupedCallers.map((entry) => `${entry.filePath}:${entry.symbol}`),
+      callers: dedupedCallerList.map((entry) => `${entry.filePath}:${entry.symbol}`),
       importers,
       relatedTests,
       mirrorCounterparts: mirrorCounterparts.map((entry) => `${entry.source} -> ${entry.filePath}`),
+      unverifiedImpact: unverifiedList,
     },
   };
 }
 
+async function pathExists(rootDir, relativePath) {
+  try {
+    await fs.access(path.join(rootDir, relativePath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function filterExistingPaths(rootDir, values = []) {
+  const checks = await Promise.all(values.map(async (value) => ({ value, exists: await pathExists(rootDir, value) })));
+  return checks.filter((check) => check.exists).map((check) => check.value);
+}
+
+async function filterExistingCallers(rootDir, callers = []) {
+  const checks = await Promise.all(callers.map(async (entry) => ({ entry, exists: await pathExists(rootDir, entry.filePath) })));
+  return checks.filter((check) => check.exists).map((check) => check.entry);
+}
+
 export function formatImpactConfidenceSummary(impact = {}) {
   const lines = ['Impact checked:'];
 
@@ -254,6 +329,11 @@ export function formatImpactConfidenceSummary(impact = {}) {
     lines.push(`- Mirrors: ${mirrors.join(', ')}`);
   }
 
+  const unverified = (impact.unverifiedImpact ?? []).slice(0, 3);
+  if (unverified.length > 0) {
+    lines.push(`- Unverified impact (name-only): ${unverified.join(', ')}`);
+  }
+
   const relatedTests = (impact.relatedTests ?? []).slice(0, 4);
   if (relatedTests.length > 0) {
     lines.push(`- Related tests: ${relatedTests.join(', ')}`);

package/src/index/languageTools.js

@@ -125,3 +125,129 @@ function foldTextForSearch(value) {
     .replace(/\p{M}+/gu, '')
     .toLowerCase();
 }
+
+// ── Fuzzy identifier resolution ──
+// Shared by resolveSymbolCandidates (queryIndex.js) and scoreDirectFileMatch's
+// symbol_fuzzy tier: camelCase/snake_case/kebab-case identifiers normalize to
+// the same folded token sequence, ordered subsequences bridge compacted queries
+// ('checknull' ⊂ check_if_is_null), and a bounded Damerau distance catches
+// misspellings ('custmer_code' → 'customer_code').
+
+export function normalizeIdentifierTokens(value) {
+  return tokenizeFoldedText(foldTextForSearch(addCamelBoundaries(value)));
+}
+
+// Query variants for phrase-level matching: the folded text as-is, then the
+// Vietnamese phrase aliases rewritten in place ('kiem tra null' → 'check null'),
+// then token-level aliases. Each variant is an ordered, deduped token list.
+export function expandIdentifierQueryVariants(value) {
+  const folded = foldTextForSearch(value);
+  const variants = [tokenizeFoldedText(folded)];
+
+  for (const entry of VIETNAMESE_PHRASE_ALIASES) {
+    entry.regex.lastIndex = 0;
+    if (!entry.regex.test(folded)) {
+      continue;
+    }
+    for (const expansion of entry.expansions) {
+      entry.regex.lastIndex = 0;
+      variants.push(tokenizeFoldedText(folded.replace(entry.regex, expansion)));
+    }
+  }
+
+  variants.push(variants[0].map((token) => VIETNAMESE_TOKEN_ALIASES.get(token)?.[0] ?? token));
+
+  const seen = new Set();
+  return variants
+    .map((tokens) => [...new Set(tokens)])
+    .filter((tokens) => tokens.length > 0)
+    .filter((tokens) => {
+      const key = tokens.join('\u0000');
+      if (seen.has(key)) {
+        return false;
+      }
+      seen.add(key);
+      return true;
+    })
+    .slice(0, 8);
+}
+
+// `queryTokens` fits inside `symbolTokens` in order ('check null' ⊆ check,if,null).
+export function isOrderedTokenSubsequence(queryTokens, symbolTokens) {
+  if (queryTokens.length === 0 || queryTokens.length > symbolTokens.length) {
+    return false;
+  }
+  let cursor = 0;
+  for (const token of symbolTokens) {
+    if (token === queryTokens[cursor]) {
+      cursor += 1;
+      if (cursor === queryTokens.length) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Character-level ordered containment on compacted forms ('checknull' ⊂ 'checkifnull').
+export function isCompactCharSubsequence(queryCompact, symbolCompact) {
+  if (!queryCompact || queryCompact.length > symbolCompact.length) {
+    return false;
+  }
+  let cursor = 0;
+  for (const char of symbolCompact) {
+    if (char === queryCompact[cursor]) {
+      cursor += 1;
+      if (cursor === queryCompact.length) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Damerau-Levenshtein (with transpositions), bounded: anything farther than
+// `maxDistance` short-circuits to maxDistance + 1 so callers can treat the
+// result as "beyond threshold" without walking the full matrix.
+export function boundedDamerauDistance(a, b, maxDistance = 2) {
+  const left = String(a ?? '');
+  const right = String(b ?? '');
+  if (left === right) {
+    return 0;
+  }
+  if (Math.abs(left.length - right.length) > maxDistance) {
+    return maxDistance + 1;
+  }
+
+  let prevPrev = null;
+  let prev = Array.from({ length: right.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= left.length; i += 1) {
+    const current = [i];
+    let rowMin = i;
+    for (let j = 1; j <= right.length; j += 1) {
+      const substitutionCost = left[i - 1] === right[j - 1] ? 0 : 1;
+      let value = Math.min(
+        prev[j] + 1,
+        current[j - 1] + 1,
+        prev[j - 1] + substitutionCost,
+      );
+      if (i > 1 && j > 1 && left[i - 1] === right[j - 2] && left[i - 2] === right[j - 1]) {
+        value = Math.min(value, prevPrev[j - 2] + 1);
+      }
+      current[j] = value;
+      if (value < rowMin) {
+        rowMin = value;
+      }
+    }
+    if (rowMin > maxDistance) {
+      return maxDistance + 1;
+    }
+    prevPrev = prev;
+    prev = current;
+  }
+  return prev[right.length];
+}
+
+// Minimum length both compacts must reach before edit-distance fuzzy matching
+// applies — short identifiers (< 6) produce too many false neighbors.
+export const FUZZY_EDIT_DISTANCE_MIN_LENGTH = 6;

package/src/index/paths.js

@@ -15,7 +15,11 @@ export const INDEX_ARTIFACTS = {
   codegraph: 'codegraph.json',
 };
 
-export const INDEX_SCHEMA_VERSION = 8;
+// v9: symbols.json gains global-registered ('global') and Vue 'method' rows,
+// SQL 'column' rows with parent/schema, and calls.json gains per-object SQL
+// reference records — a v8 cached artifact must not be reused for unchanged
+// files or the new extractions silently vanish.
+export const INDEX_SCHEMA_VERSION = 9;
 
 export function getIndexDir(rootDir) {
   return path.join(rootDir, '.cache', 'index');

package/src/index/playbookRegistry.js

@@ -22,6 +22,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { isRunAllRequest } from '../../template_project/.claude/ukit/runtime/handoff-intent.mjs';
 import { deriveEscalationTriggers, deriveRiskFloor } from './routeResolver.js';
 
 const PLAYBOOK_NAME_RE = /\.md$/i;
@@ -48,7 +49,10 @@ export const PLAYBOOK_ID_ALIASES = Object.freeze({
 // Compiled once; every row's discriminator reads the same normalized signals so
 // confusable pairs split on the discriminator column, never trigger text.
 const CREATE_VERB_RE = /\b(create|add|write|build|implement|scaffold|tạo|thêm)\b/i;
-const CHANGE_VERB_RE = /\b(fix|update|modify|change|rename|refactor|restructure|remove|delete|move|migrate|improve|patch|rework|sửa|đổi|cập nhật|thay thế|xóa)\b/i;
+// Vietnamese words never match `\b` (JS word chars are ASCII-only — 'sửa' ends
+// in a non-word char, 'đổi' starts with one), so the diacritic alternates use
+// explicit lookarounds instead. Same word list as the original literal.
+const CHANGE_VERB_RE = /(?:\b(?:fix|update|modify|change|rename|refactor|restructure|remove|delete|move|migrate|improve|patch|rework)\b|(?<![A-Za-z0-9_])(?:sửa|sua|đổi|doi|cập\s+nhật|cap\s+nhat|thay\s+thế|thay\s+the|thay|chỉnh(?:\s+sửa|\s+sua)?|chinh(?:\s+sua)?|xóa|xoa)(?![A-Za-z0-9_]))/i;
 const INVESTIGATION_TRIGGER_RE = /\b(how does|how do|why does|why do|why is|why are|explain|what happens|investigate|understand how|validate the assumption|tại sao|như thế nào|thế nào)\b/i;
 const DEFECT_TRIGGER_RE = /\b(fix|bug|defect|broken|crash(?:es|ed)?|regression|not working|doesn['’]?t work|won['’]?t work|fails?|failing|không hoạt động|lỗi)\b/i;
 const CHECK_VERB_RE = /\b(verify|check|confirm|prove|validate|assert)\b/i;
@@ -77,6 +81,68 @@ const AUTONOMOUS_TRIGGER_RE = /\b(finish (?:this|the) backlog|bounded (?:long )?
 const RELEASE_TRIGGER_RE = /\b(publish|ship it|release|bump (?:the )?version|deploy|cut a release|tag (?:the )?release)\b/i;
 const HANDOFF_CYCLE_TRIGGER_RE = /\b(handoff|multi[- ]?task cycle|task pipeline|execute the plan|worktree)\b/i;
 
+// --- Routing-orchestration signals (reference/clone/SQL/reuse/run-all) -------
+// Shared vocabulary for the discriminators below AND for the additive route
+// summary fields route-task.mjs emits (referenceTargets/cloneIntent/sqlIntent/
+// reuseFirst/goalScope). Kept here so both router surfaces read one definition.
+// Reference-based ask: "like the Customer page", "làm giống trang Customer",
+// "same as module Y", "using validation from Z" — resolve the named source.
+const REFERENCE_TARGET_RE = /(?:\b(?:like|same\s+as|similar\s+to|based\s+on|modell?ed\s+(?:on|after))\s+(?:the\s+|this\s+|that\s+|our\s+)?(?:existing\s+)?(?:[\w-]{1,32}\s){0,2}(?:page|screen|module|component|view|flow|dropdown|select|form|report)\b)|\b(?:page|screen|module|component|view|flow)\b[^\n?]{0,32}\b(?:like|same\s+as)\b|(?<![A-Za-z0-9_])(?:giống|giong|tương\s+tự|tuong\s+tu|như)\s+(?:cái\s+)?(?:trang|page|module|component|tính\s+năng|tinh\s+nang|man\s+hình|view)|(?<![A-Za-z0-9_])(?:trang|page|module|component|man\s+hình)\s+(?:giống|giong|tương\s+tự|tuong\s+tu)|\b(?:using|reuse(?:d)?)\s+(?:the\s+)?(?:validation|logic|pattern|structure|style)\b[^\n?]{0,32}\bfrom\b/i;
+// Clone ask: duplicate a named surface ("clone the Customer page", "nhân bản
+// trang này", "copy the login screen"). A bare "clone the repo" (git) and a
+// bare "copy" without a surface noun stay unmatched.
+const CLONE_INTENT_RE = /(?:\b(?:clone|duplicate|copy)\s+(?:the\s+|this\s+|that\s+|our\s+|my\s+)?(?:existing\s+)?[\w-]{0,32}\s?(?:page|screen|module|component|feature|view|flow|form)\b)|(?<![A-Za-z0-9_])(?:nhân\s+bản|nhan\s+ban|sao\s+chép|sao\s+chep)(?![A-Za-z0-9_])/i;
+// SQL-work ask: the prompt lives in the database layer (a .sql file, a view,
+// column, table, stored function). Vietnamese table words break \b, hence the
+// lookarounds.
+const SQL_INTENT_RE = /(?:\.sql\b)|(?<![A-Za-z0-9_])(?:view|column|table|schema|cột|bảng|cot|bang|stored\s+(?:procedure|function))(?![A-Za-z0-9_])/i;
+// Bare UI-ambiguous words (view/column/table/schema/cột/bảng) only count as SQL work
+// next to SQL context: a DB word, a DDL phrase, a snake_case identifier, or a .sql file.
+// "View the logs" / "a column of buttons" stay ordinary UI language.
+const SQL_STRONG_RE = /(?:\.sql\b)|stored\s+(?:procedure|function)|\b(?:sql|ddl|dml|plpgsql|postgres(?:ql)?|mysql|sqlite)\b|\b(?:create|alter|drop|truncate)\s+(?:or\s+replace\s+)?(?:(?:a|an|the|new)\s+)?(?:\w+\s+)?(?:table|view|schema|function|procedure)\b/i;
+const SQL_WEAK_RE = /(?<![A-Za-z0-9_])(?:view|column|table|schema|cột|bảng|cot|bang)(?![A-Za-z0-9_])/gi;
+const SQL_IDENT_RE = /\b[a-z]+(?:_[a-z0-9]+){1,}\b/;
+function hasSqlIntent(text) {
+  const t = String(text ?? '');
+  if (SQL_STRONG_RE.test(t)) return true;
+  const weak = new Set((t.match(SQL_WEAK_RE) || []).map((w) => w.toLowerCase()));
+  if (weak.size === 0 || /\bcolumn\s+of\b/i.test(t)) return false;
+  // A column+table pair, or a bare DB word beside a snake_case identifier, is schema work.
+  const pair = (weak.has('column') || weak.has('cột') || weak.has('cot')) && (weak.has('table') || weak.has('bảng') || weak.has('bang'));
+  return pair || SQL_IDENT_RE.test(t);
+}
+// The SQL ask touches shape/data rather than a read-only query — routes the
+// migration row instead of a feature build.
+const SQL_SCHEMA_RE = /(?<![A-Za-z0-9_])(?:ddl|alter|drop|(?:create|alter|drop|truncate)\s+table|(?:add|drop|rename|change|modify|update|thêm|xóa|xoá|sửa|sua|đổi|doi)\s+(?:a\s+|the\s+|new\s+|một\s+)*(?:column|cột|cot)(?!\s+of\b)|kiểu\s+dữ\s+liệu|kieu\s+du\s+lieu|data\s?type|not\s+null|constraint|migration|migrate)(?![A-Za-z0-9_])/i;
+// Reuse-first ask: "use the existing/core function", "dùng hàm có sẵn",
+// "tái sử dụng" — search for the function before writing a new one.
+const REUSE_FIRST_RE = /(?:\buse\s+(?:the\s+)?(?:existing|core|shared|same|current)\b)|(?:\buse\s+[\w.]+\s+from\s+(?:the\s+)?(?:core|shared|utils?|common|lib)\b)|\b(?:existing|core|shared)\s+(?:function|helper|util(?:ity|ities)?|service|component)\b|\breuse\b|(?<![A-Za-z0-9_])(?:tái\s+sử\s+dụng|tai\s+su\s+dung)|(?<![A-Za-z0-9_])(?:dùng|dung|dựa|dua)\s+(?:vào\s+|vao\s+)?(?:hàm|ham)(?:\s+(?:có\s+sẵn|co\s+san|sẵn\s+có|san\s+co|đã\s+có|da\s+co|cũ|cu))?(?![A-Za-z0-9_])/i;
+// Run-all goal scope: the prompt queues the WHOLE remaining backlog, never a
+// single named task (single-task refs veto below). A scope signal only — it
+// must never set mutation permission by itself.
+
+// One bounded derivation for the route summary signals. Pure — no I/O. Both
+// router surfaces call this; the discriminators above read the same booleans
+// through buildRouteSignals so the route fields and playbook row selection
+// cannot diverge.
+export function deriveRouteOrchestrationSignals({ promptText = '', commandText = '' } = {}) {
+  const signalText = [promptText, commandText]
+    .map((value) => String(value || '').trim().toLowerCase())
+    .filter(Boolean)
+    .join('\n');
+  if (!signalText) {
+    return { referenceTarget: false, cloneIntent: false, sqlIntent: false, sqlSchemaChange: false, reuseFirst: false, runAll: false };
+  }
+  return {
+    referenceTarget: REFERENCE_TARGET_RE.test(signalText),
+    cloneIntent: CLONE_INTENT_RE.test(signalText),
+    sqlIntent: hasSqlIntent(signalText),
+    sqlSchemaChange: hasSqlIntent(signalText) && SQL_SCHEMA_RE.test(signalText),
+    reuseFirst: REUSE_FIRST_RE.test(signalText),
+    runAll: isRunAllRequest(signalText),
+  };
+}
+
 // session-pickup discriminator needs the resumable-record check. ASYNC scan
 // (W3-PB2): the resolve path runs inside hook processes where a sync
 // readdirSync parks the event loop and can starve the hook self-deadline.
@@ -105,18 +171,32 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     // confusable pair 1: no escalation trigger AND single-surface scope. The
     // `!s.escalated` clause is the BL-010 fast-path guard — any derived
     // floor-raising trigger (the six listed triggers map to risk codes +
-    // contract signals) escalates to feature-implementation.
-    discriminator: (s) => !s.escalated && !s.contractSignal && !s.multiSurface && s.changeVerbOrCreate,
+    // contract signals) escalates to feature-implementation. Reference-driven,
+    // clone, reuse-first and SQL-schema asks take the same escape: they name a
+    // source of truth or a data contract the small path must not gloss over.
+    discriminator: (s) => !s.escalated && !s.contractSignal && !s.multiSurface && !s.sqlSchemaChange && !s.referenceTarget && !s.cloneIntent && !s.reuseFirst && s.changeVerbOrCreate,
     fastPath: 'small-feature',
   },
   {
     workGroup: 'feature-implementation',
     playbookId: 'feature-implementation',
     lanes: ['local-build', 'shared-edit', 'map-impact'],
-    triggers: [/implement|add|create|build|integrat|ship|deliver|wir(?:e|ed|ing)/i],
-    // confusable pairs 1/5/8: articulated contract OR ≥1 escalation trigger,
-    // and the ask is not a disposable spike nor the ship chain itself.
-    discriminator: (s) => (s.contractSignal || s.multiSurface || s.escalated || s.wiredShipAsk) && !s.disposable && !s.releaseAsk,
+    triggers: [
+      /implement|add|create|build|integrat|ship|deliver|wir(?:e|ed|ing)/i,
+      REFERENCE_TARGET_RE,
+      CLONE_INTENT_RE,
+      REUSE_FIRST_RE,
+    ],
+    // confusable pairs 1/5/8: articulated contract OR ≥1 escalation trigger OR
+    // a reference/clone/reuse-driven ask — and the ask is not a disposable
+    // spike nor the ship chain itself. The reference/clone/reuse clauses only
+    // claim when no defect verb leads the ask ("fix login like signup" stays
+    // bug-fix); an escalation raised by SQL schema work yields to the
+    // migration row instead of capturing the build lane.
+    discriminator: (s) => (
+      (s.contractSignal || s.multiSurface || (s.escalated && !s.sqlSchemaChange) || s.wiredShipAsk)
+      || ((s.referenceTarget || s.cloneIntent || s.reuseFirst) && s.defectIdx === -1)
+    ) && !s.disposable && !s.releaseAsk,
   },
   {
     workGroup: 'bug-fix',
@@ -191,9 +271,19 @@ export const PLAYBOOK_ROUTING_TABLE = Object.freeze([
     workGroup: 'migration',
     playbookId: 'migration',
     lanes: ['shared-edit', 'map-impact'],
-    triggers: [/migrat|move (?:the |this |all )?[\w-]*|new schema|port (?:the|to)/i],
+    triggers: [
+      /migrat|move (?:the |this |all )?[\w-]*|new schema|port (?:the|to)/i,
+      // SQL schema work pairs a change verb with a shape noun even without a
+      // "migrate" verb — "sửa cột so_created_date trong view", "alter the
+      // users table". A bare noun ("fix the users table") is not enough —
+      // defect-led asks stay bug-fix.
+      /(?:\b(?:alter|drop|add|remove|rename|modify|change|resize)\b[^\n]{0,24}?\b(?:column|table)s?\b)|(?<![A-Za-z0-9_])(?:sửa|sua|đổi|doi|thay|chỉnh|chinh|thêm|them|xóa|xoa|cập\s+nhật|cap\s+nhat)\s+(?:cột|bảng|cot|bang)/i,
+    ],
     // confusable pair 7: behavior change + data/contract move (rollback needed).
-    discriminator: (s) => s.dataMove,
+    // A SQL ask that touches shape (column/table/schema vocabulary) is the same
+    // class even without an explicit move verb — unless a defect verb leads the
+    // ask ("fix the users table" stays bug-fix).
+    discriminator: (s) => s.dataMove || (s.sqlIntent && s.sqlSchemaChange && s.defectIdx === -1),
   },
   {
     workGroup: 'verification',
@@ -333,6 +423,10 @@ async function buildRouteSignals({
     || /(?:chưa|chua|được không|duoc khong|đúng không|dung khong|không nhỉ|khong nhi|thế nào|the nao|như thế nào|nhu the nao|tại sao|tai sao|là gì|la gi|bao giờ|bao gio|khi nào|khi nao|ở đâu|o dau|không biết|khong biet)/.test(signalText)
     || /(?:chưa|chua|đúng không|dung khong|không|khong)\s*[?.!]?\s*$/.test(signalText);
   const questionAsk = questionShaped && !changeRequested;
+  const referenceTarget = REFERENCE_TARGET_RE.test(signalText);
+  const cloneIntent = CLONE_INTENT_RE.test(signalText);
+  const sqlIntent = hasSqlIntent(signalText);
+  const reuseFirst = REUSE_FIRST_RE.test(signalText);
   return {
     signalText,
     executionMode,
@@ -347,6 +441,11 @@ async function buildRouteSignals({
     questionAsk,
     checkFirst,
     changeVerbOrCreate: changeIdx !== -1 || createIdx !== -1,
+    referenceTarget,
+    cloneIntent,
+    sqlIntent,
+    sqlSchemaChange: sqlIntent && SQL_SCHEMA_RE.test(signalText),
+    reuseFirst,
     contractSignal: CONTRACT_SIGNAL_RE.test(signalText) || /\boauth\b/i.test(signalText),
     multiSurface: MULTI_SURFACE_RE.test(signalText),
     escalated: Array.isArray(escalationTriggers) && escalationTriggers.length > 0,