fix: preserve static namespace bracket calls in default-auto call graphs

[mohanagy]

User story

As a developer tracing a cross-file call, I want a statically resolved namespace bracket call to retain the same authenticated relationship as the equivalent dot call, so that the call chain is not missing a real step.

Acceptance criteria

• A literal namespace bracket call and its equivalent dot form resolve to the same source-grounded target through the real default-auto graph and public call-chain response.
• Shadowed receivers and unresolved dynamic keys do not gain invented import/call relationships.
• Existing dot calls, runtime heritage traversal, export resolution, provenance and cache/regeneration behavior remain correct; positive controls must themselves represent valid source semantics.
• A future accepted correction has reviewed exact-candidate and integrated evidence. A diagnostic pass or helper-only result cannot close this defect as fixed.

Status and boundary — 10 September 2026

OPEN — BLOCKED. The previous mechanism remains stopped. Two rejected candidates do not establish a fix. The last review records heritage traversal regressions, an invalid positive control, and red or incomplete validation.

This story states the unresolved user behavior; it does not authorize a third repair, rerun or resumption of the old mechanism. A future mechanism decision must first address the invalid oracle and the documented regression within an explicit finite scope. Do not revive old implementation instructions from the history below.

This defect remains separate from #754's product-usefulness question. No claim about overall task quality, latency or cost follows from resolving it.

Historical issue body — preserved; current disposition above takes precedence

Current disposition — 5 September 2026

OPEN — BLOCKED. The mechanism is stopped after the second independent HOLD and the agreed stop condition. Current roadmap: #740. The latest review records real heritage traversal regressions, an invalid positive control, and red or incomplete required validation: #739 (comment). Preserve those distinct findings, both reviews, and all frozen historical controls and contracts.

No third repair, coding, acceptance rerun, PR, merge, release, or benchmark is authorized by this reconciliation. Any resumption requires a separately approved mechanism decision and a new versioned contract, including correction of the invalid oracle; it is not the next automatic action. #741's independent research and evaluation-contract preparation can proceed without resuming this issue. The original implementation authorization below is historical and does not override this current blocked disposition.

---

Preserve static namespace bracket calls in default-auto call graphs

Maintainer authorization, 5 September 2026: create this one implementation issue and assign the bounded correction and tests to Codex CLI. The reviewing lead coordinates GitHub, managed state and evidence; a separate fresh reviewer checks the exact candidate. This authorization follows the positive reviewed result of #738. It does not authorize merge, release, or a new model benchmark.

Problem and expected change

At 72ecb4aa72899c5fa1ba4e2c27795070e74871eb, default-auto generation omits a cross-file call made as names["prepareName"](input), while the equivalent names.prepareName(input) produces the relation. In the three-file #738 development example, the existing public MCP call_chain consequently returns zero paths for brackets and the complete renderGreeting() → prepareName() → trimName() path for dots.

The correction should make this statically resolved bracket form produce the same authenticated relations and public chain as the dot form. The receiver must bind to the actual imported namespace, and the literal member must resolve through the existing export map. A matching name on a locally shadowed receiver must not create an imported-export edge.

This is one call-graph correctness repair. No improvement in overall agent answer quality, token cost, latency or the completed #736 experiment is established by the feasibility result.

Evidence to read before editing

Read the complete #738 contract, research result and amendments. The lead supplies the local author report, reproduction instructions, author manifest, independent review and corrected reviewer manifest in the CLI dispatch. Their identities are recorded in the linked #738 result. These artifacts are preserved evidence, not files to repair during implementation.

The reviewer independently reproduced the public responses and stored graph facts. Its copied debugger probe exited with a trace-completeness failure because a source symlink changed breakpoint URLs; the original causal trace was hash-verified and checked against the exact source. Preserve this limitation. Do not report an independent full-probe pass or edit historical diagnostic evidence to remove the failure.

Implementation boundary

Extend the existing static namespace-member recognition in resolveCrossFileRelativeJsImports, within src/pipeline/extract/cross-file.ts. Reuse its lexical-shadow guard, namespace/export resolution, relation construction, callsite provenance and deduplication.

Eligible new recognition is an identifier receiver with a string-literal element key whose existing namespace/export lookup resolves the target. Arbitrary computed keys remain outside this repair. Preserve established dot-access behavior and the existing default-auto topology policy. Apply the existing extractor-cache invalidation mechanism for the changed extraction semantics so incremental generation does not carry forward missing relations. Previously stored graphs require regeneration; do not rewrite historical graph evidence.

If the source facts are unavailable at this owner, or the correction requires changing multiple architecture owners, stop and report the contradiction before expanding scope. Do not switch topology ownership to SPI or revive the rejected navigation candidate.

Required development controls

Codex CLI should reuse the repository's existing test facilities and exercise the real default-auto generation and public MCP behavior.

1. Public regression: preserve the [Feasibility] Establish one bounded Madar recovery mechanism after #736 #738 task, source semantics and public request. Demonstrate the regression fails on the recorded base because the bracket chain is absent. After correction, regenerated bracket and dot variants must both return the same expected three-function chain. Inspect the actual relation endpoints and relevant provenance as well as the serialized result.
2. Binding negative: a nested function parameter shadows a file-scope namespace import and contains a same-named method. A literal bracket call on that parameter must not acquire a call/import relation to the imported export. Verify the absence of that specific false edge, rather than only an aggregate count.
3. Different positive: an unrelated, unshadowed namespace call uses a literal key that resolves through a renamed barrel export. Establish its source-grounded target and expected public chain before implementing the repair. It must resolve through the existing binding/export mechanism without identifier-specific exceptions.
4. Compatibility: retain dot-call behavior, unresolved dynamic-key behavior, existing relation/provenance conventions and deduplication. Verify the existing cache invalidation path for regeneration following the extractor change.

These are visible development controls, not holdout or product qualification tasks. If another occurrence exposes the same incompletely modeled boundary after correction, stop this mechanism rather than adding a sequence of name-specific exceptions.

Execution and review

