@ngockhoale/ukit 3.4.29 → 3.4.30

package/CHANGELOG.md

@@ -9,6 +9,22 @@ All notable changes to UKit are documented here.
 - New `/ukit:ci-check` command + `ci-check.mjs` helper (core pack): prechecks, fail-closed budget guard, local preflight, at most one dispatch per invocation, write-ahead run-id state, `status` (never dispatches), `--ref`, `--dry-run`, per-OS report. Never pushes, merges or publishes.
 - Default-branch bootstrap stub documented in `docs/design/CI-CROSS-PLATFORM-MATRIX.md` (requires separate approval).
 
+## 3.4.30 - 2026-10-10
+
+**Orchestration: routing, goal/cycle continuation, task ownership, discovery, landing.** Verified with `yarn test:handoff` (184/184) and `yarn release:verify`; live Claude Code two-cycle run-all and the Claude create-only permission denial were exercised on disposable fixtures. Known limits: OMP permission denial is verified through the hook bridge only, and Codex has no pre-tool hook for ownership enforcement. No performance gain is claimed beyond removing the identified redundant Stop-denial / archive-repair round.
+- **Stop-gate evidence capture (P0).** `isVerificationCommand`/`TEST_RUNNER_COMMAND` now accept subshell/group openers, so `(yarn test; echo "exit $?" >> log)` mints a receipt (it previously minted none → endless `missing verification-evidence`). `verdictHistory` retention never evicts the last satisfying PASS; a pipe-masked run is reported as "exit status unproven" instead of "fix the failure". Pipe-masked status is still rejected. Tests: `tests/hooks/stopGateReceiptCapture.test.js`.
+- **F3 ↔ ExitPredicate.** `index:all-done` on a header-only INDEX now reads `archive/cycle-NN/TASK-*.md`; `run-all` additionally requires no pending queued blueprints. Finalizing a cycle never implies run-all completion. Test: `tests/handoff/f3FinalizationPredicate.test.mjs`.
+- **Archive/Goal completion invariant.** F3 now runs `resumable-run.mjs archive-cycle <root> <NN>` before the INDEX reset: the verified INDEX rows are persisted to `archive/cycle-NN/INDEX.md` and terminal statuses stamped into archived task headers; `index:all-done` reads that snapshot (header only for legacy archives, missing row fails closed, rows immutable per cycle). Removes the stale-`ready` repair round. Receipt detection ignores quoted literals and sees `bash -c '<runner>'`. Tests: `archiveCompletionInvariant.test.mjs` (AR-01…15).
+- **Main-agent task ownership.** During implement phases the main agent must hold a claim (`main:<session>` owner) via the existing registry; new CLI `resumable-run.mjs claim|release <root> <TASK-ID> --owner <owner>`.
+- **Routing.** Deterministic greeting fast-path; Vietnamese edit verbs; REFERENCE / CLONE / SQL / REUSE / RUN-ALL signals stamped in the route summary; negated and plan-only prompts never imply implementation; "run all the tests" is a test run, "chạy hết pending tasks" is goal-level run-all; "use <symbol> from Core" stamps reuse-first. Explicit handoff commands keep authority over inferred intent.
+- **Goal vs cycle.** `deriveGoalStatus`; default exit predicate `all(index:all-done)`; quota pause marks `Paused: yes` (structured error records only); a finalized cycle (done cursor + header-only INDEX) releases once.
+- **Task ownership.** Per-task claims with task identity, lease renewal, owner fencing and takeover; wired through the Claude Code and OMP delegation hooks; per-session route-state sidecars fix a cross-session collision. The main agent takes part in the same registry (see above).
+- **Discovery.** Index schema 9: fuzzy symbol candidates (never auto-substituted), global and SQL symbols, caller proof with `unverifiedImpact`, bounded fallback search that reports truncation instead of posing as exhaustive.
+- **Reuse/reference/clone/SQL advisory.** `skill-router.sh` now emits one short source-resolution line for reuse-first, reference/clone and SQL prompts (including the previously silent no-route exit): resolve the named symbol with `query-index.mjs --symbol`, never invent a module, leave the reference untouched, alias vs real column. Found by a live OMP run that invented `import … from 'Core'`. `REFERENCE_TARGET_RE` also accepts "like the reviewed Customer dropdown".
+- **`handoff-fullstack` F3.** Archive step now snapshots verified INDEX rows (`archive-cycle`) so a finished cycle never needs a post-`done` repair round; the final verification for `verify:pass` runs in-session (the receipt is per-session).
+- **Playbook observability.** `ledger.playbookTrace`, `--playbook-status`.
+- **Fixes.** `land-worktree` / `cleanup-task-worktree` accepted only `TASK-C97-NNN`, so every ordinary handoff task (`TASK-001`) was blocked at landing; they now accept `TASK-NNN` and `TASK-<cycle>-NNN` (still no separators or whitespace). `block-dangerous` no longer blocks a quoted-delimiter heredoc whose body merely documents a dangerous command; real commands, unquoted heredocs and heredocs piped to a shell stay denied. `handoff-fullstack` P3 no longer blocks the run when the lite commit agent has no shell. `handoff-create` headless rule.
+
 ## 3.4.29 - 2026-10-09
 
 **Fixes (no new features).**

