@nomos-arc/arc 0.1.0

package/src/core/config.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'node:os';
+import { NomosError } from './errors.js';
+import type { NomosConfig } from '../types/index.js';
+
+// ── Per-binary defaults ──────────────────────────────────────────────────────
+// IMPORTANT: planner and reviewer have DIFFERENT defaults.
+// Using z.object().default({}) at each nested level performs shallow merge ONLY at
+// the top sub-object level. To correctly deep-merge a partial user config (e.g., only
+// providing `cmd`), every individual field must carry its own .default() value.
+// This ensures `{ cmd: 'my-claude' }` correctly inherits pty: true, timeouts, etc.
+//
+// Zod v4 note: .default() on z.object() requires the OUTPUT type as the default value,
+// not the input type. We use factory functions `() => SubSchema.parse({})` so TypeScript
+// is satisfied while preserving identical runtime behavior to the spec's `.default({})`.
+
+const PlannerBinarySchema = z.object({
+  cmd: z.string().default('claude'),
+  args: z.array(z.string()).default([]),
+  pty: z.boolean().default(true),
+  total_timeout_ms: z.number().positive().default(300000),
+  heartbeat_timeout_ms: z.number().positive().default(120000),
+  max_output_bytes: z.number().positive().default(1048576),
+  usage_pattern: z.string().nullable().default('Tokens used:\\s*(\\d+)'),
+});
+
+const ReviewerBinarySchema = z.object({
+  cmd: z.string().default('codex'),
+  args: z.array(z.string()).default(['-q', '--full-auto']),
+  pty: z.boolean().default(false),
+  total_timeout_ms: z.number().positive().default(120000),
+  heartbeat_timeout_ms: z.number().positive().default(120000),
+  max_output_bytes: z.number().positive().default(524288),
+  usage_pattern: z.string().nullable().default(null),
+});
+
+const ExecutionSchema = z.object({
+  default_mode: z.enum(['supervised', 'dry-run']).default('supervised'),
+  shadow_branch_prefix: z.string().default('nomos/'),
+  worktree_base: z.string().default('/tmp/nomos-worktrees/'),
+  supervised_heartbeat_timeout_ms: z.number().positive().default(300000),
+});
+
+const BinariesSchema = z.object({
+  planner: PlannerBinarySchema.default(() => PlannerBinarySchema.parse({})),
+  reviewer: ReviewerBinarySchema.default(() => ReviewerBinarySchema.parse({})),
+});
+
+const ConvergenceSchema = z.object({
+  score_threshold: z.number().min(0).max(1).default(0.9),
+  max_iterations: z.number().int().positive().default(3),
+});
+
+const BudgetSchema = z.object({
+  max_tokens_per_task: z.number().positive().default(100000),
+  warn_at_percent: z.number().min(0).max(100).default(80),
+  // RT2-4.3 fix: cost_per_1k_tokens supports both flat number (backward compat,
+  // treated as output rate with input = rate/5) and { input, output } objects.
+  cost_per_1k_tokens: z.record(z.string(), z.union([
+    z.number(),
+    z.object({ input: z.number(), output: z.number() }),
+  ])).default({
+    claude: { input: 0.003, output: 0.015 },
+    codex: { input: 0.0005, output: 0.002 },
+  }),
+});
+
+const SecuritySchema = z.object({
+  sanitize_patterns: z.array(z.string()).default([]),
+  entropy_threshold: z.number().positive().default(4.5),
+  sanitize_on: z.array(z.enum(['input', 'output'])).default(['input']),
+  safe_commands: z.array(z.string()).default([]),
+  redaction_label: z.string().default('[REDACTED]'),
+});
+
+const GitSchema = z.object({
+  auto_commit: z.boolean().default(true),
+  include_logs: z.boolean().default(false),
+  commit_prefix: z.string().default('[nomos]'),
+  sign_commits: z.boolean().default(false),
+});
+
+const ReviewSchema = z.object({
+  max_context_files: z.number().int().positive().default(5),
+  // Budget note: each affected file adds ~50 lines to the reviewer prompt.
+  // At default 5 files this is roughly 250 extra lines (~1500 tokens).
+  // Tune downward if reviewer token costs are a concern.
+});
+
+const LoggingSchema = z.object({
+  level: z.string().default('info'),
+  retain_days: z.number().positive().default(30),
+});
+
+const SearchConfigSchema = z.object({
+  embedding_model: z.string().default('gemini-embedding-001'),
+  embedding_dimensions: z.number().int().positive().default(768),
+  vector_store_path: z.string().default('tasks-management/graph/vector_index'),
+  default_top_k: z.number().int().positive().default(5),
+  default_threshold: z.number().min(0).max(1).default(0.7),
+  batch_size: z.number().int().positive().max(100).default(50),
+  embedding_requests_per_minute: z.number().int().positive().default(300),
+  request_timeout_ms: z.number().int().positive().default(30_000),
+});
+
+const AuthSchema = z.object({
+  client_id: z.string().optional(),
+  // SECURITY: client_secret intentionally excluded from project config.
+  // Project config (.nomos-config.json) is committed to git — secrets must not live here.
+  // Resolution order: NOMOS_GOOGLE_CLIENT_SECRET env var → interactive prompt → ~/.nomos/credentials.json (saved after first login).
+  credentials_path: z.string().default(
+    path.join(os.homedir(), '.nomos', 'credentials.json'),
+  ),
+  redirect_port: z.number().int().positive().default(3000),
+});
+
+const GraphConfigSchema = z.object({
+  exclude_patterns: z.array(z.string()).default(['node_modules', 'dist', '*.test.*', '*.spec.*', '*.semantic.md']),
+  ai_enrichment: z.boolean().default(true),
+  ai_model: z.string().default('gemini-1.5-flash'),
+  ai_concurrency: z.number().int().positive().default(5),
+  ai_requests_per_minute: z.number().int().positive().default(14),
+  max_file_chars: z.number().positive().default(4000),
+  core_modules_count: z.number().int().positive().default(10),
+  output_dir: z.string().default('tasks-management/graph'),
+});
+
+export const NomosConfigSchema = z.object({
+  execution: ExecutionSchema.default(() => ExecutionSchema.parse({})),
+  binaries: BinariesSchema.default(() => BinariesSchema.parse({})),
+  convergence: ConvergenceSchema.default(() => ConvergenceSchema.parse({})),
+  budget: BudgetSchema.default(() => BudgetSchema.parse({})),
+  security: SecuritySchema.default(() => SecuritySchema.parse({})),
+  git: GitSchema.default(() => GitSchema.parse({})),
+  review: ReviewSchema.default(() => ReviewSchema.parse({})),
+  graph: GraphConfigSchema.default(() => GraphConfigSchema.parse({})),
+  logging: LoggingSchema.default(() => LoggingSchema.parse({})),
+  search: SearchConfigSchema.default(() => SearchConfigSchema.parse({})),
+  auth: AuthSchema.default(() => AuthSchema.parse({})),
+});
+
+/**
+ * Returns a fully-defaulted NomosConfig by parsing an empty object through the Zod schema.
+ * Every field receives its default value. Used by `arc init` (no config file exists yet)
+ * and in tests that need a baseline config without a file on disk.
+ *
+ * RTV-3 fix: This function was referenced in factory.ts but never defined.
+ */
+export function getDefaultConfig(): NomosConfig {
+  return NomosConfigSchema.parse({}) as NomosConfig;
+}
+
+/**
+ * Walk from startDir up to filesystem root looking for `.nomos-config.json`.
+ * Returns the absolute path to the config file if found.
+ * Throws NomosError('config_not_found') if not found at any level.
+ */
+export function findConfigFile(startDir: string): string {
+  const resolvedStart = fs.realpathSync(startDir);
+  let current = resolvedStart;
+
+  while (true) {
+    const candidate = path.join(current, '.nomos-config.json');
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      // Reached filesystem root — not found
+      throw new NomosError(
+        'config_not_found',
+        'No .nomos-config.json found. Run: arc init to scaffold a new project.',
+      );
+    }
+    current = parent;
+  }
+}
+
+/**
+ * Load and validate the nomos-arc config, starting the walk-up from startDir.
+ * Returns the parsed config and the project root directory (directory containing
+ * the config file).
+ */
+export function loadConfig(startDir?: string): { config: NomosConfig; projectRoot: string } {
+  const configPath = findConfigFile(startDir ?? process.cwd());
+  const projectRoot = path.dirname(configPath);
+
+  let raw: unknown;
+  try {
+    raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  } catch (err) {
+    throw new NomosError(
+      'config_invalid',
+      `Failed to read .nomos-config.json: ${String(err)}`,
+    );
+  }
+
+  const result = NomosConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const fieldPaths = result.error.issues
+      .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+      .join('; ');
+    throw new NomosError(
+      'config_invalid',
+      `Invalid .nomos-config.json — ${fieldPaths}`,
+    );
+  }
+
+  return { config: result.data as NomosConfig, projectRoot };
+}

