@ngockhoale/ukit 3.4.29 → 3.4.31

package/CHANGELOG.md

@@ -9,6 +9,35 @@ 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.31 - 2026-10-11
+
+**Completion Gate: task-aware operational completion (fixes the CronDelete/CronList false positive).** Verified with the full suite (`yarn test`, 566 files) plus focused six-scenario routing → recorder → Stop regressions.
+- **Task kinds.** CODE_IMPLEMENTATION / OPERATIONAL / READ_ONLY / CONFIGURATION / MIXED are classified independently of write activity. Implementation still requires a source write plus risk-based verification; mixed tasks keep both obligations.
+- **Operational evidence.** New bounded, tool-agnostic proof bank (`operation-evidence.mjs`) and strict native-result normalization (`cron-operation-adapter.mjs`): completion needs an accepted execution, matching target/scope, a fresh verified postcondition and active-task evidence. Unsupported result shapes fail closed.
+- **Task-instance isolation.** Each request gets its own task identity; identical repeated requests are distinct tasks, while continue/resume keeps identity. Evidence and journals from an earlier task cannot satisfy a new one.
+- **Receipt retention / replay protection.** Failed operations survive receipt eviction; native tool-use IDs are tracked (bounded, fail-closed on saturation) so an overwritten observation cannot replay as fresh proof.
+- **Claude Code / OMP.** The Claude recorder and settings matchers cover `CronDelete`/`CronList` success and failure events; the OMP bridge normalizes `cron_delete`/`cron_list` results. Codex uses the shared policy helper (no native Stop enforcement claimed).
+- **Negation-aware classification.** "Xóa cron …, không thay đổi code, Git hoặc Docker" / "Delete cron …. Do not modify source code, Git or Docker." classify as OPERATIONAL; negated source instructions no longer become source requirements.
+- **No-route mutation.** A prompt that ordered a change but matched no skill (no routed contract) now ends with an explicit "nothing was verified" notice instead of a silent stop. This is a notice, not a block — a known limitation.
+- Loop-breaker release note no longer claims no verification ran; docs retry-guidance wording aligned in the template instructions.
+- Limits: classifier is lexical; the Cron adapter does not support an "ensure presence" goal (fails closed); no live native end-to-end run was performed.
+
+## 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
@@ -845,6 +933,18 @@ entries:
     archive_policy: never
     notes: C69 G7 operator doc — timeline render, support bundle contents/exclusions, replay limits
 
+  - id: docs-unic-decision-integration-p1-fix
+    path: docs/UNIC-DECISION-INTEGRATION-P1-FIX.md
+    class: canonical
+    audience: [maintainer]
+    owner: runtime
+    source_of_truth: docs/UNIC-DECISION-INTEGRATION-P1-FIX.md
+    merge_strategy: none
+    load_policy: on-demand
+    validation: [manual]
+    archive_policy: never
+    notes: P1 safety-floor / ordinal choice score / request-cap fix record for the unic-decision integration (9971eac0)
+
   - id: docs-design-ci-cross-platform-matrix
     path: docs/design/CI-CROSS-PLATFORM-MATRIX.md
     class: canonical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "3.4.29",
+  "version": "3.4.31",
   "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/executionContracts.js

@@ -166,3 +166,35 @@ export function buildConfigContracts() {
     Object.entries(EXECUTION_CONTRACTS).map(([mode, contract]) => [mode, stripContractForConfig(contract)])
   );
 }