Refresh live next, issue amendments and root status before dispatch. The feasibility base is 72ecb4aa72899c5fa1ba4e2c27795070e74871eb; reconcile any intervening change explicitly. Use an isolated branch/worktree and preserve the user's root changes and all #738 evidence. Use the existing managed-state writer and record the actual Codex CLI session. Historical role assignments do not override the maintainer's assignment of implementation to Codex CLI.

Codex CLI implements the failing regression, bounded correction and controls, runs the relevant required checks, and returns the exact candidate commit/tree, diff, commands, before/after public evidence and remaining limitations. Run the repository's required validation appropriate to the change. Do not substitute helper-only tests or a green aggregate for the public regression and negative binding control.

A separate fresh reviewer checks the exact candidate and all four acceptance areas. Any corrected candidate needs review and checks on that updated identity. A successful review may support a later integration proposal under #738's product-qualification gate; merge and release retain the maintainer's separate authority, with exact-head CI and post-merge verification required if integration is later authorized.

No new model benchmark is part of this implementation issue. Product qualification remains a later decision using fresh, independently held tasks and frozen quality/completeness/citation/total-cost criteria. #697, #710 and historical recovery issues retain their dispositions.

Acceptance and stop outcome

Accept implementation only when the public regression fails at base, passes on the candidate, the materially different controls establish correct binding behavior, cache/compatibility requirements hold, and independent exact-candidate review accepts the evidence.

If any of those fail, preserve the candidate and evidence and return the specific unresolved result. Closing an implementation issue as fixed requires delivered integration evidence; completing a diagnostic or obtaining a local green test does not establish that status.

[mohanagy]

IMPLEMENTATION-HOLD — local candidate rejected; #739 remains open.

Codex CLI produced local commit f1a27c5cbb070be1d50225c22e6b2366e0900056, tree 7c6126f3d233f7bdbe9c3ce0791200b48d271f4e, from the recorded 72ecb4aa72899c5fa1ba4e2c27795070e74871eb base. A fresh independent Codex CLI review reproduced the original bracket/dot repair and the supplied controls, then confirmed a new binding regression:

import * as depot from './helper.js';
export function run(): number {
  const local = {
    invoke(depot: { dispatch(): number }): number {
      return depot["dispatch"]();
    }
  };
  return local.invoke({ dispatch: () => 2 });
}

Here helper.ts exports a dispatch() that throws if called. Both compiled fixtures return 2; the receiver binds to the method parameter. The base returns no public run → dispatch chain. The candidate creates false calls and imports_from facts to the imported export, marks both EXTRACTED with confidence score 1, and returns run() → dispatch() through the actual default-auto graph and stdio MCP interface.

The existing visitor processes method parameter scopes through its class-owner branch; the object-literal method falls through with its parameter missing from the scope chain. Reusing that guard therefore did not establish the required namespace binding. This directly violates the issue contract. The agreed stop rule applies: retain the candidate and counterexample and revisit binding handling before another implementation attempt. Do not add name-specific exceptions, expand topology ownership, or treat the passing original examples as acceptance. A corrected candidate requires the new regression, existing controls, exact-candidate checks and a fresh review.

Validation is also incomplete. In an isolated child home/cache with process inspection available, the installer/discovery/lifecycle controls passed 128 tests, and typecheck/build passed. The complete guarded suite exited 1 after 319 passing files / 5,067 passing tests because five files never started their workers. The guard correctly rejected the run. #710 already tracks that failure class; a common cause is not proved and its disposition is unchanged. No full-suite retry followed. The reviewer also retained an unsuccessful additional CLI cache probe caused by its own command ordering, and makes no independent CLI cache-update pass claim; its focused cache test passed.

The source, original 534-entry evidence package, 64-entry validation continuation and independent counterexample/review are retained locally. The candidate has not been pushed or integrated; there is no PR, release or new product benchmark. Historical issue dispositions and #738 artifacts remain unchanged. Overall product benefit remains unqualified.

The lead verified all three manifests after both CLI tasks completed: 534 original entries, 64 continuation entries and 521 reviewer entries, with no mismatches. Reviewer manifest SHA-256: 4a7dfbac00748f831d584c61edaf244d865d8cd32f65eada146798a14b6b6880.

[mohanagy]

#739 — reviewed binding correction contract

This amendment supersedes the previous instruction to reuse the incomplete spelling-based shadow guard. The maintainer authorized this reassessment and the bounded successor correction after the rejected attempt.

Fresh actual Codex CLI design review "01a07061-9a98-7cd3-a806-f35422086492" returned DESIGN-GO, meaning this finite design fits the existing owner; it does not accept any successor implementation. Review SHA-256: 09fa428955a91f167e1cad0251d2d8c2f116a3b73d7d909fc0239b675d7aaedc; manifest SHA-256: 2046ab189ee18eec3908973b6b82036619f0e1f8fa22cf5b844e8bfb8b92b6cf. The lead verified all 10 sealed artifact entries and 47 read-only inputs after CLI exit 0.

The rejected candidate f1a27c5cbb070be1d50225c22e6b2366e0900056 remains rejected and preserved. Its actual object-method counterexample proves a false imported relation; the corrected-environment full suite also failed because five workers never started. The maintainer authorized a binding-model reassessment and, if the existing owner can support it, a general correction by Codex CLI. Integration base remains live origin/next at 72ecb4a.

Changed mechanism, same bounded behavior

The old instruction to reuse the spelling-based lexical-shadow guard is superseded by a declaration-identity requirement. Build an import-binding projection from the parsed TypeScript AST within resolveCrossFileRelativeJsImports and local helpers. Predeclare bindings and assign evaluation environments independently of graph ownership. For a reached eligible call, only resolution to the exact runtime import declaration can authorize an imported target. A same-spelled local declaration, unavailable runtime alias, or ambiguous binding cannot authorize it.

Keep the existing call traversal and graph-owner policy. Do not create object-method/accessor/static-block nodes, add previously skipped call locations, infer alias/object values, or replace SPI/topology ownership. Existing owner limitations must remain explicit; binding acceptance is not general call-graph or product correctness.