package/src/core/errors.ts

@@ -0,0 +1,54 @@
+export type NomosErrorCode =
+  | 'config_not_found'
+  | 'config_invalid'
+  | 'binary_not_found'
+  | 'task_not_found'
+  | 'task_exists'
+  | 'invalid_transition'
+  | 'state_locked'
+  | 'convergence_failed'
+  | 'review_failed'
+  | 'budget_exceeded'
+  | 'no_tty'
+  | 'worktree_creation_failed'
+  | 'worktree_missing'
+  | 'worktree_unrecoverable'
+  | 'branch_exists'
+  | 'wrong_branch'
+  | 'dirty_working_tree'
+  | 'path_traversal'
+  | 'state_migration_failed'
+  | 'invalid_frontmatter'
+  | 'rules_missing'
+  | 'no_changes'
+  | 'secrets_detected'          // RT2-5.1 fix: context_files contain secrets
+  | 'base_commit_unreachable'   // RT2-2.1 fix: baseCommit SHA orphaned after rebase
+  | 'certificate_not_eligible'  // task status not approved/merged
+  | 'certificate_not_found'     // certificate file not found for --verify
+  | 'certificate_invalid'       // certificate failed validation or parsing
+  | 'graph_map_not_found'
+  | 'graph_parse_error'
+  | 'graph_ai_key_missing'
+  | 'graph_write_failed'
+  | 'drift_baseline_not_found'
+  | 'drift_parse_error'
+  | 'search_index_not_found'
+  | 'search_index_failed'
+  | 'search_index_corrupted'
+  | 'search_embedding_failed'
+  | 'search_query_failed'
+  | 'search_api_key_missing'
+  | 'auth_not_logged_in'
+  | 'auth_token_expired'
+  | 'auth_login_failed'
+  | 'auth_client_config_missing';
+
+export class NomosError extends Error {
+  constructor(
+    public readonly code: NomosErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'NomosError';
+  }
+}