package/manifests/documentation.yaml

@@ -418,6 +418,94 @@ entries:
     validation: [none]
     archive_policy: immutable
     notes: C99 measurement-only sub-agent cost audit snapshot; registered in 3.4.25 (was unclassified on 3.4.24)
+  - id: docs-analysis-handoff-root-cause-audit
+    path: docs/analysis/HANDOFF-ROOT-CAUSE-AUDIT.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/HANDOFF-ROOT-CAUSE-AUDIT.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-09 handoff root-cause audit (create-scope authority + Stop verification semantics)
+  - id: docs-analysis-handoff-remediation-plan
+    path: docs/analysis/HANDOFF-REMEDIATION-PLAN.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/HANDOFF-REMEDIATION-PLAN.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-09 handoff remediation plan (create-scope authority + Stop verification semantics)
+  - id: docs-analysis-handoff-regression-test-plan
+    path: docs/analysis/HANDOFF-REGRESSION-TEST-PLAN.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/HANDOFF-REGRESSION-TEST-PLAN.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-09 handoff regression test plan (create-scope authority + Stop verification semantics)
+  - id: docs-analysis-orchestration-root-cause-audit
+    path: docs/analysis/ORCHESTRATION-ROOT-CAUSE-AUDIT.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/ORCHESTRATION-ROOT-CAUSE-AUDIT.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-10 orchestration root-cause audit (routing, playbooks, discovery, goal cycles)
+  - id: docs-analysis-orchestration-spec
+    path: docs/analysis/ORCHESTRATION-SPEC.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/ORCHESTRATION-SPEC.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-10 orchestration behavior spec
+  - id: docs-analysis-orchestration-implementation-plan
+    path: docs/analysis/ORCHESTRATION-IMPLEMENTATION-PLAN.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/ORCHESTRATION-IMPLEMENTATION-PLAN.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-10 orchestration implementation plan
+  - id: docs-analysis-orchestration-regression-tests
+    path: docs/analysis/ORCHESTRATION-REGRESSION-TESTS.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/ORCHESTRATION-REGRESSION-TESTS.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-10 orchestration regression test inventory
+  - id: docs-analysis-orchestration-final-verification
+    path: docs/analysis/ORCHESTRATION-FINAL-VERIFICATION.md
+    class: archive
+    audience: [maintainer]
+    owner: product
+    source_of_truth: docs/analysis/ORCHESTRATION-FINAL-VERIFICATION.md
+    merge_strategy: none
+    load_policy: never
+    validation: [none]
+    archive_policy: immutable
+    notes: 2026-10-10 orchestration final verification and release readiness
   - id: docs-analysis-c100-frag-a-d
     path: docs/analysis/c100/frag-A-D.md
     class: archive

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.4.29",
+  "version": "3.4.30",
   "description": "Install/update an index-first AI workspace for Claude Code, OpenAI Codex and omp (Oh My Pi).",
   "license": "MIT",
   "type": "module",

package/src/core/permissionPolicy.js