Production source boundary: src/pipeline/extract/cross-file.ts, confined to the existing JS/TS linker and its local binding helpers, plus EXTRACTOR_CACHE_VERSION in src/pipeline/extract.ts. Existing namespace/export target selection, relation construction, ordering, provenance and dedup remain authoritative. An owner-local runtime-route veto may reject a selected type-only route; it must not change the shared export map or select a new target. No compiler Program/TypeChecker service, public schema, ranking, dependency, test-runner configuration or reliability fix is included. Bounded tests and fixtures live under tests/unit/ and tests/fixtures/static-namespace-calls/; record their exact file list before production edits.

Source notation: CF is cross-file.ts at rejected head; EX is extract.ts at that head. AST and TS refer to the locally installed TypeScript 6.0.3 declarations/implementation pinned by the unchanged lockfile. S means static source assessment; R means retained directly executed predecessor evidence, not a new reproduction.

Concrete correction algorithm

The only production edits belong inside resolveCrossFileRelativeJsImports, its local scope helpers, and the existing cache constant in EX. The local call-eligibility preflight below is part of that owner. It must not change the shared export-map implementation or create another resolver pipeline.

1. Index identities before walking calls. From the owner's parsed source with parent pointers (CF1751), build lexical environments and an AST-node-to-environment map. Parse/cache the existing knownFiles inside this owner as needed for its existing export routes and namespace declarations; use the existing module-path resolver. Do not read compiler locals/symbol fields that require binding. Precollect import descriptors by declaration/specifier identity, local name, form, phase, target file/export and original import line. This pass is pure: no graph nodes, edges or dedup writes. Imports are visible throughout their module, including inside a function whose declaration precedes the import text.

2. Use distinct binding categories. A frame maps a value name to a declaration identity: eligible runtime ESM import, other value, unavailable type-only import alias, or conflict/unknown. Retain a separate type-name classification solely to avoid shadowing values with interfaces, type aliases, type parameters or noninstantiated namespaces. A value/type legal merge keeps the value identity. An invalid conflicting value declaration never falls back to the file import. A local alias initialized from the import is still a different binding; do not invent alias flow. import = supplies a local/unavailable binding, without becoming a newly supported call-target form. import defer * as remains a runtime namespace binding. Language-defined arguments belongs to non-arrow functions; this is a syntax rule, not a fixture-name exception.

3. Predeclare each scope, not each visited statement. Source, module execution body, function body and class static block are var containers. Precollect their var declarations through nested ordinary statements/blocks/loops/catches, stopping at every nested runtime function, namespace body and static block. For a class expression's evaluation children, retain the surrounding environment; do not treat its fields/static blocks/method bodies as surrounding var code. A function's direct body function declarations belong to its body environment; block function declarations in strict module code belong to their block. Blocks prebind let/const/using/await-using, functions, classes and relevant enum/module declarations. Each switch CaseBlock gets one shared lexical frame; its discriminant stays outside. Lexical loop bindings cover header/RHS/test/increment/body, including TDZ references; var goes to the nearest var container. Catch names cover its binding evaluation and block, not try/finally. Predeclaration means a use before initialization is local, never the outer import; runtime reachability is not inferred.

4. Model every function and class independently of graph IDs. Runtime function kinds are exactly declaration, expression, arrow, method, get accessor, set accessor and constructor (AST4644). Build a named-function-expression self frame if present, a parameter frame with all pattern leaves prebound, then a body-var frame and body lexical frame. Parameter defaults/pattern expressions use self + parameters + outer environment, excluding body vars/functions/lexicals. Later parameters still block an outer import in a default (TDZ). Body scopes contain all parameters. A class has its own name frame for runtime extends, computed member names, field initializers, static blocks and member bodies; implements and type arguments are nonexecuting. Its declaration name also binds in the containing lexical scope, while a class-expression name never escapes. Methods/property names and constructor parameter properties do not create lexical names in sibling members. Each nested class expression gets its own named or empty class frame and retains the enclosing lexical chain; its own name never comes from inherited graph currentClassName. Thus an anonymous class nested within class ns can still capture that outer class binding. Computed method/accessor keys use the enclosing object/class environment, before parameters. Decorators bypass parameter/member function environments; class-declaration decorators use the surrounding declaration environment, while a named class expression retains its own name binding where that syntax is represented. TS23834–23840 supports the decorator skip, and TS23765–23772 the expression name. No new decorator ownership is implied.

5. Cover TypeScript execution containers. Bind enums as non-import values; member-initializer environments see enum members, including the same group's merged members. Group namespace declarations by containing lexical scope identity and namespace path, never by name across unrelated scopes. Each ModuleBlock has its private local/var environment and a shared exported-value view; lookup is local, merged exported values, then outer scope. Dotted namespace bodies form nested groups. Exported nested groups merge through their parent export identity; private ones remain block-specific. Use a finite syntax classification for noninstantiated namespaces (interfaces, aliases, nonexported import-only bodies, recursively noninstantiated nested modules) versus value/const-enum-only namespaces; TS46800–46935 and TS48472–48479 supply the relevant classification. This is declared value-space binding, not a simulation of emitted JavaScript. Const-enum values cannot authorize an outer import by spelling.

   Ambient/global/module-augmentation bodies are nonexecuting, but their declared values must be considered where they affect an indexed namespace group. Resolve literal augmentation targets only with the existing file resolver and attach declared exported values to the matching module/namespace identity; index all such declarations in the finite known-file set before lookup. Global declarations cannot replace a local ESM import. An augmentation is attached only when the existing resolver establishes its exact known module identity; if it returns no known target, retain the augmentation as unassociated, nonexecuting declarations, with no claim that it changes a known local namespace. No spelling/path-suffix guess attaches it. Within an established group, conflicting or unclassifiable declared value names are unknown when lookup crosses that group, rather than rejecting every namespace or pretending those names resolve to an import. An unknown outer/global group does not override a nearer proven import. This covers supplied parsed-source visibility; it does not assert TypeChecker knowledge of unseen project/dependency declarations.