+
+// Task semantics are independent of source execution strategy and observed progress.
+export function classifyTaskSemantics({ promptText = '', targetFile = '' } = {}) {
+  const text = String(promptText).normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/đ/g, 'd').toLowerCase();
+  const clauses = text.split(/\s*(?:[;\n,]|\.(?:\s+|$)|\band\b|\bthen\b|\bva\b)\s*/);
+  const actionable = clauses.map((clause) => clause.split(/\bwithout\b/)[0]).filter((clause) => !/\b(?:do not|don't|never|khong|dung)\b/.test(clause)
+    && !/^\s*(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(clause));
+  const sourceOrder = actionable.some((clause) => /\b(?:implement|fix|refactor|modify|edit|write|update|sua|viet|chinh)\b/.test(clause)
+    && /\b(?:source|code|logic|scheduler|implementation|ma nguon)\b|\.[cm]?[jt]sx?\b/.test(clause));
+  const operation = actionable.some((clause) => /\b(?:delete|remove|cancel|xoa|huy|ensure|dam bao)\b/.test(clause)
+    && /\bcron\b|scheduled\s+(?:cron\s+)?(?:task|job)|tac vu\s+(?:cron|dinh ky)/.test(clause));
+  const config = actionable.some((clause) => /\b(?:configuration|config|toggle|cau hinh)\b/.test(clause));
+  const repository = Boolean(targetFile) || /[\w.-]+\.(?:json|ya?ml|toml|ini)\b/.test(text);
+  const readOnly = /\b(?:audit|inspect|review|analyze|analyse|explain|read|kiem tra|phan tich)\b/.test(text)
+    && !sourceOrder && !operation && !config;
+  const taskKind = operation ? (sourceOrder ? 'MIXED' : 'OPERATIONAL')
+    : config ? 'CONFIGURATION' : readOnly ? 'READ_ONLY' : 'CODE_IMPLEMENTATION';
+  const id = text.match(/\b[a-f0-9]{8}(?:[a-f0-9-]{0,28})\b/)?.[0] || null;
+  return { taskKind, ...(config ? { configurationScope: repository ? 'repository' : 'external' } : {}),
+    ...(operation ? { operationGoal: { domain: 'scheduled-job', target: id, desiredState: /\b(?:delete|remove|cancel|xoa|huy|absent|removed|deleted|no longer|khong con)\b/.test(actionable.join(' ')) ? 'absent' : 'present',
+      completionSemantics: /\b(?:ensure|dam bao)\b/.test(text) ? 'ensure-state' : 'execute-and-verify' } } : {}) };
+}
+
+export function applyTaskSemantics(contract, semantic) {
+  const evidence = contract?.completionEvidence || [];
+  const operationOnly = semantic.taskKind === 'OPERATIONAL'
+    || (semantic.taskKind === 'CONFIGURATION' && semantic.configurationScope === 'external');
+  return { ...(contract || {}), ...semantic,
+    completionEvidence: operationOnly ? ['operation-verification']
+      : semantic.taskKind === 'MIXED' ? [...new Set([...evidence, 'write-evidence', 'operation-verification'])]
+        : semantic.taskKind === 'READ_ONLY' ? (evidence.length === 1 && evidence[0] === 'verification-evidence' ? evidence : ['impact-evidence']) : evidence };
+}

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/decision/client.js

@@ -368,6 +368,21 @@ export function createDecisionClient({
       return outcome('invalid', { fallbackCode: 'empty-batch' });
     }
 
+    const maxBatch = dp.maxBatchQuestions ?? 8;
+    const maxEnum = dp.maxEnumLabels ?? 11;
+    if (![maxBatch, maxEnum].every(n => Number.isInteger(n) && n > 0)) {
+      return outcome('unsupported', { fallbackCode: 'invalid-decision-limits' });
+    }
+    if (questions.length > maxBatch) {
+      return outcome('unsupported', { fallbackCode: 'max-batch-questions' });
+    }
+    if (questions.some(q => Array.isArray(q.candidates) && q.candidates.length > maxEnum)) {
+      return outcome('unsupported', { fallbackCode: 'max-enum-labels' });
+    }
+    if (new Set(questions.map(q => q.decisionKey)).size !== questions.length) {
+      return outcome('invalid', { fallbackCode: 'duplicate-question' });
+    }
+
     // Language classification covers state + question text; the English
     // checkpoint is reachable only when the whole request proves English.
     // Malformed batch input (cyclic state, non-serializable values, internal

package/src/decision/protocol.js

@@ -51,23 +51,20 @@ export function encodeQuestion(question) {
       description: 'true iff the proposition holds; interpreted as P(true).',
     };
   } else {
-    // score — ordinal integer; the legend MUST be defined in the description.
-    const legend = Array.isArray(candidates) ? candidates : [];
-    value = { type: 'integer' };
-    if (legend.length > 0) {
-      value.minimum = 1;
-      value.maximum = legend.length;
-      value.description = `Ordered scale: ${legend
-        .map((label, i) => `${i + 1}=${label}`)
-        .join(', ')}.`;
+    if (!Array.isArray(candidates) || candidates.length === 0
+        || candidates.some(label => typeof label !== 'string' || !label.trim())
+        || new Set(candidates).size !== candidates.length) {
+      throw new TypeError('score requires unique non-empty ordinal labels.');
     }
+    value = { type: 'string', enum: [...candidates] };
   }
 
   return {
     type: 'function',
     function: {
       name: decisionKey,
-      description: String(instruction ?? ''),
+      description: String(instruction ?? '') + (kind === 'score'
+        ? `\nOrdered ordinal rubric: ${candidates.map((label, i) => `${i + 1}=${JSON.stringify(label)}`).join(', ')}. Choose exactly one label; do not return an expected numeric score.` : ''),
       parameters: {
         type: 'object',
         properties: { value },
@@ -184,11 +181,12 @@ function validateValue(question, args) {
     if (isFiniteNumber(value) && value >= 0 && value <= 1) return { value };
     return 'missing-value';
   }
-  // score — finite integer within the declared legend range.
-  if (!isFiniteNumber(value) || !Number.isInteger(value)) return 'missing-value';
+  // Decode an explicit choice losslessly; never reinterpret native expectations.
   const legend = Array.isArray(question.candidates) ? question.candidates : [];
-  if (legend.length > 0 && (value < 1 || value > legend.length)) return 'out-of-enum';
-  return { value };
+  if (!legend.length || new Set(legend).size !== legend.length) return 'out-of-enum';
+  if (typeof value !== 'string') return 'missing-value';
+  const ordinal = legend.indexOf(value);
+  return ordinal < 0 ? 'out-of-enum' : { value: ordinal + 1 };
 }
 
 /**

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)) {