@@ -36,7 +36,7 @@ export const CANONICAL_DENY = Object.freeze([
   { id: 'rm-rf-parent', claude: 'Bash(rm -rf ..:*)', omp: 'rm -rf ..', codex: 'rm -rf ..', hardDeny: true },
   { id: 'rm-rf-dot', claude: 'Bash(rm -rf .:*)', omp: 'rm -rf .', codex: 'rm -rf .', hardDeny: true },
   { id: 'dd-raw-device', claude: 'Bash(dd if=/dev/:*)', omp: 'dd if=/dev/*', codex: 'dd if=/dev/', hardDeny: true },
-  { id: 'write-raw-device', claude: 'Bash(*> /dev/sda:*)', omp: '*> /dev/sda*', codex: '> /dev/sda', hardDeny: true },
+  { id: 'write-raw-device', claude: 'Bash(*> /dev/sda*)', omp: '*> /dev/sda*', codex: '> /dev/sda', hardDeny: true },
   { id: 'mkfs', claude: 'Bash(mkfs:*)', omp: 'mkfs.*', codex: 'mkfs', hardDeny: true },
   { id: 'fork-bomb', claude: 'Bash(:(){ :|:& };::*)', omp: ':(){ :|:& };:*', codex: ':(){ :|:& };:', hardDeny: true },
 ]);

package/src/index/buildIndex.js