6. Separate lexical indexing from emission. Keep the existing visitor's reached-call set and existing legitimate owner selection. At each reached candidate call, look up the identifier occurrence's indexed environment. Only the exact eligible import descriptor can authorize the matching import form's target. Neither currentOwnerId, searchableNodeIds, currentClassName, inherited class identity, nor an object method's missing node is input to this lookup. Existing class/method/default/nested-function owner IDs and existing fallback attribution remain. No object-method/accessor/class-expression node is fabricated, and no calls in presently skipped parameter defaults, heritage or fields are added. Their lexical environments are nevertheless modeled because other paths already traverse those syntax positions. Type-only/ambient subtrees are marked nonexecuting, so generic child walking cannot promote their computed type expressions into runtime calls.

7. Authenticate only the existing target and route. Keep the candidate grammar: named direct call; namespace dot call; namespace element call with identifier receiver and ts.isStringLiteral(argumentExpression) (decoded .text). Do not widen to StringLiteralLike, templates, numeric keys, parentheses around the receiver, assertions as receiver, arbitrary expressions or object alias evaluation. For the selected existing export-map target (CF1724–1732), run an owner-local value-route eligibility check. This is necessary because CF262–400 is type-only blind: a function can currently be reached through an explicitly erased export type route. Seed allowed routes from declared value bindings, local export aliases/default expressions supported by the current map, and runtime import aliases. Follow runtime named/star reexports and imported-then-exported aliases; honor both clause and specifier type-only flags. A legal type/value merge can supply a value route. Pure interface/type-alias terminals and solely type-only routes cannot justify a runtime call.

   Implement this veto as a finite worklist over (file, export name, existing selected target) and the parsed export/import route graph. Explicit runtime names have their existing precedence; a type-only declaration is not an executable value route. Propagate proven value terminals through runtime routes to a fixed point; cycles without a value terminal remain ineligible. Use the current export map's unique selected target, preserving its existing unresolved/ambiguous outcome. Preserve ambient value declarations as declared runtime contracts: declare or .d.ts alone is not a type-only-route veto. Never select a different target, add an export, widen namespace-export support, or infer arbitrary expression values. This preflight can reject an incorrect chosen route; it cannot expand topology. The map remains a prerequisite, not proof of runtime type/callability or execution.

8. Preserve relation semantics. Keep eager named/default imports_from facts at import-declaration lines, including legitimate structural type imports. A shadowed named call must lose only the false imported call; its real file-level import remains (existing extract.test.ts:4567 explicitly requires this). Namespace-member imports_from is demand-driven and is added only with an admitted call. Existing createEdge confidence/provenance and addUniqueEdge endpoint-triple dedup remain. Rejected calls do not reserve dedup entries or callsite provenance. External named/dot inference uses the same runtime-binding lookup and keeps INFERRED status; unresolved external brackets remain unresolved. Bump EXTRACTOR_CACHE_VERSION to a distinct successor value, normally 70, invalidating both 68 and 69 through equality checks and existing policy/cache keys.

Termination is structural. There are finitely many parsed nodes, scopes, declaration identities and existing export names. Scope creation visits each AST node once; predeclaration collections can be cached per container. Lookup walks finite parent frames. Namespace grouping is keyed by source scope identity; export eligibility uses a monotone visited worklist over finite route states. No unbounded search, runtime value analysis, compiler binder, model inference or fixture-specific rule is required.

The environment lookup follows the nearest binding, including uninitialized bindings. Parameter/body separation and class self scope follow the language environment rules. These narrow principles are checked against the ECMAScript environment operations, function declaration instantiation, and class definition evaluation. Namespace private/exported visibility is also documented in TypeScript declaration merging. The detailed finite partition below is independently grounded in the installed source.

Finite syntax and control matrix

All rows below are S: static source-derived current behavior / proposed correction, unless R identifies the retained executed predecessor observation. No new runtime/extractor reproduction is claimed. P is an unshadowed positive, N rejects the specific imported call and any call-induced namespace import, X checks scope exit/sibling isolation. For named/default imports, retain the separate real declaration-level import as explained above. Each control is future work, to be specified before production edits; no tests were written in this review.

Use namespace brackets and dot equivalents throughout, plus direct named-import counterparts wherever the same binding form applies. P/N pairs change declaration identity, not just a helper flag. P includes no-local and differently-named-local variants. X uses a distinct existing callable owner or separate fixture where necessary so endpoint dedup cannot hide an inner false call. A shadowed call first and valid call later must preserve the later valid provenance. TDZ/invalid-value structural negatives must be explicitly labeled if not executable; never present them as a valid runtime-2 counterexample.