package/src/core/factory.ts

@@ -0,0 +1,49 @@
+import * as path from 'path';
+import { createLogger } from './logger.js';
+import { loadConfig, NomosConfigSchema } from './config.js';
+import { StateManager } from './state.js';
+import { GitAdapter } from '../adapters/git.js';
+import { PtyAdapter } from '../adapters/pty.js';
+import { StdioAdapter } from '../adapters/stdio.js';
+import { Orchestrator } from './orchestrator.js';
+import type { NomosConfig } from '../types/index.js';
+
+export async function createOrchestrator(options?: {
+  skipConfig?: boolean;
+  projectRoot?: string;  // E5 fix: explicit root avoids process.chdir() in tests
+}): Promise<{ orchestrator: Orchestrator; config: NomosConfig; projectRoot: string }> {
+
+  if (options?.skipConfig) {
+    // arc init (project scaffold) — no config file exists yet.
+    // RTV-3 fix: use NomosConfigSchema.parse({}) instead of the previously-undefined getDefaultConfig()
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const config = NomosConfigSchema.parse({}) as NomosConfig;
+    const logger = createLogger('info');
+    const stateDir = path.join(projectRoot, 'tasks-management', 'state');
+    const stateManager = new StateManager(stateDir, logger);
+    const gitAdapter = new GitAdapter(projectRoot, config, logger);
+    const ptyAdapter = new PtyAdapter(logger);
+    const stdioAdapter = new StdioAdapter(logger);
+    return {
+      orchestrator: new Orchestrator(config, projectRoot, stateManager, gitAdapter, ptyAdapter, stdioAdapter, logger),
+      config,
+      projectRoot,
+    };
+  }
+
+  const { config, projectRoot } = loadConfig(options?.projectRoot);
+  const logger = createLogger(config.logging.level, path.join(projectRoot, 'tasks-management', 'logs'));
+  logger.debug(`Project root: ${projectRoot}`);
+  const stateDir = path.join(projectRoot, 'tasks-management', 'state');
+  const stateManager = new StateManager(stateDir, logger);
+  // M-6 fix: clean orphaned .tmp files from crashed writes on startup
+  stateManager.cleanupTempFiles(stateDir);
+  const gitAdapter = new GitAdapter(projectRoot, config, logger);
+  const ptyAdapter = new PtyAdapter(logger);
+  const stdioAdapter = new StdioAdapter(logger);
+  return {
+    orchestrator: new Orchestrator(config, projectRoot, stateManager, gitAdapter, ptyAdapter, stdioAdapter, logger),
+    config,
+    projectRoot,
+  };
+}

