[Ancienttwo]

Refs #574 · Tier Medium (one GPT review) · slice S1b (joint decision "parallelizing the remaining issues", item 3)

Move-only split of packages/local-runtime/codegraph-adapter/src/index.ts (2226 lines) by responsibility. Base: main 449b61b (S1, #589).

Goal

Give S2+S3, S4 and S5 their own modules so they can run in parallel, one writer per file. Behavior does not change.

Change: what moved where

Every top-level declaration is copied verbatim, in its original relative order. The only edits are moving declarations, adding imports and exports between the new modules, adding export to 17 moved declarations that another module now imports, and dropping imports that became unused. No logic edit, rename, signature change or reorder inside a body.

Module	Contents
cli-provider.ts (397)	telemetry env (CODEGRAPH_TELEMETRY_*, disableCodeGraphTelemetryByDefault, MutableEnv), DEFAULT_CODEGRAPH_BINARY, requireFromAdapter, CLI output/timeout limits, CodeGraphProvider, CodeGraphCliProvider, CodeGraphCliInvocation, packagedCodeGraphCliInvocation, codeGraphCliInvocation, resolveExecutable, isExecutablePath, resolvePackagedCodeGraphShim, packagedCodeGraphRuntimeDigest, isNodeRuntimeScript, readFilePrefix, runCodeGraphCli, the output parsers (CodeGraphCliNode, syntheticSymbolId, normalizeCliNode, scopedTaskQuery, parseNodeTrail, trailEntries, uniqueSymbols, uniqueEdges, parseExploreSymbols), digestFile
repository-code-facts.ts (224)	RepositoryCodeFactsPendingChangesV1, RepositoryCodeFactsV1, REPOSITORY_CODE_FACTS_SCHEMA … assertRepositoryCodeFactsReady, codeGraphIndexAvailable
projection-handshake.ts (465)	the projection section comment, CodeGraphProjectionStatusV1, CodeGraphProjectionHandshakeV1, PreparedProjectionCodeFacts, PreparedArchitectureDocumentationProjectionSnapshot, prepareArchitectureDocumentationProjectionSnapshot … runProjectionCodeGraph (code facts, status issues, status digest)
snapshot.ts (298)	codeGraphSnapshotRuntime, codeGraphSourceScanner, CODEGRAPH_SNAPSHOT_*, codeGraphSnapshotQueries, withExistingCodeGraphSnapshot, assertSnapshotGitReadSafety, pinSnapshotHooks, mirrorCodeGraphInputs
import-population.ts (281)	CODEGRAPH_IMPORT_NODE_READ_LIMIT, CODEGRAPH_IMPORT_NODE_OUTPUT_BYTES, SOURCE_EXTENSIONS, importQuery, importEdgesFromQueryNodes, resolvedImportPairs, resolveImportTarget, importTargetCandidates, fileSymbolId, normalizeChangedPaths, uniqueStrings, ProjectionImportPopulationV1, RepositoryImportPair(s)V1, repositoryImportPairs, importPairsOf, statusImportNodeCount, codeGraphImportPopulation, capabilityImportGraphs
selector-index.ts (372)	codeGraphSdk, CapabilityCodeGraphProjectionInputs, CodeGraphSelectorIndex, CODEGRAPH_NO_DOWNLOAD_ENV, the symbol-reader types, NON_DECLARATION_KINDS, openCodeGraphSymbolReader, indexedDeclaration, memoizedSourceDeclarations, loadCapabilityCodeGraphProjectionInputs, RUNTIME_BUILTIN_CALL_NAMES, exactSelectorEvidence, indexedSymbolsAt, edgeSites, isFalseBuiltinCall, normalizedIndexPath
index.ts (309)	CodeGraphAdapter, LandscapeContextInput, MultiRepoCodeGraphAdapter, assertNoCodeGraphInternalPathAccess, architectureDeltaTask, and explicit re-exports of the same 64 public names

Boundary adjustments (one shared symbol each, placed with its main user):

• digestFile → cli-provider.ts. packagedCodeGraphRuntimeDigest calls it 4 times and prepareProjectionCodeFacts once.
• normalizeChangedPaths and uniqueStrings → import-population.ts (importQuery uses both), not index.ts. That way no module imports the index.ts barrel, which re-exports all of them. CodeGraphAdapter and architectureDeltaTask import them from there.
• CodeGraphProvider → cli-provider.ts, next to its implementation, for the same reason.
• Small helpers used only by one module go with it: codeGraphSdk → selector-index, codeGraphSourceScanner → snapshot, CODEGRAPH_NO_DOWNLOAD_ENV → selector-index (only loadCapabilityCodeGraphProjectionInputs reads it), and SOURCE_EXTENSIONS and fileSymbolId → import-population.

read-session.ts, snapshot-query.ts, child-env.ts and ref-impact-facts.ts are not touched. No test file is changed. Every test imports ../src/index or the package entry. Test budget: 0 test lines.

Evidence

Move-only proof

The script below is run from the repository root as node move-only-proof.mjs origin/main. It is not committed, because the write scope is src/ only. It checks two things:

1. Diff check. Every line removed from index.ts appears verbatim in a changed src/ file. A moved declaration may gain a leading export . No other line is added. Import statements, export { } from statements and blank lines are ignored. It also asserts that index.ts is the only modified file and every other changed file is new.
2. Block check. Each of the 118 top-level blocks of the old index.ts (one declaration with its leading comment) appears as one contiguous run in exactly one file. So no body was edited or reordered.

A tamper test changed timeout: 5_000 to 6_000 in one moved function, and the script reports FAIL on both checks.

base origin/main (449b61b3)
changed files: A cli-provider.ts, A import-population.ts, M index.ts, A projection-handshake.ts, A repository-code-facts.ts, A selector-index.ts, A snapshot.ts
diff: 1981 lines removed from index.ts, 2101 lines added under src/
  ignored: 40 removed import/export lines, 158 added import/export lines, 232 blank lines
  moved verbatim: 1826 of 1826 removed code lines
  'export ' added to 17 moved declarations:
    cli-provider.ts:16 export const DEFAULT_CODEGRAPH_BINARY = "codegraph";
    cli-provider.ts:20 export const CODEGRAPH_OUTPUT_MAX_BYTES = 32 * 1024 * 1024;
    cli-provider.ts:21 export const CODEGRAPH_QUERY_TIMEOUT_MS = 30_000;
    cli-provider.ts:190 export function isExecutablePath(path: string): boolean {
    cli-provider.ts:221 export function packagedCodeGraphRuntimeDigest(): string {
    cli-provider.ts:280 export interface CodeGraphCliNode {
    cli-provider.ts:358 export function digestFile(path: string): string {
    cli-provider.ts:366 export function runCodeGraphCli(binary: string, workspaceRoot: string, a
    import-population.ts:10 export function importQuery(changedPaths: string[]): string | undefined 
    import-population.ts:16 export function importEdgesFromQueryNodes(gitVisibleFiles: ReadonlySet<s
    import-population.ts:44 export function resolveImportTarget(gitVisibleFiles: ReadonlySet<string>
    import-population.ts:63 export function normalizeChangedPaths(paths: string[]): string[] {
    import-population.ts:70 export function uniqueStrings(items: string[]): string[] {
    import-population.ts:199 export function statusImportNodeCount(status: CodeGraphProjectionStatusV
    import-population.ts:242 export function capabilityImportGraphs(
    projection-handshake.ts:321 export function readProjectionCodeGraphStatus(
    selector-index.ts:370 export function normalizedIndexPath(path: string): string {
  removed lines not found in any new file: 0
  added lines that are not moved lines: 0
blocks: 118 top-level blocks of the old index.ts, each found contiguous in exactly one file: true
  cli-provider.ts: 30
  import-population.ts: 19
  index.ts: 5
  projection-handshake.ts: 21
  repository-code-facts.ts: 14
  selector-index.ts: 20
  snapshot.ts: 9
MOVE-ONLY: PASS

move-only-proof.mjs

#!/usr/bin/env node
// Move-only proof for the #574 S1b split of codegraph-adapter/src/index.ts.
// Usage: node move-only-proof.mjs <base-ref>   (run from the repository root)
// 1. Diff check: every line removed from index.ts is added verbatim in src/ (a moved declaration
//    may gain a leading `export `), and no other line is added. Import statements, `export { } from`
//    re-export statements and blank lines are ignored.
// 2. Block check: every top-level block of the old index.ts (a declaration with its leading comment)
//    appears as one contiguous run in exactly one file under src/, so no body was edited or reordered.
import { execFileSync } from "node:child_process";
import { readFileSync } from "node:fs";

const base = process.argv[2] ?? "origin/main";
const dir = "packages/local-runtime/codegraph-adapter/src";
const git = (...args) => execFileSync("git", args, { encoding: "utf8", maxBuffer: 64 << 20 });
const oldIndex = git("show", `${base}:${dir}/index.ts`).split("\n");
const changed = git("diff", "--name-status", "--no-renames", base, "--", dir).trim().split("\n").map((line) => line.split("\t"));
// Only index.ts may change; every other changed file must be new. read-session.ts, snapshot-query.ts,
// child-env.ts and ref-impact-facts.ts stay untouched.
for (const [status, path] of changed) {
  if (!(status === "M" && path === `${dir}/index.ts`) && status !== "A") throw new Error(`unexpected change: ${status} ${path}`);
}
const files = Object.fromEntries(changed.map(([, path]) => [path, readFileSync(path, "utf8").split("\n")]));

/** Line numbers (1-based) that belong to an import statement or an `export { ... } from` statement. */
function importExportLines(lines) {
  const marked = new Set();
  for (let i = 0; i < lines.length; i++) {
    if (!/^(import\b|export \{|export type \{|export \* from)/.test(lines[i])) continue;
    let j = i;
    while (!/;\s*$/.test(lines[j])) j++;
    if (lines[i].startsWith("export") && !/\bfrom\s+"[^"]+";\s*$/.test(lines[j])) continue;
    for (let k = i; k <= j; k++) marked.add(k + 1);
    i = j;
  }
  return marked;
}

// --- 1. Diff check -------------------------------------------------------------------------
const diff = git("diff", "--no-color", "--no-renames", "-U0", base, "--", dir);
const removed = [];
const added = [];
let file, oldLine, newLine;
for (const line of diff.split("\n")) {
  if (line.startsWith("+++ ")) { file = line.slice(4).replace(/^b\//, ""); continue; }
  if (line.startsWith("--- ")) continue;
  const hunk = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
  if (hunk) { oldLine = Number(hunk[1]); newLine = Number(hunk[2]); continue; }
  if (line.startsWith("-")) removed.push({ file, n: oldLine++, text: line.slice(1) });
  else if (line.startsWith("+")) added.push({ file, n: newLine++, text: line.slice(1) });
}
const oldMarks = importExportLines(oldIndex);
const newMarks = Object.fromEntries(Object.entries(files).map(([f, lines]) => [f, importExportLines(lines)]));
const notes = { removedImportExport: 0, addedImportExport: 0, blank: 0, exportAdded: [] };
const pool = new Map();
for (const r of removed) {
  if (r.file !== "/dev/null" && !r.file.endsWith("/index.ts")) throw new Error(`unexpected removal in ${r.file}`);
  if (!r.text.trim()) { notes.blank++; continue; }
  if (oldMarks.has(r.n)) { notes.removedImportExport++; continue; }
  pool.set(r.text, (pool.get(r.text) ?? 0) + 1);
}
const removedCount = [...pool.values()].reduce((a, b) => a + b, 0);
const take = (text) => {
  const count = pool.get(text) ?? 0;
  if (count === 0) return false;
  count === 1 ? pool.delete(text) : pool.set(text, count - 1);
  return true;
};
const unexplained = [];
for (const a of added) {
  if (!a.text.trim()) { notes.blank++; continue; }
  if (newMarks[a.file]?.has(a.n)) { notes.addedImportExport++; continue; }
  if (take(a.text)) continue;
  if (a.text.startsWith("export ") && take(a.text.slice("export ".length))) { notes.exportAdded.push(`${a.file.split("/").pop()}:${a.n} ${a.text.slice(0, 72)}`); continue; }
  unexplained.push(`${a.file}:${a.n}: ${a.text}`);
}
const missing = [...pool.entries()].map(([text, count]) => `${count}x ${text}`);

// --- 2. Block check ------------------------------------------------------------------------
const body = oldIndex.map((text, i) => ({ text, n: i + 1 })).filter(({ n }) => !oldMarks.has(n));
const blocks = [];
for (let i = 0; i < body.length; i++) {
  const { text } = body[i];
  // A block starts at column 0 after a blank line, or at a declaration or comment opener that does
  // not continue a leading comment, so adjacent one-line declarations are separate blocks.
  const previous = i === 0 ? "" : body[i - 1].text;
  const startsBlock = text.trim() && /^[^\s})\]]/.test(text)
    && (!previous.trim() || (/^(export |const |let |function |async function |class |type |interface |\/\*\*|\/\/)/.test(text) && !/^(\/\*\*|\s\*|\/\/)/.test(previous)));
  if (startsBlock) blocks.push([]);
  if (blocks.length && (text.trim() || blocks.at(-1).length)) blocks.at(-1).push(body[i].text);
}
for (const block of blocks) while (block.length && !block.at(-1).trim()) block.pop();
const sameLine = (actual, expected) => actual === expected || actual === `export ${expected}`;
const blockFailures = [];
const placement = {};
for (const block of blocks) {
  const hits = [];
  for (const [f, lines] of Object.entries(files)) {
    for (let i = 0; i + block.length <= lines.length; i++) {
      if (block.every((expected, k) => sameLine(lines[i + k], expected))) hits.push(f);
    }
  }
  if (hits.length !== 1) blockFailures.push(`${hits.length} placements: ${block[0]}`);
  else placement[hits[0].split("/").pop()] = (placement[hits[0].split("/").pop()] ?? 0) + 1;
}

console.log(`base ${base} (${git("rev-parse", "--short", base).trim()})`);
console.log(`changed files: ${changed.map(([status, path]) => `${status} ${path.split("/").pop()}`).join(", ")}`);
console.log(`diff: ${removed.length} lines removed from index.ts, ${added.length} lines added under src/`);
console.log(`  ignored: ${notes.removedImportExport} removed import/export lines, ${notes.addedImportExport} added import/export lines, ${notes.blank} blank lines`);
console.log(`  moved verbatim: ${removedCount - missing.length} of ${removedCount} removed code lines`);
console.log(`  'export ' added to ${notes.exportAdded.length} moved declarations:`);
for (const note of notes.exportAdded) console.log(`    ${note}`);
console.log(`  removed lines not found in any new file: ${missing.length}`);
for (const m of missing) console.log(`    ${m}`);
console.log(`  added lines that are not moved lines: ${unexplained.length}`);
for (const u of unexplained) console.log(`    ${u}`);
console.log(`blocks: ${blocks.length} top-level blocks of the old index.ts, each found contiguous in exactly one file: ${blockFailures.length === 0}`);
for (const [f, count] of Object.entries(placement).sort()) console.log(`  ${f}: ${count}`);
for (const failure of blockFailures) console.log(`  FAIL ${failure}`);
const ok = missing.length === 0 && unexplained.length === 0 && blockFailures.length === 0;
console.log(ok ? "MOVE-ONLY: PASS" : "MOVE-ONLY: FAIL");
process.exit(ok ? 0 : 1);

git diff --color-moved=zebra --stat origin/main:

 .../codegraph-adapter/src/cli-provider.ts          |  397 ++++
 .../codegraph-adapter/src/import-population.ts     |  281 +++
 .../local-runtime/codegraph-adapter/src/index.ts   | 2045 +-------------------
 .../codegraph-adapter/src/projection-handshake.ts  |  465 +++++
 .../codegraph-adapter/src/repository-code-facts.ts |  224 +++
 .../codegraph-adapter/src/selector-index.ts        |  372 ++++
 .../codegraph-adapter/src/snapshot.ts              |  298 +++
 7 files changed, 2101 insertions(+), 1981 deletions(-)

With --color-moved=zebra, 1960 added and 1947 removed lines are coloured as moved. The lines that are not are imports and re-exports, blank lines, the 17 export prefixes, and the 3-line uniqueStrings body, which is below git's moved-block minimum.

Public export list is unchanged

The TS checker's getExportsOfModule(index.ts) gives the same 64 names before (449b61b) and after: diff exports-before.txt exports-after.txt is empty. The runtime Object.keys(await import(index.ts)) also matches: 36 value exports.

the 64 exports (name, kind)

CODEGRAPH_IMPORT_NODE_READ_LIMIT	value
CODEGRAPH_PROVIDER_INTERNAL_EXPORTS	value
CODEGRAPH_SNAPSHOT_MAX_BYTES	value
CODEGRAPH_SNAPSHOT_MAX_ENTRIES	value
CODEGRAPH_TELEMETRY_DISABLED_VALUE	value
CODEGRAPH_TELEMETRY_ENV	value
CapabilityCodeGraphProjectionInputs	type
CodeGraphAdapter	value
CodeGraphCallee	type
CodeGraphCliInvocation	type
CodeGraphCliProvider	value
CodeGraphIndexCompatibilityV1	type
CodeGraphIndexFreshnessV1	type
CodeGraphIndexRevisionV1	type
CodeGraphIndexedDeclaration	type
CodeGraphProjectionHandshakeV1	type
CodeGraphProjectionStatusV1	type
CodeGraphProvider	type
CodeGraphProviderUnavailableError	value
CodeGraphReadProvider	type
CodeGraphReadSession	type
CodeGraphReadSessionOpenV1	type
CodeGraphSelectorIndex	type
CodeGraphSymbolDeclaration	type
CodeGraphSymbolReader	type
CodeGraphSymbolReaderResult	type
LandscapeContextInput	type
MultiRepoCodeGraphAdapter	value
PreparedArchitectureDocumentationProjectionSnapshot	type
PreparedProjectionCodeFacts	type
ProjectionCodeFactsUnavailableError	value
ProjectionCodeGraphStatusIssueCode	type
ProjectionCodeGraphStatusIssueV1	type
ProjectionImportPopulationV1	type
REQUIRED_CODEGRAPH_PACKAGE	value
REQUIRED_CODEGRAPH_VERSION	value
RUNTIME_BUILTIN_CALL_NAMES	value
RepositoryCodeFactsInspectionOptions	type
RepositoryCodeFactsPendingChangesV1	type
RepositoryCodeFactsV1	type
RepositoryImportPairV1	type
RepositoryImportPairsV1	type
assertNoCodeGraphInternalPathAccess	value
assertProjectionCodeFactsAvailable	value
assertRepositoryCodeFactsReady	value
codeGraphCliInvocation	value
codeGraphIndexAvailable	value
codeGraphSnapshotQueries	value
codeGraphSnapshotRuntime	value
disableCodeGraphTelemetryByDefault	value
inspectRepositoryCodeFacts	value
loadCapabilityCodeGraphProjectionInputs	value
memoizedSourceDeclarations	value
openCodeGraphReadSession	value
openCodeGraphSymbolReader	value
packagedCodeGraphCliInvocation	value
pinnedCodeGraphProvider	value
prepareArchitectureDocumentationProjectionSnapshot	value
prepareProjectionCodeFacts	value
projectionCodeFactsRequired	value
projectionCodeGraphStatusIssues	value
repositoryImportPairs	value
withCodeGraphReadSession	value
withExistingCodeGraphSnapshot	value

Checks (Bun 1.4.4, macOS arm64)

• bun run typecheck: pass. tsc --noEmit --noUnusedLocals reports nothing in codegraph-adapter/src, so no import is left unused.
• bun test packages/local-runtime/codegraph-adapter: 113 pass, 0 fail (8 files).
• bun test packages/local-runtime/runtime-daemon: 855 pass, 1 skip, 0 fail (47 files).
• bun test packages/surfaces/cli: 312 pass, 0 fail (29 files).
• bun test on core/application/test/control-loop.test.ts, core/context-compiler/test/context-compiler.test.ts, tests/projection-prior-committed-applies.test.ts and tests/ownership-change-acceptance-recovery.test.ts (the other direct importers): 25 pass, 0 fail.
• bun run test:codegraph-selector-node: verified. It bundles src/index.ts for Node and checks the selectors, the snapshot and the read session.
• node scripts/package-boundary-audit.mjs and node scripts/production-mock-reachability-audit.mjs: pass.

Risk

• Import cycles between the new modules. cli-provider ↔ import-population, repository-code-facts ↔ projection-handshake, and import-population → projection-handshake → selector-index → import-population are cycles. They follow from the agreed boundaries; in the single file these were all forward references. They are safe because no module reads an imported binding at evaluation time. Every top-level initializer is a literal, a node:/@archcontext/contracts value or createRequire(import.meta.url). Cross-module references sit only in function bodies, class members and default parameters. The Bun runtime (all suites above) and the Bun-built Node bundle (test:codegraph-selector-node) both load them.
• requireFromAdapter = createRequire(import.meta.url) now lives in cli-provider.ts. That file is in the same directory, so package resolution is unchanged.
• 17 formerly private helpers are now exported from their module, so the new modules can use them. index.ts does not re-export them, so the package's public surface is unchanged.

Rollback

Revert this single commit. No data, schema, contract or test changes.

[chatgpt-codex-connector]

Codex Review Summary: ❌ Failed

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	❌ Failed 2026-11-13T19:22:54.202936Z We couldn’t complete this review. Comment @codex review to try again.	d5ac750	PR opened

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, add credits to your account and enable them for code reviews in your settings.

[Ancienttwo]

repo-harness acceptance claim
Role: acceptor
Round: 1
Subject: d5ac750
Tier: medium
Agent: codex (gpt-6.1-terra), read-only

[Ancienttwo]

repo-harness acceptance review
Round: 1
Subject: d5ac750
Tier: medium
Verdict: PASS
Reviewer: codex (gpt-6.1-terra)
Model relation: different-family

Independent move-only check against 449b61b. A normalized diff comparison found 1,826 removed and 1,826 added code lines with no unmatched line, and the zebra diff identifies the moved blocks. The same 64 public export names and type/value classifications appear before and after, and the package export is unchanged. The new modules have import cycles, but no cyclic binding is read during module initialization. Only the seven codegraph-adapter/src files changed; git diff --check passes.

NITs

None.

[Ancienttwo]

repo-harness acceptance record
Claim: #596 (comment)

Round	Role	Subject	Verdict
1	codex (gpt-6.1-terra), read-only	d5ac75094f612b5748d0e805d62fc282482e5659	PASS: none

Model relation: different-family

Findings:

• none

[Ancienttwo]

Joint decision (orchestrator + advisor), 2026-11-14: merge #596 (#574 S1b) at d5ac750 onto main 449b61b. All 35 checks pass. GPT PASS: an independent normalized check found 1826 removed and 1826 added code lines with none unmatched, and the 64 export names are identical (596#issuecomment-6862759587). The chatgpt-codex-connector summary failed on the Codex usage limit and left no inline finding.

Seat: orchestrator t7