ID / syntax	Current behavior and source evidence	Expected decision / shared operation	P / N / X controls
M01 SourceFile and import ordering	S: source frame exists, but import maps fill only on traversal (CF1886–1947,2001–2013). Function before import can miss target.	Module-wide import identity preindex; retain textual provenance.	P function before/after import yields same endpoint; N function parameter same name; X sibling function remains imported.
M02 Namespace, named/default imports, renamed aliases, side-effect imports	S: four global spelling maps (CF1752–1755); aliases mapped, side-effect has no binding (1892–1894).	Distinct per-declaration form/identity; side-effect import adds no callable binding.	P renamed import + renamed barrel; N local same-spelled object/function; X same import in sibling survives.
M03 Type-only imports, per-specifier type, deferred import, import attributes	S: no phase/type flags checked; AST5530–5539,5599–5609 exposes them.	Type aliases imported are unavailable for runtime calls; defer namespace remains value; attributes do not bind identifiers. Keep structural named import facts.	P mixed value/type clause and defer value; N type-only namespace/direct callee; X outer value beyond nested alias scope, adjacent value specifier unaffected.
M04 Interfaces, type aliases, type parameters, type queries/JSDoc, ambient bodies	S: statement binder ignores type names correctly, but generic walk can reach computed calls in type syntax (CF1827–1836,2267).	No value shadow from pure type names; no execution in type/ambient syntax; ambient declared values still classify as values where visible.	P same-spelled interface/type parameter beside runtime import use; N call solely in type-member computed syntax/type-only alias; X following runtime call survives.
M05 Source/block value declarations before and after calls	S: funcs/classes/variables prebound; enum/module/import-equals absent (CF1827–1836,1964–1979).	Predeclare complete direct lexical values. let/const/class TDZ still shadows; order cannot restore import.	P unrelated local; N same-name declarations both before and after call; X inner block exit restores import; source-level duplicate import/value is conflict, not fallback.
M06 Block/function declarations and ordinary nested blocks	S: Blocks push/pop; direct funcs predeclared (CF1964–2008).	Body function names belong to body; strict block functions to block; nested blocks inherit.	P closure captures import; N same-name block function, including earlier closure defined before declaration; X after block imported again.
M07 Source/function var, nested-block/loop var, inner isolation	S: body hoist scans blocks/loop headers; source lacks the same full prepass; stop set omits accessors/modules (CF1787–1825,1861–1867).	Precollect once to nearest execution var container; stop every function-like/module/static boundary.	P getter/method/inner-function contains same-name var but outer call imports; N later same-function nested-block/loop var blocks earlier call; X exit function restores import, exit block alone does not for var.
M08 Switch discriminant, case selectors, clauses	S: CaseBlock falls through; late clause declarations not prebound and encountered names mutate outer frame (CF2006–2008,2134–2161,2267; AST5370–5392).	Discriminant outer, one shared lexical CaseBlock over selectors and all clauses, vars in enclosing var container.	P imported call in discriminant; N earlier case selector/body versus later same-name lexical declaration; X post-switch positive; separate nested case block has own exit.
M09 Named/anonymous/default function declarations	S: named/default branches select existing owners and combine parameter/body bindings (CF2071–2097). Defaults skipped.	Universal function operation; declaration name outer; anonymous default invents no lexical name. Preserve owners/skips.	P named and default owners; N parameter or body var; X sibling function positive; anonymous default has no fabricated default identifier binding.
M10 Function expressions and named-expression self scope	S: self names passed at CF2109,2129,2152; generic expression reuses owner; variable/direct-property forms select existing owners.	Self frame inside expression, outside params/body; variable binding belongs to its actual containing scope, not a fabricated function self identity.	P anonymous expression captures import; N expression named like import; X self name does not leak after expression.
M11 Arrows, callbacks, async/generator functions	S: arrow/expression body generally scoped (CF2122–2131), recognized function branches skip defaults.	Same params/body operation; arrows inherit outer arguments; async/generator flags do not change lexical names.	P callback captures import; N arrow destructured param or body var; X outer/sibling unaffected.
M12 Parameter patterns, rest, defaults, later parameters, body-local separation	S: leaf collection good (CF1770–1786); ordinary defaults skipped; generic object methods/accessors may traverse them with wrong scope.	All parameter names prebound in parameter frame; defaults/computed binding keys exclude body locals/functions.	P object-method default value = ns['f']() despite body var ns; N same-name parameter earlier or later, rest/nested pattern; X next member/outer call imports. Ordinary skipped defaults stay unowned/skipped.
M13 Object methods (including string/computed names)	R: rejected ordinary method parameter produces false bracket call/import/public chain; S: gating at CF2032, fallthrough2267.	Always construct method lexical frame, with or without graph node/class context. Name/key is not a parameter binding. Existing reached body owner retained.	P unshadowed method call retains its old owner; N exact runtime-2 rejected control + nested/rest params; X call outside method remains imported. Repeat dot/direct named.
M14 Object getters and setters	S: generic traversal; accessors missing in var stop set and function dispatch (CF1787–1821,2032,2267; AST4670–4685).	Each accessor is a function/var boundary; setter pattern parameter local; getter has its own body vars.	P accessor uses import; N setter param/getter local var; X outer call after getter with inner same-name var stays positive (catches inner-var leakage).
M15 Class methods and constructors	S: params scoped only when class context set, owner existence may suppress body calls (CF2032–2048). EX3291–3338 defines legitimate nodes.	Build scopes regardless of whether methodId exists; preserve existing real method/constructor owner selection.	P existing constructor/method endpoints; N params/body vars; X next method and outer function positive; test absent graph node does not remove lexical scope.
M16 Class getters/setters and auto-accessor properties	S: getters/setters generic under class owner; no accessor function frame. Auto-accessor uses PropertyDeclaration path (CF2051–2068; AST4589,4670–4693).	Accessor functions isolated; auto-accessor initializer is class field context, property name not lexical.	P unshadowed accessor retains current owner; N setter parameter/getter var; X sibling member imports; skipped nonfunction auto-accessor initializer stays skipped.
M17 Class arrow/function properties and constructor parameter properties	S: direct function property body scoped and assigned existing methodId; other initializers skipped (CF2051–2068).	Field creation in class+outer scope; then function self/params/body. Constructor params only constructor, never sibling fields.	P property arrow references import even if ctor has same-name parameter property; N arrow param/named-expression self/body var; X sibling field/method positive.
M18 Named/anonymous class declarations, default class	S: declaration name goes in containing frame; named/default class branches visit only members (CF2016–2030).	Class self frame plus containing declaration value; anonymous default no invented identifier. Preserve class/default owners.	P unshadowed call in real method/default class; N same-name class in inner block; X block exit restores import; anonymous class does not shadow arbitrary default spelling.
M19 Named/anonymous ordinary class expressions and default-export expression	S: ordinary expressions generic, no class-self scope; default expression visits members without expression name (CF2114–2118,2267).	Named self frame through class evaluation/body, never escapes; anonymous no self. Keep existing owner behavior, no new class node.	P anonymous/differently named expression captures import; N class ns with a local static f and ns['f'](); X call after expression imports.
M20 Heritage, computed member names, decorators	S: declaration-class heritage/decorators skipped; method branch skips keys/decorators; ordinary class expressions/object methods/accessors can generic-traverse them (CF2016–2068,2267).	Class self for heritage/keys; object key uses outer object environment; parameter names do not bind keys/decorators. Apply decorator position rule above.	P computed object key calls import although method param same name; N class-self reference in reached heritage/key; X outer call after class. Keep declared-class skipped positions skipped.
M21 Instance/static fields and private/member names	S: declared-class nonfunction fields skipped; ordinary class expression generic fields reached (CF2051–2068,2267).	Class+self+outer environment; no constructor/body-var scope inherited by field. Private/property identifiers are members, not lexical value binders.	P reached class-expression field calls import; N named class self blocks; X member called ns does not suppress sibling bare ns import. No new initialization owner.
M22 Static blocks	S: body generic Block; direct var forwarded into nearest outer function; class vars may leak after visitation (CF1861–1867,2006–2008,2267; AST4698).	Separate static-block var + lexical frame; class outer frame; nested functions isolated.	P static block import call where already owned; N later local var blocks earlier call inside block; X second block, member and outer function import survive first block var.
M23 Object method/class expression nested inside an existing class	S: stale currentClassName may select an existing same-spelled class method owner (CF2032–2046,2122–2130,2267).	Lexical frames use AST parentage only; inherited owner context cannot prove import identity. No owner redesign here.	P existing unshadowed reached call retains attribution; N shadowed object-method parameter remains negative with same-name class method present/absent; X next real class method stays positive.
M24 for lexical headers	S: let/const scope covers init/test/increment/body; binding-expression positions skipped (CF2165–2193).	Lexical loop frame, pattern leaves before header expressions; per-iteration runtime values do not change declaration identity.	P unrelated loop local; N same-name receiver in init/test/body/closure; X after loop positive.
M25 for-in, for-of, for await-of lexical headers	S: RHS/body inside lexical frame, correctly including TDZ; pattern expressions skipped (CF2196–2209; AST5339–5350).	Full loop environment including RHS and pattern evaluation. Await modifier adds no binding.	P unrelated binding; N same-name receiver in RHS, body or closure; X after loop imports. Retain TDZ binding even though runtime may throw.
M26 var loop headers and assignment-only loop targets	S: var headers bind nearest function; nondeclaration loops generic (CF2165–2209).	Var predeclared throughout containing var scope; assignment patterns assign existing bindings and declare none.	P assignment to unrelated existing local; N var same name blocks before/after loop; X leaving loop does not restore var-shadowed import, leaving function does.
M27 Catch identifiers/patterns/optional binding	S: catch-name frame exists, pattern expression traversal skipped (CF2212–2217).	Catch frame before its body; optional binding adds no name; var still nearest execution scope.	P optional/unrelated catch; N renamed nested/rest catch binding; X finally and post-catch import positive, catch-local lexical never leaks.
M28 Destructuring variables/params/loops/catch; rest/omissions/defaults/keys	S: recursive leaves collected, property source names correctly not bound (CF1770–1786); explicit visitors skip several pattern expressions (2134–2161,2171–2183,2199–2200,2215).	One Pattern operation binds identifier leaves; computed keys/defaults mapped to the declaration's evaluation environment. No binding for source property name or array hole.	P {ns: other} leaves imported ns; N {other: ns}, nested/rest/array ns; X lexical pattern scope exit; skipped expressions stay skipped but index covers them.
M29 using / await using	S: existing BlockScoped mask includes these (AST4234–4262; CF2186,2203).	Preserve block/loop declaration behavior; disposal does not alter lexical identity.	P differently named resource; N same resource name before/after declaration; X outside resource block import positive.
M30 Enum/const enum, enum member initializers and merges	S: no enum declaration/member frame; initializers generic (CF1827–1836,2267). TS23727–23739 resolves members.	Outer enum value, inner merged-member environment; never imported by same spelling, including const-enum-only values.	P initializer refers to unrelated import; N same-name enum (with local namespace method for executable control) or member blocks outer name; X member name never leaks after enum.
M31 Runtime namespaces/module blocks and dotted namespaces	S: no module frame/name prebinding; private vars leak and lookup uses file-global maps (CF1787–1825,1827–1836,2267).	Module var/private frame + exported group + outer; dotted declarations nest groups.	P imported receiver when no local/exported binding; N module-local binding before/after call; X outside module remains imported, private sibling group isolated.
M32 Namespace/enum merges, pure type namespaces, augmentations	S: no group/value classification; TS23704–23739,46800–46935,48472–48479 exposes finite distinctions.	Preindex same-scope groups; shared exported values but block-private isolation; pure type group no value shadow; ambient augmentation nonexecuting declared visibility as step5.	P earlier block's private ns invisible in later block, or pure type namespace same name; N earlier/later merged exported ns or parsed augmentation declared value; X unrelated lexical group and outer import unaffected.
M33 Runtime/type import-equals and ambient modules	S: omitted by binder; generic ModuleBlock can leak names into source (CF1827–1836,2011–2013,2267; AST5505–5517).	Runtime equals aliases are local bindings, not new ESM target support; type-only alias unavailable; ambient module contents not executable.	P unrelated alias with imported receiver; N alias named receiver; X after containing namespace block outer import returns. Preserve no-call behavior for unsupported equals-import target itself.
M34 Strict direct eval, indirect eval, with, sloppy/Annex-B syntax	S: no dynamic barrier (CF2267). Valid static ESM import source is strict.	Strict eval cannot inject an enclosing var binding; do not inspect/evaluate strings. with expression outer, body an unknown object environment if encountered. Non-strict direct-eval var scope/Annex-B ambiguity can be marked unknown only where crossed; ordinary ESM frames stay precise.	P strict module imported call beside eval remains; N unresolved with-body cannot assert imported fact; X outside with/independent function precise. No invented eval-string graph calls.
M35 Remaining syntax and invalid/recovered positions	S: generic traversal covers return/throw/if/while/do/try expressions, operators, JSX expressions, wrappers and export expressions (CF2267); labels and property names are not declarations.	Such nodes inherit the proper indexed environment; function/class/container children dispatch to rows above. Type syntax/ambient subtrees nonexecuting. Malformed binding conflicts or unclassified declaration-bearing syntax use unknown, never a spelling fallback.	P call in conditional/JSX expression retains existing owner; N nested shadow in expression; X sibling expression positive. Confirm optional-call/access AST cases preserve candidate grammar, including no new new/tagged-template target recognition.

