v1.6.0

Added

• code-graph: capture Go call/reference target import-path qualifiers on pending_edges (target_module) and classify external edges by go.mod module membership in the resolution-rate metric (ADR-0038, Layer A).
• code-graph: definition-side pkg: qualifier on Go symbols + package-qualified resolution (precise cross-package linking, AMBIGUOUS producer, cross-repo deferred) — ADR-0038, Layer B.
• code-graph: qualified-target capture for TypeScript (def-side pkg: qualifier from the repo-relative file path + call-side target_module from the import specifier), extending package-qualified resolution beyond Go; the resolution-rate external classification is now language-aware so non-Go qualifiers classify by pkg:-existence rather than the Go go.mod membership test — ADR-0038, Layer C.
• code-graph: qualified-target capture for Python (def-side dotted-module pkg: qualifier + call-side target_module from import statements, relative imports normalized against the source file) — ADR-0038, Layer C.
• code-graph: definition-side namespace pkg: qualifier for C# symbols (enclosing block namespace or file-scoped namespace), extending package-qualified resolution — ADR-0038, Layer C.
• code-graph: call-side C# qualified-target capture — configs/csharp.json supplies the @reference.call captures the inferred tagger pool omits for invocation_expression via an additive extra_tags_query (appended to, never replacing, the resolved query). A using-alias receiver yields a namespace target_module (the alias target's FQN minus its final type segment); a bare type resolved by using-namespace search, a namespace-rooted member chain (ambiguous namespace/type split), and this/local-variable receivers stay unqualified under the authoritative-qualifier invariant — ADR-0038, Layer C.
• code-graph: RunResult.Ambiguous counter and RESOLVER_AMBIGUOUS diagnostic event (candidate set) make the qualified-resolution ambiguous producer observable (ADR-0038 follow-up).
• code-graph: graph retag backfills def-side pkg: on already-indexed Go/TS/Python symbols without re-extraction and (by default) drains the per-repo resolver, closing the Layer B/C rollout resolution-rate dip; --resolve=false for tag-only runs. C# requires a re-index (ADR-0038 follow-up).
• code-graph: relationships.target_module records the module qualifier that pinned each qualified-resolved edge (provenance) — ADR-0038 follow-up.
• code-graph: the /health code-graph-resolution panel now reports the terminal-external edge count alongside the unresolved split (informational; the resolution-rate gate is unchanged) — ADR-0038 follow-up.
• code-graph: one-hop re-export following — TypeScript barrel re-exports (export * from, export { X } from) resolve through the barrel to the defining module, staying package-qualified (ADR-0038 follow-up).
• code-graph: Python __init__.py re-export following — from .mod import X in a package init resolves pkg.X to its defining module via the shared one-hop follow (ADR-0038 follow-up).
• code-graph: Go value-method calls on explicitly-typed receivers (var x pkg.T, parameters) capture the receiver type's package qualifier; :=-inferred receivers stay unqualified (ADR-0038 follow-up).
• code-graph: Java qualified-target capture — def-side pkg: from the package declaration (and call-side target_module from imported FQNs where Java call edges exist), generalizing the C# lexical-namespace model. Kotlin/F# remain grammar-gated (ADR-0038 follow-up).
• intake: copy the verbatim source file into ~/.anton-core/data/knowledge/<item-type>/<id><ext> after a successful save --source-path / bulk-import, so raw inputs survive DB loss (Layer 1 durability). bulk-import summary gains copies_written / copy_failures and its per-file jsonl line gains copy_failed; save reports the durable copy location as saved_path. The item save / item bulk-import output contracts now enumerate these keys.

Fixed

• code-graph: nested C# block namespaces now qualify with their full dotted path — namespace Acme { namespace Web { … } } stamps def-side pkg:Acme.Web, not just the innermost pkg:Web. The enclosing-namespace walk concatenates every namespace_declaration ancestor instead of returning at the first; the truncated form mismatched the call-side qualifier (full FQN minus its last segment), so nested-namespace symbols referenced through a using alias could never resolve. Single dotted declarations (namespace Acme.Web) and file-scoped namespaces were already correct — ADR-0038, Layer C.
• code-graph: a CALLS edge now resolves against a method definition, not only a free function. The candidate lookup matched the call's conservative function expected-kind exactly against items.kind, so a call whose target is a method (every C# call, and most calls in any OO language) never resolved; the candidate-kind match now treats a CALLS target as a callable (function or method). Pre-existing and latent — every prior resolve fixture used free functions — first exercised by C# call-side capture (ADR-0038, Layer C).
• code-graph: the resolver now persists the normalized TypeScript/Python target_module (def-side pkg: form, e.g. src/util) on a pending edge that stays unresolved, instead of leaving the raw import specifier (./util). The language-aware resolution-rate reader tests pkg:<target_module> existence, so a persisted raw specifier silently dropped an in-corpus relative/aliased-import gap as external and under-counted unresolved edges — ADR-0038, Layer C.
• code-graph: nested-go.mod walk — def-side pkg: and resolution-rate module membership resolve against the nearest enclosing module, fixing monorepo misclassification (ADR-0038 follow-up).
• code-graph: Python multi-segment relative imports (from .pkg.mod import x) resolve to the nested module (ADR-0038 follow-up).
• code-graph: TypeScript index.ts implicit resolution — an index module's def-side pkg: is its directory (src/feature), matching ./feature imports (ADR-0038 follow-up).
• code-graph: guard the indexer's per-repo module-path cache (Indexer.repoRootBySlug) with a mutex — repos sync indexes multiple repos concurrently through one shared indexer, so the unsynchronized cache read/write was a data race (pre-existing; mirrors the mutex the slug cache already takes) — ADR-0038 follow-up.
• code-graph: a failed best-effort module-path persist (or stale-key sweep) during indexing now emits a WARN MODULE_PATH_PERSIST_FAILED / MODULE_PATH_SWEEP_FAILED event instead of a bare log line. The Go resolution-rate metric classifies edges by module membership read from those rows, so a silently-lost write could otherwise leave the code_graph_resolution panel falsely healthy — ADR-0038 follow-up.
• code-graph: graph retag now reports status: "partial" for a repo whose pkg: tags committed but whose post-tag resolver drain failed, so a status-only scan no longer reads a half-completed repo as fully successful — ADR-0038 follow-up.

Changed

• intake: saved_path now records the durable copy location (<item-type>/<id><ext>) instead of the user's original path; retry --target extraction and purge --target legacy-stubs resolve it against the data root and re-read the copy. The save --saved-path flag is removed (the path is computed now).
• report health — the code_graph_resolution panel no longer counts calls
  into the standard library or unindexed dependencies as unresolved. The
  resolution-rate reader excludes any pending edge whose target name is defined
  nowhere in the indexed corpus (generalising the language-level externals
  filter), so a single-repo index stops pegging warning over expected
  external call targets; a target the corpus does define stays counted, so the
  ratio measures edges the resolver could link but has not. The panel detail
  now reads N% of code-graph edges unresolved rather than N% orphaned items
  — the figure counts edges, not graph nodes. Precise classification via
  fully-qualified target monikers is tracked in
  docs/adr/0038-code-graph-qualified-target-capture.md.