@nomos-arc/arc 0.1.0

package/src/core/__tests__/config.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { loadConfig, getDefaultConfig, findConfigFile } from '../config.js';
+import { NomosError } from '../errors.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'nomos-config-test-'));
+}
+
+function writeConfig(dir: string, content: unknown): string {
+  const cfgPath = path.join(dir, '.nomos-config.json');
+  fs.writeFileSync(cfgPath, JSON.stringify(content), 'utf-8');
+  return cfgPath;
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('findConfigFile — walk-up discovery', () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = makeTmpDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('finds config in the start directory', () => {
+    writeConfig(root, {});
+    const found = findConfigFile(root);
+    expect(found).toBe(path.join(root, '.nomos-config.json'));
+  });
+
+  it('finds config in a parent directory when starting from a nested child', () => {
+    writeConfig(root, {});
+    const nested = path.join(root, 'a', 'b', 'c');
+    fs.mkdirSync(nested, { recursive: true });
+    const found = findConfigFile(nested);
+    expect(found).toBe(path.join(root, '.nomos-config.json'));
+  });
+
+  it('throws config_not_found when no config exists in any ancestor', () => {
+    // Use a fresh temp dir with no config file at all
+    const empty = makeTmpDir();
+    try {
+      expect(() => findConfigFile(empty)).toThrowError(
+        expect.objectContaining({ code: 'config_not_found' }),
+      );
+    } finally {
+      fs.rmSync(empty, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('loadConfig — defaults and deep-merge', () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = makeTmpDir();
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('loads empty config and applies all defaults', () => {
+    writeConfig(root, {});
+    const { config, projectRoot } = loadConfig(root);
+
+    expect(projectRoot).toBe(root);
+    expect(config.execution.default_mode).toBe('supervised');
+    expect(config.convergence.score_threshold).toBe(0.9);
+    expect(config.convergence.max_iterations).toBe(3);
+    expect(config.binaries.planner.cmd).toBe('claude');
+    expect(config.binaries.planner.pty).toBe(true);
+    expect(config.binaries.reviewer.cmd).toBe('codex');
+    expect(config.binaries.reviewer.pty).toBe(false);
+  });
+
+  it('applies correct planner defaults', () => {
+    writeConfig(root, {});
+    const { config } = loadConfig(root);
+    expect(config.binaries.planner.heartbeat_timeout_ms).toBe(120000);
+    expect(config.binaries.planner.total_timeout_ms).toBe(300000);
+    expect(config.binaries.planner.max_output_bytes).toBe(1048576);
+  });
+
+  it('applies correct reviewer defaults', () => {
+    writeConfig(root, {});
+    const { config } = loadConfig(root);
+    expect(config.binaries.reviewer.heartbeat_timeout_ms).toBe(120000);
+    expect(config.binaries.reviewer.total_timeout_ms).toBe(120000);
+    expect(config.binaries.reviewer.max_output_bytes).toBe(524288);
+    expect(config.binaries.reviewer.usage_pattern).toBeNull();
+  });
+
+  it('minimal config — only cmd provided — does not wipe other planner defaults (deep-merge)', () => {
+    writeConfig(root, {
+      binaries: {
+        planner: { cmd: 'my-claude' },
+        reviewer: { cmd: 'my-codex' },
+      },
+    });
+    const { config } = loadConfig(root);
+
+    // Overridden
+    expect(config.binaries.planner.cmd).toBe('my-claude');
+    expect(config.binaries.reviewer.cmd).toBe('my-codex');
+
+    // Planner defaults must survive
+    expect(config.binaries.planner.pty).toBe(true);
+    expect(config.binaries.planner.heartbeat_timeout_ms).toBe(120000);
+    expect(config.binaries.planner.total_timeout_ms).toBe(300000);
+
+    // Reviewer defaults must survive
+    expect(config.binaries.reviewer.pty).toBe(false);
+    expect(config.binaries.reviewer.heartbeat_timeout_ms).toBe(120000);
+
+    // Top-level defaults must survive
+    expect(config.convergence.score_threshold).toBe(0.9);
+  });
+
+  it('partial nested config correctly inherits all non-provided fields', () => {
+    writeConfig(root, {
+      convergence: { score_threshold: 0.95 },
+    });
+    const { config } = loadConfig(root);
+    expect(config.convergence.score_threshold).toBe(0.95);
+    expect(config.convergence.max_iterations).toBe(3);  // default preserved
+  });
+
+  it('invalid config — wrong type for score_threshold — throws NomosError with field path', () => {
+    writeConfig(root, { convergence: { score_threshold: 'not-a-number' } });
+    expect(() => loadConfig(root)).toThrowError(
+      expect.objectContaining({
+        code: 'config_invalid',
+        message: expect.stringContaining('convergence.score_threshold'),
+      }),
+    );
+  });
+
+  it('missing config throws NomosError with config_not_found code', () => {
+    // No .nomos-config.json in root
+    expect(() => loadConfig(root)).toThrowError(
+      expect.objectContaining({ code: 'config_not_found' }),
+    );
+  });
+
+  it('NomosError is instanceof Error', () => {
+    try {
+      loadConfig(root);
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      expect(err).toBeInstanceOf(NomosError);
+      expect((err as NomosError).name).toBe('NomosError');
+    }
+  });
+});
+
+describe('getDefaultConfig', () => {
+  it('returns a fully populated config with all fields', () => {
+    const cfg = getDefaultConfig();
+
+    expect(cfg.execution.default_mode).toBe('supervised');
+    expect(cfg.execution.shadow_branch_prefix).toBe('nomos/');
+    expect(cfg.execution.worktree_base).toBe('/tmp/nomos-worktrees/');
+    expect(cfg.binaries.planner.cmd).toBe('claude');
+    expect(cfg.binaries.planner.pty).toBe(true);
+    expect(cfg.binaries.reviewer.cmd).toBe('codex');
+    expect(cfg.binaries.reviewer.pty).toBe(false);
+    expect(cfg.convergence.score_threshold).toBe(0.9);
+    expect(cfg.convergence.max_iterations).toBe(3);
+    expect(cfg.budget.max_tokens_per_task).toBe(100000);
+    expect(cfg.security.redaction_label).toBe('[REDACTED]');
+    expect(cfg.git.auto_commit).toBe(true);
+    expect(cfg.review.max_context_files).toBe(5);
+    expect(cfg.logging.level).toBe('info');
+    expect(cfg.logging.retain_days).toBe(30);
+  });
+
+  it('cost_per_1k_tokens contains expected model entries', () => {
+    const cfg = getDefaultConfig();
+    expect(cfg.budget.cost_per_1k_tokens['claude']).toEqual({ input: 0.003, output: 0.015 });
+    expect(cfg.budget.cost_per_1k_tokens['codex']).toEqual({ input: 0.0005, output: 0.002 });
+  });
+});

package/src/core/__tests__/preflight.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import * as path from 'path';
+import { resolveBinary } from '../preflight.js';
+import { NomosError } from '../errors.js';
+
+describe('resolveBinary', () => {
+  it('resolves "node" to an absolute path', async () => {
+    const resolved = await resolveBinary('node');
+    expect(path.isAbsolute(resolved)).toBe(true);
+    expect(resolved).toContain('node');
+  });
+
+  it('throws binary_not_found for a nonexistent binary', async () => {
+    await expect(resolveBinary('nonexistent-binary-xyz')).rejects.toMatchObject({
+      code: 'binary_not_found',
+    });
+  });
+
+  it('throws binary_not_found for an absolute path that does not exist', async () => {
+    await expect(resolveBinary('/nonexistent/path/to/binary')).rejects.toMatchObject({
+      code: 'binary_not_found',
+    });
+  });
+});

package/src/core/__tests__/prompt.test.ts

@@ -0,0 +1,358 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { assemblePrompt, assembleReviewPrompt, loadRules } from '../prompt.js';
+import { readArchitecturalConstraints } from '../graph/constraints.js';
+import type { PromptOptions, ReviewPromptOptions } from '../../types/index.js';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nomos-prompt-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function scaffoldRules(opts: {
+  global?: string;
+  backend?: string;
+  session?: { taskId: string; content: string };
+}): void {
+  const rulesDir = path.join(tmpDir, 'tasks-management', 'rules');
+  fs.mkdirSync(rulesDir, { recursive: true });
+  if (opts.global !== undefined) {
+    fs.writeFileSync(path.join(rulesDir, 'global.md'), opts.global);
+  }
+  if (opts.backend !== undefined) {
+    fs.writeFileSync(path.join(rulesDir, 'backend.md'), opts.backend);
+  }
+  if (opts.session) {
+    const sessionDir = path.join(rulesDir, 'session');
+    fs.mkdirSync(sessionDir, { recursive: true });
+    fs.writeFileSync(path.join(sessionDir, `${opts.session.taskId}.md`), opts.session.content);
+  }
+}
+
+const BASE_PROMPT_OPTIONS: PromptOptions = {
+  globalRules: 'Global rule content',
+  domainRules: 'Domain rule content',
+  sessionRules: null,
+  taskBody: 'Implement the feature',
+  contextFiles: [],
+  previousFeedback: null,
+  previousVersion: null,
+  mode: 'supervised',
+  architecturalConstraints: null,
+};
+
+// ── assemblePrompt ────────────────────────────────────────────────────────────
+
+describe('assemblePrompt', () => {
+  it('includes all sections in correct order', () => {
+    const result = assemblePrompt(BASE_PROMPT_OPTIONS);
+
+    const systemIdx = result.indexOf('[SYSTEM RULES]');
+    const domainIdx = result.indexOf('[DOMAIN RULES]');
+    const taskIdx = result.indexOf('[TASK REQUIREMENTS]');
+    const instrIdx = result.indexOf('[INSTRUCTION]');
+
+    expect(systemIdx).toBeGreaterThanOrEqual(0);
+    expect(domainIdx).toBeGreaterThan(systemIdx);
+    expect(taskIdx).toBeGreaterThan(domainIdx);
+    expect(instrIdx).toBeGreaterThan(taskIdx);
+  });
+
+  it('omits [DOMAIN RULES] when domainRules is empty', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, domainRules: '' });
+    expect(result).not.toContain('[DOMAIN RULES]');
+  });
+
+  it('omits [SESSION CONSTRAINTS] when sessionRules is null', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, sessionRules: null });
+    expect(result).not.toContain('[SESSION CONSTRAINTS]');
+  });
+
+  it('includes [SESSION CONSTRAINTS] when sessionRules is set', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, sessionRules: 'Only use TypeScript.' });
+    expect(result).toContain('[SESSION CONSTRAINTS]');
+    expect(result).toContain('Only use TypeScript.');
+  });
+
+  it('includes [CONTEXT FILES] section when contextFiles is non-empty', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, contextFiles: ['src/auth.ts'] });
+    expect(result).toContain('[CONTEXT FILES]');
+    expect(result).toContain('- src/auth.ts');
+  });
+
+  it('omits [CONTEXT FILES] section when contextFiles is empty', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, contextFiles: [] });
+    expect(result).not.toContain('[CONTEXT FILES]');
+  });
+
+  it('formats previous feedback as a bullet list with version number', () => {
+    const result = assemblePrompt({
+      ...BASE_PROMPT_OPTIONS,
+      previousFeedback: [
+        { severity: 'high', category: 'security', description: 'SQL injection', suggestion: 'Use parameterized queries' },
+      ],
+      previousVersion: 2,
+    });
+    expect(result).toContain('[PREVIOUS REVIEW FEEDBACK]');
+    expect(result).toContain('v2');
+    expect(result).toContain('- [high] SQL injection: Use parameterized queries');
+  });
+
+  it('omits [PREVIOUS REVIEW FEEDBACK] when previousFeedback is null', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, previousFeedback: null });
+    expect(result).not.toContain('[PREVIOUS REVIEW FEEDBACK]');
+  });
+
+  it('omits [PREVIOUS REVIEW FEEDBACK] when previousFeedback is empty array', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, previousFeedback: [] });
+    expect(result).not.toContain('[PREVIOUS REVIEW FEEDBACK]');
+  });
+});
+
+// ── assembleReviewPrompt ──────────────────────────────────────────────────────
+
+describe('assembleReviewPrompt', () => {
+  const BASE_REVIEW_OPTIONS: ReviewPromptOptions = {
+    planDiff: '+ added line\n- removed line',
+    planSummary: null,
+    globalRules: 'No secrets in output',
+    domainRules: '',
+    mode: 'supervised',
+  };
+
+  it('includes the full JSON schema in [INSTRUCTION]', () => {
+    const result = assembleReviewPrompt(BASE_REVIEW_OPTIONS);
+    expect(result).toContain('[INSTRUCTION]');
+    expect(result).toContain('"score"');
+    expect(result).toContain('"summary"');
+    expect(result).toContain('"issues"');
+    expect(result).toContain('"severity"');
+    expect(result).toContain('"category"');
+    expect(result).toContain('"description"');
+    expect(result).toContain('"suggestion"');
+  });
+
+  it('includes [ZERO-TOLERANCE CLAUSE] in auto mode', () => {
+    const result = assembleReviewPrompt({ ...BASE_REVIEW_OPTIONS, mode: 'auto' });
+    expect(result).toContain('[ZERO-TOLERANCE CLAUSE]');
+    expect(result).toContain('auto mode');
+    expect(result).toContain('score below 0.5');
+  });
+
+  it('omits [ZERO-TOLERANCE CLAUSE] in supervised mode', () => {
+    const result = assembleReviewPrompt({ ...BASE_REVIEW_OPTIONS, mode: 'supervised' });
+    expect(result).not.toContain('[ZERO-TOLERANCE CLAUSE]');
+  });
+
+  it('includes [AFFECTED FILES] when affectedFileSnippets is provided', () => {
+    const result = assembleReviewPrompt({
+      ...BASE_REVIEW_OPTIONS,
+      affectedFileSnippets: [{ file: 'src/auth.ts', snippet: 'const x = 1;' }],
+    });
+    expect(result).toContain('[AFFECTED FILES]');
+    expect(result).toContain('// src/auth.ts');
+    expect(result).toContain('const x = 1;');
+  });
+
+  it('omits [AFFECTED FILES] when affectedFileSnippets is absent', () => {
+    const result = assembleReviewPrompt(BASE_REVIEW_OPTIONS);
+    expect(result).not.toContain('[AFFECTED FILES]');
+  });
+});
+
+// ── architecturalConstraints injection (Step 5.6) ────────────────────────────
+
+describe('assemblePrompt — architectural constraints', () => {
+  it('includes [ARCHITECTURAL CONSTRAINTS] when architecturalConstraints is non-null', () => {
+    const constraints = '- src/types.ts → symbol: User\n  Consumed by: src/services/user-service.ts\n  Contract: "Manages user persistence"';
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, architecturalConstraints: constraints });
+    expect(result).toContain('[ARCHITECTURAL CONSTRAINTS]');
+    expect(result).toContain('src/types.ts → symbol: User');
+  });
+
+  it('omits [ARCHITECTURAL CONSTRAINTS] when architecturalConstraints is null', () => {
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, architecturalConstraints: null });
+    expect(result).not.toContain('[ARCHITECTURAL CONSTRAINTS]');
+  });
+
+  it('[ARCHITECTURAL CONSTRAINTS] appears before [INSTRUCTION]', () => {
+    const constraints = '- src/types.ts → symbol: User\n  Consumed by: src/services/user-service.ts\n  Contract: "Manages user persistence"';
+    const result = assemblePrompt({ ...BASE_PROMPT_OPTIONS, architecturalConstraints: constraints });
+    const constraintsIdx = result.indexOf('[ARCHITECTURAL CONSTRAINTS]');
+    const instrIdx = result.indexOf('[INSTRUCTION]');
+    expect(constraintsIdx).toBeGreaterThanOrEqual(0);
+    expect(instrIdx).toBeGreaterThan(constraintsIdx);
+  });
+});
+
+// ── readArchitecturalConstraints integration (Step 5.6) ──────────────────────
+
+describe('readArchitecturalConstraints', () => {
+  function writeMap(dir: string, data: unknown): void {
+    const graphDir = path.join(dir, 'tasks-management/graph');
+    fs.mkdirSync(graphDir, { recursive: true });
+    fs.writeFileSync(path.join(graphDir, 'project_map.json'), JSON.stringify(data));
+  }
+
+  function makeMinimalMap(files: Record<string, unknown>) {
+    return {
+      schema_version: 1,
+      generated_at: new Date().toISOString(),
+      root: '/tmp',
+      files,
+      stats: { total_files: Object.keys(files).length, total_symbols: 0, total_edges: 0, core_modules: [], structural_only: 0, semantically_enriched: 0, indexed: 0 },
+    };
+  }
+
+  it('returns null when project_map.json does not exist', async () => {
+    const outputDir = path.join(tmpDir, 'tasks-management/graph');
+    const result = await readArchitecturalConstraints(tmpDir, outputDir, ['src/types.ts']);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when no context files have enriched dependents', async () => {
+    const outputDir = path.join(tmpDir, 'tasks-management/graph');
+    const map = makeMinimalMap({
+      'src/types.ts': {
+        file: 'src/types.ts', hash: 'sha256:abc', language: 'typescript',
+        symbols: [{ name: 'User', kind: 'interface', line: 1, end_line: 5, signature: 'interface User', exported: true }],
+        imports: [], dependents: [], dependencies: [], depth: 2,
+        last_parsed_at: new Date().toISOString(), semantic: null,
+      },
+    });
+    writeMap(tmpDir, map);
+    const result = await readArchitecturalConstraints(tmpDir, outputDir, ['src/types.ts']);
+    expect(result).toBeNull();
+  });
+
+  it('builds constraint string when enriched dependents consume exported symbols', async () => {
+    const outputDir = path.join(tmpDir, 'tasks-management/graph');
+    const map = makeMinimalMap({
+      'src/types.ts': {
+        file: 'src/types.ts', hash: 'sha256:abc', language: 'typescript',
+        symbols: [{ name: 'User', kind: 'interface', line: 1, end_line: 5, signature: 'interface User { id: string }', exported: true }],
+        imports: [], dependents: ['src/services/user-service.ts'], dependencies: [], depth: 2,
+        last_parsed_at: new Date().toISOString(), semantic: null,
+      },
+      'src/services/user-service.ts': {
+        file: 'src/services/user-service.ts', hash: 'sha256:def', language: 'typescript',
+        symbols: [],
+        imports: [{ source: '../types', resolved: 'src/types.ts', symbols: ['User'], is_external: false }],
+        dependents: [], dependencies: ['src/types.ts'], depth: 1,
+        last_parsed_at: new Date().toISOString(),
+        semantic: {
+          overview: 'User management service',
+          purpose: 'Manages user persistence and retrieval',
+          key_logic: [], usage_context: [],
+          source_hash: 'sha256:def',
+          enriched_at: new Date().toISOString(),
+          model: 'gemini',
+        },
+      },
+    });
+    writeMap(tmpDir, map);
+    const result = await readArchitecturalConstraints(tmpDir, outputDir, ['src/types.ts']);
+    expect(result).not.toBeNull();
+    expect(result).toContain('src/types.ts');
+    expect(result).toContain('User');
+    expect(result).toContain('Consumed by:');
+    expect(result).toContain('src/services/user-service.ts');
+    expect(result).toContain('Contract:');
+  });
+
+  it('[AMB-7] normalizes relative context file path correctly', async () => {
+    const outputDir = path.join(tmpDir, 'tasks-management/graph');
+    const map = makeMinimalMap({
+      'src/types.ts': {
+        file: 'src/types.ts', hash: 'sha256:abc', language: 'typescript',
+        symbols: [{ name: 'User', kind: 'interface', line: 1, end_line: 5, signature: 'interface User', exported: true }],
+        imports: [], dependents: ['src/services/user-service.ts'], dependencies: [], depth: 2,
+        last_parsed_at: new Date().toISOString(), semantic: null,
+      },
+      'src/services/user-service.ts': {
+        file: 'src/services/user-service.ts', hash: 'sha256:def', language: 'typescript',
+        symbols: [],
+        imports: [{ source: '../types', resolved: 'src/types.ts', symbols: ['User'], is_external: false }],
+        dependents: [], dependencies: ['src/types.ts'], depth: 1,
+        last_parsed_at: new Date().toISOString(),
+        semantic: {
+          overview: 'User management service',
+          purpose: 'Manages user persistence and retrieval',
+          key_logic: [], usage_context: [],
+          source_hash: 'sha256:def',
+          enriched_at: new Date().toISOString(),
+          model: 'gemini',
+        },
+      },
+    });
+    writeMap(tmpDir, map);
+
+    // Pass a relative path that resolves to 'src/types.ts'
+    const result = await readArchitecturalConstraints(
+      tmpDir, outputDir,
+      ['./src/types.ts'], // relative form
+    );
+    expect(result).not.toBeNull();
+    expect(result).toContain('src/types.ts');
+  });
+
+  it('returns null and skips missing-from-map context files', async () => {
+    const outputDir = path.join(tmpDir, 'tasks-management/graph');
+    const map = makeMinimalMap({});
+    writeMap(tmpDir, map);
+    // File not in map
+    const result = await readArchitecturalConstraints(tmpDir, outputDir, ['src/nonexistent.ts']);
+    expect(result).toBeNull();
+  });
+});
+
+// ── loadRules ─────────────────────────────────────────────────────────────────
+
+describe('loadRules', () => {
+  it('computes consistent hash for same input', async () => {
+    scaffoldRules({ global: 'global rules content', backend: 'backend rules' });
+    const r1 = await loadRules(tmpDir, 'task-1');
+    const r2 = await loadRules(tmpDir, 'task-1');
+    expect(r1.rulesHash).toBe(r2.rulesHash);
+    expect(r1.rulesHash).toMatch(/^sha256:[a-f0-9]{64}$/);
+  });
+
+  it('throws rules_missing when global.md is absent', async () => {
+    scaffoldRules({});  // no global.md
+    await expect(loadRules(tmpDir, 'task-1')).rejects.toMatchObject({
+      code: 'rules_missing',
+    });
+  });
+
+  it('handles missing backend.md gracefully (empty domain, no throw)', async () => {
+    scaffoldRules({ global: 'global content' });  // no backend.md
+    const result = await loadRules(tmpDir, 'task-1');
+    expect(result.domain).toBe('');
+    expect(result.rulesList).not.toContain('backend.md');
+  });
+
+  it('includes session rules when session/{taskId}.md exists', async () => {
+    scaffoldRules({
+      global: 'global content',
+      session: { taskId: 'task-abc', content: 'session specific rules' },
+    });
+    const result = await loadRules(tmpDir, 'task-abc');
+    expect(result.session).toBe('session specific rules');
+    expect(result.rulesList).toContain('session/task-abc.md');
+  });
+
+  it('returns null for session when session file is absent', async () => {
+    scaffoldRules({ global: 'global content' });
+    const result = await loadRules(tmpDir, 'task-xyz');
+    expect(result.session).toBeNull();
+  });
+});