This partition covers the installed relevant node types: BindingName/BindingElement (AST4539–4569,4623–4628), every FunctionLikeDeclaration (4644), object members (4599–4615), class/property/accessor/static block types (4581–4589,4650–4702,5415–5440), all statement/loop/switch/catch containers (5297–5410), enum/module/import-equals (5463–5517), imports/exports and phase flags (5520–5630). Remaining syntax inherits an environment or is nonexecuting; it cannot silently add another declaration kind. This is a finite classification, not a growing list of example exclusions.

Recognition, export and ownership controls

Control	Current evidence / successor requirement
Original public chain	Retained R and source fixture: renderGreeting → prepareName → trimName. Keep the original task and request: source renderGreeting, target trimName, max_hops 8, edge_types [calls, imports_from]. Base brackets absent, base dots present; regenerated successor both present. Verify actual stored endpoint IDs/files, EXTRACTED score/provenance, call L4 and import L1, and public stdio output.
Different positive	Retained R and fixture: runShipment → enqueueParcel → checksum; parcelOps namespace from barrel renames enqueueParcel to dispatch. Target must be the worker declaration, not barrel/name invention. Preserve source-derived endpoints before edits.
Binding controls	Preserve nested function parameter negative and add exact object-method runtime-2 counterexample before production edits, then M01–M35. Keep unrelated local objects with the same member negative. Named-import negatives preserve genuine file imports.
Dynamic-key negative	Retained R and controls/dynamic.ts: parcelOps[key]() remains unresolved even when the local key value is a string literal. Keep absence of the specific imported call and call-induced import endpoints and the public no-path control. Do not propagate a constant into the new literal syntax.
Literal/receiver boundary	Existing extract-static-namespace-members.test.ts:37–116 accepts single/double quotes, decoded escape and string-named export "0"; rejects numeric 0, templates (including no-substitution), concatenation, nonidentifier/parenthesized/property receivers, unexported target and unrelated objects. Keep all. Optional access/call flags do not change import identity or allow new key syntax.
Export route boundary	Existing CF210–485 handles aliases, explicit/default exports, stars/ambiguity and cycles. Keep its result as prerequisite. Add paired runtime versus import type/export type/per-specifier-type route controls, including a renamed barrel and mixed value/type merge. Preserve working reexport cycles with a value terminal; no-terminal or ambiguous/missing target remains unresolved. Direct eager structural imports are not deleted by a runtime-call veto. S: type-route defect inferred from source, not reproduced here.
Dot/named compatibility	Both share the identity check. Keep constructor owner, nested helper owner, inline callback, named-expression self, later lexical/var/loop and catch controls already in extract.test.ts:4567–5090. Correcting false old dot/named call facts is permitted; removing valid owners or real imports is not.
Dedup and provenance	Keep mixed dot/double/single quote single endpoint triple and first valid callsite, current EXTRACTED/INFERRED distinction. Add shadowed-first/unshadowed-later ordering so scope suppression cannot steal dedup/provenance. External dot inference retained; unresolved external bracket has no fabricated target.
Traversal/owner freeze	For M09–M23, compare existing node IDs and admitted call owners on unshadowed controls. Snapshot absence of new owners/calls in already skipped defaults/declared-class heritage/nonfunction fields. Use object methods/accessors/reached class expressions to exercise those binding rules at existing owners. Lexical scopes remain present even when graph nodes are absent; do not fabricate a graph node to make a binding test pass.