package/src/core/graph/__tests__/builder.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GraphBuilder } from '../builder.js';
+import type { FileNode, NomosConfig } from '../../../types/index.js';
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+function makeConfig(overrides: Partial<NomosConfig['graph']> = {}): NomosConfig['graph'] {
+  return {
+    exclude_patterns: [],
+    ai_enrichment: false,
+    ai_model: 'gemini-1.5-flash',
+    ai_concurrency: 5,
+    ai_requests_per_minute: 14,
+    max_file_chars: 4000,
+    core_modules_count: 3,
+    output_dir: 'tasks-management/graph',
+    ...overrides,
+  };
+}
+
+function makeLogger() {
+  return { warn: vi.fn(), info: vi.fn() };
+}
+
+/**
+ * Create a minimal FileNode with only the fields needed for GraphBuilder tests.
+ * Dependencies / dependents / depth are intentionally left at defaults so BLK-3
+ * reset behavior can be verified.
+ */
+function makeNode(
+  file: string,
+  imports: Array<{ resolved: string | null; is_external: boolean }> = [],
+  // Pre-populate with stale data to verify BLK-3 reset
+  staleData: Partial<Pick<FileNode, 'dependencies' | 'dependents' | 'depth'>> = {},
+): FileNode {
+  return {
+    file,
+    hash: 'sha256:abc',
+    language: 'typescript',
+    symbols: [],
+    imports: imports.map((imp) => ({
+      source: imp.resolved ?? 'unknown',
+      resolved: imp.resolved,
+      symbols: [],
+      is_external: imp.is_external,
+    })),
+    dependents: staleData.dependents ?? [],
+    dependencies: staleData.dependencies ?? [],
+    depth: staleData.depth ?? 0,
+    last_parsed_at: null,
+    semantic: null,
+    enrichment_status: 'structural',
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('GraphBuilder', () => {
+  let logger: ReturnType<typeof makeLogger>;
+  let builder: GraphBuilder;
+
+  beforeEach(() => {
+    logger = makeLogger();
+    builder = new GraphBuilder(makeConfig(), logger);
+  });
+
+  // ── Test 1: Linear chain A → B → C ───────────────────────────────────────
+
+  it('linear chain: A→B→C → depths A=0, B=1, C=2', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [{ resolved: 'C.ts', is_external: false }])],
+      ['C.ts', makeNode('C.ts', [])],
+    ]);
+
+    builder.build(nodes);
+
+    expect(nodes.get('A.ts')!.depth).toBe(0);
+    expect(nodes.get('B.ts')!.depth).toBe(1);
+    expect(nodes.get('C.ts')!.depth).toBe(2);
+  });
+
+  // ── Test 2: Fan-in A→C, B→C ──────────────────────────────────────────────
+
+  it('fan-in: A→C, B→C → C highest depth, A and B = 0', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'C.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [{ resolved: 'C.ts', is_external: false }])],
+      ['C.ts', makeNode('C.ts', [])],
+    ]);
+
+    builder.build(nodes);
+
+    expect(nodes.get('A.ts')!.depth).toBe(0);
+    expect(nodes.get('B.ts')!.depth).toBe(0);
+    expect(nodes.get('C.ts')!.depth).toBeGreaterThan(0);
+  });
+
+  // ── Test 3: Forward/reverse edges correctly populated ────────────────────
+
+  it('populates dependencies and dependents correctly', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [])],
+    ]);
+
+    builder.build(nodes);
+
+    expect(nodes.get('A.ts')!.dependencies).toEqual(['B.ts']);
+    expect(nodes.get('A.ts')!.dependents).toEqual([]);
+    expect(nodes.get('B.ts')!.dependencies).toEqual([]);
+    expect(nodes.get('B.ts')!.dependents).toEqual(['A.ts']);
+  });
+
+  // ── Test 4: 2-node cycle A ↔ B ───────────────────────────────────────────
+
+  it('2-node cycle: A↔B → both get depth > 0, warning logged', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [{ resolved: 'A.ts', is_external: false }])],
+    ]);
+
+    builder.build(nodes);
+
+    const dA = nodes.get('A.ts')!.depth;
+    const dB = nodes.get('B.ts')!.depth;
+    // Both assigned the same cycle depth (both start from external edge depth -1 → 0)
+    expect(dA).toBe(dB);
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Circular dependency detected'),
+    );
+  });
+
+  // ── Test 5: 3-node cycle A → B → C → A ───────────────────────────────────
+
+  it('3-node cycle: A→B→C→A → all three get cycle depth, warning with full path', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [{ resolved: 'C.ts', is_external: false }])],
+      ['C.ts', makeNode('C.ts', [{ resolved: 'A.ts', is_external: false }])],
+    ]);
+
+    builder.build(nodes);
+
+    // All three must have a depth assigned
+    const depths = [
+      nodes.get('A.ts')!.depth,
+      nodes.get('B.ts')!.depth,
+      nodes.get('C.ts')!.depth,
+    ];
+    expect(depths.every((d) => d >= 0)).toBe(true);
+
+    // Warning should mention a cycle
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Circular dependency detected'),
+    );
+    // The logged path should include all three nodes
+    const warnCall = logger.warn.mock.calls.find((c) =>
+      c[0].includes('Circular dependency detected'),
+    );
+    expect(warnCall![0]).toMatch(/A\.ts/);
+    expect(warnCall![0]).toMatch(/B\.ts/);
+    expect(warnCall![0]).toMatch(/C\.ts/);
+  });
+
+  // ── Test 6: [BLK-3] Incremental — second run clears stale edges ──────────
+
+  it('[BLK-3] second build() on same nodes does NOT accumulate stale edges', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [])],
+    ]);
+
+    // First build
+    builder.build(nodes);
+    expect(nodes.get('A.ts')!.dependencies).toEqual(['B.ts']);
+    expect(nodes.get('B.ts')!.dependents).toEqual(['A.ts']);
+
+    // Mutate imports (A no longer imports B)
+    nodes.get('A.ts')!.imports = [];
+
+    // Second build — stale edges must be gone
+    builder.build(nodes);
+    expect(nodes.get('A.ts')!.dependencies).toEqual([]);
+    expect(nodes.get('B.ts')!.dependents).toEqual([]);
+    expect(nodes.get('A.ts')!.depth).toBe(0);
+    expect(nodes.get('B.ts')!.depth).toBe(0);
+  });
+
+  // ── Test 7: [GAP-6] Disconnected cycles ──────────────────────────────────
+
+  it('[GAP-6] disconnected cycles A↔B and C↔D produce distinct warnings', () => {
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }])],
+      ['B.ts', makeNode('B.ts', [{ resolved: 'A.ts', is_external: false }])],
+      ['C.ts', makeNode('C.ts', [{ resolved: 'D.ts', is_external: false }])],
+      ['D.ts', makeNode('D.ts', [{ resolved: 'C.ts', is_external: false }])],
+    ]);
+
+    builder.build(nodes);
+
+    const warnCalls = logger.warn.mock.calls.filter((c) =>
+      c[0].includes('Circular dependency detected'),
+    );
+    expect(warnCalls.length).toBeGreaterThanOrEqual(2);
+  });
+
+  // ── Test 8: core_modules extraction ──────────────────────────────────────
+
+  it('core_modules returns top N files by depth descending', () => {
+    const nodes = new Map<string, FileNode>([
+      ['entry.ts', makeNode('entry.ts', [{ resolved: 'mid.ts', is_external: false }])],
+      ['mid.ts', makeNode('mid.ts', [{ resolved: 'core.ts', is_external: false }])],
+      ['core.ts', makeNode('core.ts', [])],
+      ['util.ts', makeNode('util.ts', [])],
+    ]);
+
+    const stats = builder.build(nodes);
+
+    // core.ts has depth 2 (deepest), should appear first in core_modules
+    expect(stats.core_modules[0]).toBe('core.ts');
+    expect(stats.core_modules.length).toBeLessThanOrEqual(3); // config.core_modules_count = 3
+  });
+
+  // ── Test 9: Stats accuracy ────────────────────────────────────────────────
+
+  it('stats: total_files, total_symbols, total_edges are accurate', () => {
+    const nodeA: FileNode = {
+      ...makeNode('A.ts', [{ resolved: 'B.ts', is_external: false }]),
+      symbols: [
+        { name: 'foo', kind: 'function', line: 1, end_line: 5, signature: null, exported: true },
+        { name: 'Bar', kind: 'class', line: 7, end_line: 15, signature: null, exported: false },
+      ],
+    };
+    const nodeB: FileNode = {
+      ...makeNode('B.ts', []),
+      symbols: [
+        { name: 'baz', kind: 'variable', line: 1, end_line: 1, signature: null, exported: true },
+      ],
+    };
+
+    const nodes = new Map<string, FileNode>([
+      ['A.ts', nodeA],
+      ['B.ts', nodeB],
+    ]);
+
+    const stats = builder.build(nodes);
+
+    expect(stats.total_files).toBe(2);
+    expect(stats.total_symbols).toBe(3); // 2 from A + 1 from B
+    expect(stats.total_edges).toBe(1);   // A → B
+  });
+
+  // ── Bonus: external/null imports are not counted as edges ─────────────────
+
+  it('does not count external or unresolved imports as edges', () => {
+    const nodes = new Map<string, FileNode>([
+      [
+        'A.ts',
+        makeNode('A.ts', [
+          { resolved: null, is_external: true },  // external package
+          { resolved: null, is_external: false },  // unresolvable relative
+          { resolved: 'B.ts', is_external: false }, // real internal edge
+        ]),
+      ],
+      ['B.ts', makeNode('B.ts', [])],
+    ]);
+
+    const stats = builder.build(nodes);
+    expect(stats.total_edges).toBe(1);
+  });
+});