@@ -1681,7 +1681,7 @@ function computeSignature(content, lineStartIndex) {
 export function extractSymbols(filePath, content) {
   const symbols = [];
   const lineStarts = computeLineStarts(content);
-  const addSymbol = (name, type, matchIndex = null) => {
+  const addSymbol = (name, type, matchIndex = null, extra = null) => {
     if (!name) {
       return;
     }
@@ -1691,7 +1691,7 @@ export function extractSymbols(filePath, content) {
     }
     const line = lineNumberForIndex(lineStarts, matchIndex);
     const signature = computeSignature(content, lineStarts[line - 1]);
-    symbols.push({ name, type, filePath, line, signature });
+    symbols.push(extra ? { name, type, filePath, line, signature, ...extra } : { name, type, filePath, line, signature });
   };
   const addMatches = (regex, type, groupIndex = 1) => {
     for (const match of content.matchAll(regex)) {
@@ -1713,7 +1713,26 @@ export function extractSymbols(filePath, content) {
     addMatches(new RegExp(`CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'index');
     addMatches(new RegExp(`CREATE\\s+(?:TYPE|DOMAIN|SEQUENCE|MATERIALIZED\\s+VIEW)\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'type');
     addMatches(new RegExp(`ALTER\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?${sqlIdent}`, 'gi'), 'table');
-    return dedupeBy(symbols, (item) => `${item.filePath}:${item.type}:${item.name}`);
+
+    // Column-level symbols: CREATE TABLE bodies (with parent + schema kept so
+    // same-named columns in different schemas/tables stay distinct) and view
+    // output aliases (`expr AS alias`).
+    const sqlObjects = findSqlObjects(content);
+    for (const [objectIndex, sqlObject] of sqlObjects.entries()) {
+      if (sqlObject.type === 'table') {
+        for (const column of extractSqlTableColumns(content, sqlObject)) {
+          addSymbol(column.name, 'column', column.matchIndex, { parent: sqlObject.name, schema: sqlObject.schema });
+        }
+      }
+      if (sqlObject.type === 'view') {
+        const bodyEnd = objectIndex + 1 < sqlObjects.length ? sqlObjects[objectIndex + 1].matchIndex : content.length;
+        for (const alias of extractSqlViewAliases(content.slice(sqlObject.matchIndex, Math.min(bodyEnd, sqlObject.matchIndex + 20000)))) {
+          addSymbol(alias.name, 'column', sqlObject.matchIndex + alias.matchIndex, { parent: sqlObject.name, schema: sqlObject.schema });
+        }
+      }
+    }
+
+    return dedupeBy(symbols, (item) => `${item.filePath}:${item.type}:${item.name}:${item.parent ?? ''}:${item.schema ?? ''}`);
   }
 
   addMatches(/export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g, 'function');
@@ -1727,6 +1746,32 @@ export function extractSymbols(filePath, content) {
   addMatches(/defineComponent\(\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
   addMatches(/export\s+default\s*\{[\s\S]*?name\s*:\s*['"]([^'"]+)['"]/g, 'component-name');
 
+  // Global-registered frontend functions: reachable from anywhere without an
+  // import edge, so impact analysis must treat them as verified dependencies.
+  addMatches(/\b(?:window|globalThis|global)\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*=/g, 'global');
+  addMatches(/\b(?:window|globalThis|global)\s*\[\s*['"]([^'"]+)['"]\s*\]\s*=/g, 'global');
+  addMatches(/\b(?:app|vueApp)\s*\.\s*config\s*\.\s*globalProperties\s*\.\s*(\$?[A-Za-z_$][A-Za-z0-9_$]*)\s*=/g, 'global');
+  addMatches(/\bVue\s*\.\s*prototype\s*\.\s*(\$?[A-Za-z_$][A-Za-z0-9_$]*)\s*=/g, 'global');
+  addMatches(/\b(?:app|vueApp)\s*\.\s*provide\s*\(\s*['"]([^'"]+)['"]/g, 'global');
+  addMatches(/\b(?:Vue|app|vueApp)\s*\.\s*component\s*\(\s*['"]([^'"]+)['"]/g, 'global');
+
+  // Vue options-API methods: `methods: { submit() {...}, validate: () => ... }`.
+  // Names inside the balanced `methods` block only — body-level matches keep
+  // their real file line through the absolute-index offset.
+  for (const methodsMatch of content.matchAll(/\bmethods\s*:\s*\{/g)) {
+    const methodsBody = sliceBalancedBlock(content, methodsMatch.index + methodsMatch[0].length);
+    if (!methodsBody) {
+      continue;
+    }
+    const methodsStart = methodsMatch.index + methodsMatch[0].length;
+    for (const methodMatch of methodsBody.matchAll(/(?:^|[,{\n]\s*)([A-Za-z_$][A-Za-z0-9_$]*)\s*\((?:[^()]|\([^)]*\))*\)\s*\{/g)) {
+      addSymbol(methodMatch[1], 'method', methodsStart + methodMatch.index + methodMatch[0].indexOf(methodMatch[1]));
+    }
+    for (const methodMatch of methodsBody.matchAll(/(?:^|[,{]\s*)([A-Za-z_$][A-Za-z0-9_$]*)\s*:\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][A-Za-z0-9_$]*\s*=>)/g)) {
+      addSymbol(methodMatch[1], 'method', methodsStart + methodMatch.index + methodMatch[0].indexOf(methodMatch[1]));
+    }
+  }
+
   if (/\bexport\s+default\b/.test(content)) {
     addSymbol('default', 'default-export');
   }
@@ -1743,7 +1788,120 @@ export function extractSymbols(filePath, content) {
     }
   }
 
-  return dedupeBy(symbols, (item) => `${item.filePath}:${item.type}:${item.name}`);
+  return dedupeBy(symbols, (item) => `${item.filePath}:${item.type}:${item.name}:${item.parent ?? ''}:${item.schema ?? ''}`);
+}
+
+// Locates every CREATE <object> statement with its schema qualifier (or null)
+// so same-named objects in different schemas stay distinct records. Used for
+// column extraction and SQL reference segmentation.
+function findSqlObjects(content) {
+  const sqlQualifiedIdent = '(?:(["`]?[A-Za-z_][A-Za-z0-9_$]*["`]?)\\s*\\.\\s*)?["`]?([A-Za-z_][A-Za-z0-9_$]*)["`]?';
+  const patterns = [
+    ['table', `CREATE\\s+(?:OR\\s+REPLACE\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlQualifiedIdent}`],
+    ['view', `CREATE\\s+(?:OR\\s+REPLACE\\s+)?VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlQualifiedIdent}`],
+    ['function', `CREATE\\s+(?:OR\\s+REPLACE\\s+)?FUNCTION\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlQualifiedIdent}`],
+    ['procedure', `CREATE\\s+(?:OR\\s+REPLACE\\s+)?PROCEDURE\\s+${sqlQualifiedIdent}`],
+    ['type', `CREATE\\s+(?:TYPE|DOMAIN|SEQUENCE)\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${sqlQualifiedIdent}`],
+  ];
+  const objects = [];
+  for (const [type, pattern] of patterns) {
+    for (const match of content.matchAll(new RegExp(pattern, 'gi'))) {
+      if (!match[2]) {
+        continue;
+      }
+      objects.push({
+        type,
+        name: match[2],
+        schema: match[1] ? match[1].replace(/["`]/g, '') : null,
+        matchIndex: match.index,
+      });
+    }
+  }
+  return objects.sort((a, b) => a.matchIndex - b.matchIndex);
+}
+
+const SQL_COLUMN_CONSTRAINT_KEYWORDS = new Set([
+  'primary', 'foreign', 'unique', 'check', 'constraint', 'key', 'index', 'exclude', 'like', 'period',
+]);
+
+// Slices a CREATE TABLE body's balanced paren list and emits one row per
+// top-level column definition (constraint rows are skipped).
+function extractSqlTableColumns(content, sqlObject) {
+  const headerPattern = new RegExp(
+    `CREATE\\s+(?:OR\\s+REPLACE\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:(?:["\`]?[A-Za-z_][A-Za-z0-9_$]*["\`]?)\\s*\\.\\s*)?["\`]?${escapeRegExp(sqlObject.name)}["\`]?`,
+    'gi',
+  );
+  headerPattern.lastIndex = sqlObject.matchIndex;
+  const headerMatch = headerPattern.exec(content);
+  if (!headerMatch) {
+    return [];
+  }
+  const openParenSearchEnd = Math.min(content.length, headerMatch.index + headerMatch[0].length + 500);
+  const openParen = content.slice(headerMatch.index + headerMatch[0].length - 1, openParenSearchEnd).indexOf('(');
+  if (openParen === -1) {
+    return [];
+  }
+  const openParenAbsolute = headerMatch.index + headerMatch[0].length - 1 + openParen;
+
+  let depth = 0;
+  let closeParen = -1;
+  for (let index = openParenAbsolute; index < content.length; index += 1) {
+    if (content[index] === '(') {
+      depth += 1;
+    } else if (content[index] === ')') {
+      depth -= 1;
+      if (depth === 0) {
+        closeParen = index;
+        break;
+      }
+    }
+  }
+  if (closeParen === -1) {
+    return [];
+  }
+
+  const body = content.slice(openParenAbsolute + 1, closeParen);
+  const columns = [];
+  let topLevelDepth = 0;
+  let segmentStart = 0;
+  const segments = [];
+  for (let index = 0; index < body.length; index += 1) {
+    const char = body[index];
+    if (char === '(') {
+      topLevelDepth += 1;
+    } else if (char === ')') {
+      topLevelDepth -= 1;
+    } else if (char === ',' && topLevelDepth === 0) {
+      segments.push(body.slice(segmentStart, index));
+      segmentStart = index + 1;
+    }
+  }
+  segments.push(body.slice(segmentStart));
+
+  let offset = openParenAbsolute + 1;
+  for (const segment of segments) {
+    const columnMatch = segment.match(/^\s*["`]?([A-Za-z_][A-Za-z0-9_$]*)["`]?/);
+    const columnName = columnMatch?.[1];
+    if (columnName && !SQL_COLUMN_CONSTRAINT_KEYWORDS.has(columnName.toLowerCase())) {
+      columns.push({ name: columnName, matchIndex: offset + columnMatch[0].indexOf(columnMatch[1]) });
+    }
+    offset += segment.length + 1;
+  }
+  return columns;
+}
+
+// Output aliases inside a CREATE VIEW body segment: `expr AS alias` where the
+// alias is followed by a column-list boundary.
+function extractSqlViewAliases(viewSegment) {
+  const aliases = [];
+  for (const match of viewSegment.matchAll(/\bAS\s+["`]?([A-Za-z_][A-Za-z0-9_$]*)["`]?\s*(?=\s*(?:,|FROM|WHERE|;|\n|$))/gi)) {
+    aliases.push({ name: match[1], matchIndex: match.index + match[0].indexOf(match[1]) });
+  }
+  return aliases;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 function extractImports(filePath, content) {
@@ -1912,7 +2070,89 @@ function sliceBalancedBlock(content, startIndex) {
   return '';
 }
 
+// SQL keywords that appear before `(` in procedural/plain SQL but are not
+// object references (SELECT count(, IF(, CAST(...) — plus common column type
+// names, since `VARCHAR(20)` in a table body is a type, not a call.
+const SQL_CALL_KEYWORDS = new Set([
+  'select', 'from', 'where', 'and', 'or', 'not', 'case', 'when', 'then', 'else',
+  'end', 'join', 'inner', 'left', 'right', 'outer', 'full', 'cross', 'on',
+  'group', 'order', 'by', 'having', 'limit', 'offset', 'union', 'all',
+  'distinct', 'as', 'insert', 'into', 'values', 'update', 'set', 'delete',
+  'create', 'table', 'view', 'function', 'procedure', 'index', 'alter', 'drop',
+  'if', 'exists', 'begin', 'commit', 'rollback', 'return', 'declare', 'exec',
+  'execute', 'call', 'with', 'cast', 'coalesce', 'nullif', 'extract', 'primary',
+  'foreign', 'references', 'key', 'constraint', 'default', 'unique', 'check',
+  'asc', 'desc', 'is', 'in', 'like', 'between', 'null', 'true', 'false',
+  'interval', 'date', 'using', 'natural', 'returns', 'language', 'temporary',
+  'varchar', 'char', 'nvarchar', 'nchar', 'int', 'integer', 'bigint', 'smallint',
+  'tinyint', 'text', 'boolean', 'bool', 'datetime', 'timestamp', 'timestamptz',
+  'decimal', 'numeric', 'float', 'double', 'real', 'json', 'jsonb', 'uuid',
+  'serial', 'bigserial', 'blob', 'bytea', 'bit', 'money', 'xml', 'enum',
+  'count', 'sum', 'avg', 'min', 'max', 'round', 'upper', 'lower', 'trim',
+  'length', 'concat', 'substring', 'replace', 'abs', 'ceil', 'floor', 'now',
+  'current_timestamp', 'current_date', 'year', 'month', 'day', 'hour', 'minute',
+  'second', 'convert', 'try_cast', 'iif', 'stuff', 'format', 'getdate',
+]);
+
+// SQL reference extraction: one calls-record per created object whose segment
+// (its statement through the next CREATE) lists the SQL objects it touches —
+// FROM/JOIN targets, EXEC targets, and `name(` function calls. This is the
+// dependency edge impact analysis uses to surface dependent views/functions.
+function extractSqlFunctionCalls(filePath, content) {
+  const objects = findSqlObjects(content);
+  if (objects.length === 0) {
+    return [];
+  }
+  const stripped = content
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/--[^\n]*/g, '');
+
+  const records = [];
+  for (const [objectIndex, sqlObject] of objects.entries()) {
+    const bodyEnd = objectIndex + 1 < objects.length ? objects[objectIndex + 1].matchIndex : content.length;
+    const segment = stripped.slice(sqlObject.matchIndex, Math.min(bodyEnd, sqlObject.matchIndex + 20000));
+
+    const calls = [];
+    const addCall = (rawName) => {
+      if (!rawName) {
+        return;
+      }
+      const bareName = rawName.split('.').pop().replace(/["`]/g, '');
+      if (!bareName || bareName.toLowerCase() === sqlObject.name.toLowerCase()) {
+        return;
+      }
+      if (SQL_CALL_KEYWORDS.has(bareName.toLowerCase())) {
+        return;
+      }
+      if (!calls.includes(bareName)) {
+        calls.push(bareName);
+      }
+    };
+
+    for (const match of segment.matchAll(/\b(?:FROM|JOIN)\s+["`]?([A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*["`]?[A-Za-z_][A-Za-z0-9_$]*)?)/gi)) {
+      addCall(match[1]);
+    }
+    for (const match of segment.matchAll(/\bEXEC(?:UTE)?\s+(?:@\w+\s*=\s*)?["`]?([A-Za-z_][A-Za-z0-9_$]*)/gi)) {
+      addCall(match[1]);
+    }
+    for (const match of segment.matchAll(/\b([A-Za-z_][A-Za-z0-9_$]*)\s*\(/g)) {
+      addCall(match[1]);
+    }
+
+    records.push({
+      filePath,
+      symbol: sqlObject.name,
+      exported: true,
+      calls,
+    });
+  }
+  return records;
+}
+
 function extractFunctionCalls(filePath, content) {
+  if (filePath.endsWith('.sql')) {
+    return extractSqlFunctionCalls(filePath, content);
+  }
   return extractFunctionBlocks(content).map((block) => {
     const calls = [];
     for (const match of block.body.matchAll(/(?:\b|\.)([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g)) {

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(', ')}`);