Tests must assert semantic endpoint triples and public paths, not the number/type of helper frames. Use separate callers/fixtures for negative and exit positives when dedup would merge them. With existing attribution that aggregates an object method into its enclosing owner, isolate the counterexample to require both exact false endpoints and the public chain absent; use a separate positive variant to show legitimate owner behavior. Full matrix coverage is a development obligation before production edits, not a claim that a generated Cartesian test count proves the model. No product holdout or private #736 input is used.

Frozen controls and acceptance

Retain the original renderGreeting -> prepareName -> trimName public task/request and bracket/dot source semantics, the renamed-barrel runShipment -> enqueueParcel -> checksum positive, nested-parameter negative, dynamic-key/literal/receiver/export boundaries, and first legitimate call provenance/dedup. Add the rejected object-method example and complete finite matrix before production edits. Record which negatives already pass at base, which fail on the rejected candidate, and which are new source-audit controls; do not mislabel them holdouts or historical reproductions.

Controls must catch removal of binding identity checks, omission of callable/switch/class/static/namespace boundaries, body-var contamination of defaults, and scope leakage. One general correction is allowed after reassessment; another same-boundary miss stops this mechanism again. Do not add a succession of literal-name or syntax-example exceptions.

Use the existing cache version mechanism with a distinct successor version. Actual CLI artifacts from versions 68 and 69 must exist and be sealed before successor regeneration. Verify correction of the missing positive and removal of the rejected false facts, then unchanged reuse; distinguish default-auto from explicit legacy reuse behavior. Synthetic cache unit controls supplement actual old CLI artifacts.

Required validation is typecheck, guarded test:run and build on the clean frozen successor identity. Follow the separate recorded validation plan: isolated child home/cache, pinned Node 22.22.3, normal process inspection, focused public/binding/cache controls, one guarded single-worker diagnostic selection of the five previously unstarted files, then one complete npm run test:run with ordinary repository configuration. Stop before the full suite if the diagnostic fails. No pool/timeout/guard changes, benchmark or threshold waiver. A recurring startup failure remains a required-validation failure; stop retries pending diagnosis under the existing #710 boundary.

All new implementation evidence depends on successor production/test/fixture/runner identities. Preserve old manifests as historical evidence for their own head; do not reuse their freshness as successor acceptance. Seal stable evidence after producers finish, excluding growing CLI logs. Rollback is discarding/reverting the unmerged successor lineage and regenerating with the selected version; never rewrite stored historical evidence.

A fresh exact-candidate Codex CLI reviewer distinct from design, author and predecessor final reviewer must accept the controls and required validation. No merge, release, product benchmark, historical issue reopening or closing #739 as fixed is authorized here. Madar's expected product benefit remains unproven.

The default full-suite worker configuration remains unchanged. The diagnostic command is npm run test:run -- --maxWorkers=1 tests/unit/generate.test.ts tests/unit/compare-native-agent.test.ts tests/unit/compare.test.ts tests/unit/worktree-path-comparison.test.ts tests/unit/federate.test.ts. It is followed, only if successful, by one npm run test:run; no retries after another startup failure.

Prior art: the rejected candidate, the existing dot/named lexical controls in extract.test.ts:4567–5090, the installed TypeScript syntax/value-binding rules, the unchanged current export/cache owners, and available shadow/scope/739 branch names were inspected. No equivalent completed binding-identity repair was found in that bounded search.

[mohanagy]

Successor result: IMPLEMENTATION-HOLD

The successor under the revised contract is not accepted. Keep #739 open and blocked. Codex CLI authored the changes; a separate fresh Codex CLI session independently reviewed the exact local candidate.

• Head / last production-changing head: 00475b8b02cb7554171cf0f472f83eb9a6f449b6
• Tree: b8dc77824d70e775e26b24211032362d85767589
• Integration base: 72ecb4aa72899c5fa1ba4e2c27795070e74871eb (origin/next remains there)
• Retained rejected ancestor: f1a27c5cbb070be1d50225c22e6b2366e0900056
• Local branch: fix/739-namespace-binding-r2; source is clean.

Independent findings

B1 — Blocking implementation regression. All four frozen M20-heritage-class-{bracket,dot,named,default} controls lose the existing consumer_run → helper_dispatch call at source line 3. For example:

import * as ns from './helper.js';
export function run() {
  const Box = class extends (ns["dispatch"]()) {};
}

The new index marks heritage wrappers nonexecuting, then restores only the child expression's environment. The emission visitor returns at an unmapped wrapper before reaching the runtime call (cross-file.ts:1954, 1989, 2243). These controls passed on the predecessor. They test structural extraction; their helper returns 1, so they do not claim successful runtime class construction. Existing graph owners must be preserved.

B2 — Blocking error in our frozen expectation. M20-decorator-object-bracket expects an imported call from:

const obj = { @ns["dispatch"]() read(ns:any){} };

Pinned TypeScript parses this into decorator @ns and a separate array-literal call ["dispatch"](), with six parse diagnostics. No eligible ns["dispatch"]() call exists. The absent imported edge is correct for those parsed bytes. This is an invalid oracle, not a fifth implementation omission. The author and pre-freeze audit missed it; it was already red in the old-source observation. All frozen expectations remain unchanged. Satisfying this expectation by inventing an edge would violate the contract.

B3 — Required validation is red and incomplete. The author focused run exited 1: 1,118 passed / five failed, seven passing files and one failing file. The fresh reviewer independently reproduced five failed / 791 filtered out through the unchanged guarded entrypoint:

npm run test:run -- tests/unit/extract-import-binding-identity.test.ts -t 'M20-(heritage-class-(bracket|dot|named|default)|decorator-object-bracket)'

The review used Node 22.22.3 and TypeScript 6.0.3, a physical scratch copy, isolated child configuration/cache, and normal process visibility. Its test command ran from 08:44:09.293490 to 08:44:13.162422 UTC on 2026-09-05, exit 1. Its independent AST command exited 0. Later assertions after the failed call check were not executed and are not claimed as observed provenance results.

Typecheck passed. Successor build, actual public CLI, real version-68/69 cache migrations and second unchanged update, mutations, the five-file worker diagnostic, and the complete required suite were not run after the stop. Synthetic cache and in-process public tests do not replace these gates. No new worker-start occurrence was observed; #710's history remains unchanged.

No separate B4 scope expansion was found. Production edits remain inside the existing cross-file linker/local helpers and cache version 70; shared export-map, graph-node construction, dependencies and test-runner configuration are unchanged.

Evidence and disposition

Fresh reviewer: 01a070b9-3730-7301-9f53-a16c61afa82c, separate from author and design sessions. The reviewer returned IMPLEMENTATION-HOLD; its CLI completed with exit 0 at 2026-09-05T08:52:09.868170+00:00.

• All 30 frozen entries remain byte-identical.
• All 1,294 successor manifest entries verify. The typecheck and failed focused run bind all 882 recorded input files to the delivered commit.
• After review exit, all 63 review artifacts, 3,178 primary inputs and one workflow input verify.
• The predecessor's 1,119 sealed entries and design's 10 artifacts plus 47 readonly inputs remain unchanged. Two additional old external references contain base hashes at worktree paths now holding exact rejected-commit bytes; both versions are recoverable from Git. This historical reference limitation is retained explicitly.

Retained artifacts are under this task's outputs/implementation-739-r2/: DECISION.md, IMPLEMENTATION-REPORT.md, CANDIDATE.json, EVIDENCE-MANIFEST.json, REVIEW-LEAD-VERIFICATION.json, and review/{REVIEW.md,COMMAND-RECORD.json,EVIDENCE-MANIFEST.json}. Reproduction files and frozen controls remain under work/739-r2/evidence/; independent reproduction remains under work/739-r2/review/.

• Author manifest SHA256: b9179073e76a6732e6e5c2bdb802c390e440ae1c021e5be6854a6a0267dc5861
• Review report SHA256: 196163a2977eb413fb8b522d2ff821610b7c917624ab434cfdcfbb90bd605f1e
• Review manifest SHA256: 07f72762c4c71f8b672936aabc0ddc0eb0d5d642646872e25e447d0e39cd023f
• Frozen controls SHA256: c2060e0772f70a5a34e72f025c7fe7028208471d91995de86e33eaea6de600c3

This is the second finding in the same import-binding mechanism; changing the failing syntax does not reset that history. The posted contract states: “One general correction is allowed after reassessment; another same-boundary miss stops this mechanism again.” That stop now applies.

Proposed next decision, not another coding authorization: explicitly replace/reclassify the invalid positive in a new recorded control version; require eligible parsed-call evidence before freezing positive expectations; reassess how the binding index preserves traversal through runtime/type wrappers; and review the revised concrete controls/model before another author run. Preserve the original freeze and all failed candidates. All outstanding public/cache and guarded validation requirements remain.

The design was plausible; this implementation did not satisfy it. Madar's intended product result remains unproved. No push, PR, merge, release, new issue, issue closure, product benchmark or historical #735–#738 disposition change occurred.