@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/context.test.cjs

@@ -0,0 +1,693 @@
+/**
+ * Tests for context.cjs -- Context tier engine
+ *
+ * Uses Node.js built-in test runner (node:test) and assert (node:assert/strict).
+ * Tests invoke dgs-tools.cjs CLI via execSync against isolated temp fixtures
+ * to verify tier resolution, scope handling, and graceful degradation.
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const { createFixture } = require('./test-helpers.cjs');
+const {
+  parseTierDefinitions,
+  parseSimpleYaml,
+  loadTierInternal,
+  resetTierCache,
+  resolvePhaseScope,
+  resolveIdeaScope,
+  resolveSpecScope,
+  resolveTierFiles,
+  cmdContextLoadTier,
+} = require('./context.cjs');
+
+// Path to CLI entry point
+const CLI = path.resolve(__dirname, '..', 'dgs-tools.cjs');
+
+/**
+ * Run a dgs-tools context command in a fixture directory and return parsed JSON.
+ */
+function runContext(cwd, args) {
+  const stdout = execSync(`node "${CLI}" context ${args}`, {
+    cwd,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  return JSON.parse(stdout.trim());
+}
+
+/**
+ * Run a dgs-tools context command expecting an error, return stderr text.
+ */
+function runContextError(cwd, args) {
+  try {
+    execSync(`node "${CLI}" context ${args}`, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return null; // No error
+  } catch (err) {
+    return err.stderr ? err.stderr.toString().trim() : err.message;
+  }
+}
+
+// ─── parseTierDefinitions ────────────────────────────────────────────────────
+
+describe('parseTierDefinitions', () => {
+  afterEach(() => {
+    resetTierCache();
+  });
+
+  it('parses all 5 tiers from the reference doc', () => {
+    const tiers = parseTierDefinitions();
+    assert.equal(tiers.size, 5, 'should have exactly 5 tiers');
+    assert.ok(tiers.has('none'), 'should have none tier');
+    assert.ok(tiers.has('lite'), 'should have lite tier');
+    assert.ok(tiers.has('planning'), 'should have planning tier');
+    assert.ok(tiers.has('execution'), 'should have execution tier');
+    assert.ok(tiers.has('verification'), 'should have verification tier');
+  });
+
+  it('each tier has required fields', () => {
+    const tiers = parseTierDefinitions();
+    for (const [name, tier] of tiers) {
+      assert.ok(tier.tier, `tier ${name} should have tier field`);
+      assert.equal(tier.tier, name, `tier name should match key`);
+    }
+  });
+
+  it('tier inheritance chain is correct', () => {
+    const tiers = parseTierDefinitions();
+
+    assert.equal(tiers.get('none').includes_tier, null, 'none has no parent');
+    assert.equal(tiers.get('lite').includes_tier, null, 'lite has no parent');
+    assert.equal(tiers.get('planning').includes_tier, 'lite', 'planning inherits lite');
+    assert.equal(tiers.get('execution').includes_tier, 'planning', 'execution inherits planning');
+    assert.equal(tiers.get('verification').includes_tier, 'execution', 'verification inherits execution');
+  });
+
+  it('none tier has empty files array', () => {
+    const tiers = parseTierDefinitions();
+    const none = tiers.get('none');
+    assert.ok(Array.isArray(none.files), 'none tier files should be array');
+    assert.equal(none.files.length, 0, 'none tier files should be empty');
+  });
+
+  it('lite tier has 3 files (PROJECT.md, STATE.md, config.json)', () => {
+    const tiers = parseTierDefinitions();
+    const lite = tiers.get('lite');
+    assert.ok(Array.isArray(lite.files), 'lite tier files should be array');
+    assert.equal(lite.files.length, 3, 'lite tier should have 3 files');
+    const paths = lite.files.map(f => f.path);
+    assert.ok(paths.includes('PROJECT.md'), 'should include PROJECT.md');
+    assert.ok(paths.includes('STATE.md'), 'should include STATE.md');
+    assert.ok(paths.includes('config.json'), 'should include config.json');
+  });
+
+  it('planning tier has 3 own files plus dynamic codebase glob', () => {
+    const tiers = parseTierDefinitions();
+    const planning = tiers.get('planning');
+    assert.ok(Array.isArray(planning.files), 'planning tier files should be array');
+    assert.equal(planning.files.length, 3, 'planning tier should have 3 own files');
+    const paths = planning.files.map(f => f.path);
+    assert.ok(paths.includes('ROADMAP.md'), 'should include ROADMAP.md');
+    assert.ok(paths.includes('REQUIREMENTS.md'), 'should include REQUIREMENTS.md');
+    assert.ok(paths.includes('REPOS.md'), 'should include REPOS.md');
+
+    // Dynamic rules
+    assert.ok(Array.isArray(planning.dynamic), 'should have dynamic rules');
+    assert.ok(planning.dynamic.length > 0, 'should have at least one dynamic rule');
+    assert.equal(planning.dynamic[0].type, 'glob', 'first dynamic rule should be glob');
+    assert.equal(planning.dynamic[0].pattern, 'codebase/**/*.md', 'codebase glob pattern');
+  });
+
+  it('caches results on subsequent calls', () => {
+    const first = parseTierDefinitions();
+    const second = parseTierDefinitions();
+    assert.equal(first, second, 'should return same Map instance from cache');
+  });
+});
+
+// ─── context load-tier none ──────────────────────────────────────────────────
+
+describe('context load-tier none', () => {
+  let fixture;
+
+  beforeEach(() => {
+    resetTierCache();
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+    });
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+    resetTierCache();
+  });
+
+  it('returns empty files array', () => {
+    const result = loadTierInternal('none', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.ok(Array.isArray(result.files), 'files should be array');
+    assert.equal(result.files.length, 0, 'none tier should have 0 files');
+  });
+
+  it('returns tier name in output', () => {
+    const result = loadTierInternal('none', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.equal(result.tier, 'none', 'tier should be "none"');
+  });
+
+  it('returns empty scope', () => {
+    const result = loadTierInternal('none', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.deepEqual(result.scope, {}, 'scope should be empty');
+  });
+});
+
+// ─── context load-tier lite ──────────────────────────────────────────────────
+
+describe('context load-tier lite', () => {
+  let fixture;
+
+  beforeEach(() => {
+    resetTierCache();
+  });
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    resetTierCache();
+  });
+
+  it('returns files with correct paths for existing files', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+    });
+
+    const result = loadTierInternal('lite', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.equal(result.tier, 'lite');
+    assert.ok(result.files.length > 0, 'should have some files');
+
+    const filePaths = result.files.map(f => f.path);
+    // All three should be present since they exist in fixture
+    assert.ok(filePaths.some(p => p.includes('PROJECT.md')), 'should include PROJECT.md');
+    assert.ok(filePaths.some(p => p.includes('STATE.md')), 'should include STATE.md');
+    assert.ok(filePaths.some(p => p.includes('config.json')), 'should include config.json');
+  });
+
+  it('returns category labels for each file', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+    });
+
+    const result = loadTierInternal('lite', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+
+    for (const file of result.files) {
+      assert.ok(file.category, `file ${file.path} should have category`);
+    }
+
+    const categories = result.files.map(f => f.category);
+    assert.ok(categories.includes('project'), 'should have project category');
+    assert.ok(categories.includes('state'), 'should have state category');
+    assert.ok(categories.includes('config'), 'should have config category');
+  });
+
+  it('omits missing files silently', () => {
+    // No STATE.md in this fixture
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+    });
+
+    const result = loadTierInternal('lite', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(!filePaths.some(p => p.includes('STATE.md')), 'STATE.md should be omitted when missing');
+    assert.ok(filePaths.some(p => p.includes('PROJECT.md')), 'PROJECT.md should still be present');
+    assert.ok(filePaths.some(p => p.includes('config.json')), 'config.json should still be present');
+  });
+
+  it('all files have exists: true', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+    });
+
+    const result = loadTierInternal('lite', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    for (const file of result.files) {
+      assert.equal(file.exists, true, `file ${file.path} should have exists: true`);
+    }
+  });
+});
+
+// ─── context load-tier planning ──────────────────────────────────────────────
+
+describe('context load-tier planning', () => {
+  let fixture;
+
+  beforeEach(() => {
+    resetTierCache();
+  });
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    resetTierCache();
+  });
+
+  it('includes all lite tier files plus planning files', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/REQUIREMENTS.md': '# Requirements',
+      '.planning/REPOS.md': '# Repos',
+    });
+
+    const result = loadTierInternal('planning', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    const filePaths = result.files.map(f => f.path);
+
+    // Lite tier files
+    assert.ok(filePaths.some(p => p.includes('PROJECT.md')), 'should include PROJECT.md from lite tier');
+    assert.ok(filePaths.some(p => p.includes('STATE.md')), 'should include STATE.md from lite tier');
+    assert.ok(filePaths.some(p => p.includes('config.json')), 'should include config.json from lite tier');
+
+    // Planning tier files
+    assert.ok(filePaths.some(p => p.includes('ROADMAP.md')), 'should include ROADMAP.md');
+    assert.ok(filePaths.some(p => p.includes('REQUIREMENTS.md')), 'should include REQUIREMENTS.md');
+    assert.ok(filePaths.some(p => p.includes('REPOS.md')), 'should include REPOS.md');
+  });
+
+  it('includes codebase docs via dynamic glob', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/codebase/CONVENTIONS.md': '# Conventions',
+      '.planning/codebase/TESTING.md': '# Testing',
+    });
+
+    const result = loadTierInternal('planning', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    const filePaths = result.files.map(f => f.path);
+
+    assert.ok(filePaths.some(p => p.includes('CONVENTIONS.md')), 'should include CONVENTIONS.md');
+    assert.ok(filePaths.some(p => p.includes('TESTING.md')), 'should include TESTING.md');
+
+    // Verify codebase files have correct category
+    const codebaseFiles = result.files.filter(f => f.category === 'codebase');
+    assert.ok(codebaseFiles.length >= 2, 'should have at least 2 codebase files');
+  });
+
+  it('missing REPOS.md is silently omitted', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/REQUIREMENTS.md': '# Requirements',
+      // No REPOS.md
+    });
+
+    const result = loadTierInternal('planning', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(!filePaths.some(p => p.includes('REPOS.md')), 'REPOS.md should be omitted when missing');
+    assert.ok(filePaths.some(p => p.includes('ROADMAP.md')), 'ROADMAP.md should be present');
+  });
+});
+
+// ─── context load-tier with scope flags ──────────────────────────────────────
+
+describe('context load-tier with scope flags', () => {
+  let fixture;
+
+  beforeEach(() => {
+    resetTierCache();
+  });
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    resetTierCache();
+  });
+
+  it('--phase adds phase-specific files to output', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/STATE.md': '# State',
+      '.planning/ROADMAP.md': '# Roadmap\n\n## Phases\n\n### Phase 1: Test Phase\n',
+      '.planning/phases/01-test-phase/01-CONTEXT.md': '# Context',
+      '.planning/phases/01-test-phase/01-RESEARCH.md': '# Research',
+      '.planning/phases/01-test-phase/01-01-PLAN.md': '---\nphase: 01\nplan: 01\n---\n# Plan',
+      '.planning/phases/01-test-phase/01-01-SUMMARY.md': '---\nphase: 01\nplan: 01\n---\n# Summary',
+    });
+
+    const result = loadTierInternal('execution', path.join(fixture.cwd, '.planning'), {
+      cwd: fixture.cwd,
+      phase: '1',
+    });
+
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(filePaths.some(p => p.includes('CONTEXT.md')), 'should include phase CONTEXT.md');
+    assert.ok(filePaths.some(p => p.includes('PLAN.md')), 'should include phase PLAN.md');
+    assert.ok(filePaths.some(p => p.includes('SUMMARY.md')), 'should include phase SUMMARY.md');
+    assert.equal(result.scope.phase, '1', 'scope should include phase');
+  });
+
+  it('--idea adds idea file and docs to output', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/ideas/pending/005-better-caching.md': '# Better Caching',
+      '.planning/ideas/pending/005-better-caching/docs/research.md': '# Research on caching',
+    });
+
+    const result = loadTierInternal('planning', path.join(fixture.cwd, '.planning'), {
+      cwd: fixture.cwd,
+      idea: '5',
+    });
+
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(filePaths.some(p => p.includes('005-better-caching.md')), 'should include idea file');
+    assert.ok(filePaths.some(p => p.includes('research.md')), 'should include idea docs');
+    assert.equal(result.scope.idea, '5', 'scope should include idea');
+  });
+
+  it('--spec adds spec file and docs to output', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/specs/dgs-improved-context-spec.md': '---\nid: dgs-improved-context\nstatus: draft\n---\n# Improved Context',
+      '.planning/specs/dgs-improved-context-spec/docs/analysis.md': '# Analysis',
+    });
+
+    const result = loadTierInternal('planning', path.join(fixture.cwd, '.planning'), {
+      cwd: fixture.cwd,
+      spec: 'dgs-improved-context',
+    });
+
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(filePaths.some(p => p.includes('dgs-improved-context-spec.md')), 'should include spec file');
+    assert.ok(filePaths.some(p => p.includes('analysis.md')), 'should include spec docs');
+    assert.equal(result.scope.spec, 'dgs-improved-context', 'scope should include spec');
+  });
+
+  it('missing scope targets silently return no extra files', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/STATE.md': '# State',
+      '.planning/ROADMAP.md': '# Roadmap\n\n## Phases\n\n### Phase 1: Test Phase\n',
+      '.planning/phases/01-test-phase/01-01-PLAN.md': '# Plan',
+    });
+
+    // Phase 999 does not exist
+    const result = loadTierInternal('execution', path.join(fixture.cwd, '.planning'), {
+      cwd: fixture.cwd,
+      phase: '999',
+    });
+
+    // Should still have base files from execution -> planning -> lite inheritance
+    assert.ok(result.files.length >= 0, 'should not crash with missing phase');
+    assert.equal(result.scope.phase, '999', 'scope should still record phase');
+    // No phase-specific files should appear
+    const phaseFiles = result.files.filter(f => f.category === 'phase');
+    assert.equal(phaseFiles.length, 0, 'no phase files for non-existent phase');
+  });
+
+  it('approved spec is marked as truncated', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/specs/my-spec.md': '---\nid: my-spec\nstatus: approved\n---\n# My Spec\n\n## Section 1\nContent\n\n## Section 2\nContent\n\n## Section 3\nContent\n\n## Section 4\nShould be truncated',
+    });
+
+    const result = loadTierInternal('planning', path.join(fixture.cwd, '.planning'), {
+      cwd: fixture.cwd,
+      spec: 'my-spec',
+    });
+
+    const specFiles = result.files.filter(f => f.category === 'spec');
+    assert.ok(specFiles.length > 0, 'should include spec file');
+    assert.equal(specFiles[0].truncated, true, 'approved spec should be marked truncated');
+    assert.equal(result.scope.spec_truncated, true, 'scope should note truncation');
+  });
+});
+
+// ─── graceful degradation ────────────────────────────────────────────────────
+
+describe('graceful degradation', () => {
+  let fixture;
+
+  beforeEach(() => {
+    resetTierCache();
+  });
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    resetTierCache();
+  });
+
+  it('empty .planning directory returns empty files for lite tier', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      // No STATE.md, PROJECT.md etc.
+    });
+
+    const result = loadTierInternal('lite', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.equal(result.tier, 'lite');
+    // config.json exists but PROJECT.md and STATE.md don't
+    assert.ok(result.files.length <= 1, 'should have at most config.json');
+  });
+
+  it('non-existent tier name returns error in result', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    const result = loadTierInternal('invalid-name', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.ok(result.error, 'should have error field');
+    assert.ok(result.error.includes('Unknown tier'), 'error should mention unknown tier');
+    assert.equal(result.files.length, 0, 'should have empty files');
+  });
+
+  it('invalid tier via CLI produces error on stderr', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    const stderr = runContextError(fixture.cwd, 'load-tier invalid-name');
+    assert.ok(stderr, 'should produce error');
+    assert.ok(stderr.includes('invalid tier'), 'error should mention invalid tier');
+  });
+
+  it('missing .planning/config.json falls back gracefully', () => {
+    fixture = createFixture({
+      '.planning/PROJECT.md': '# Project',
+      '.planning/STATE.md': '# State',
+    });
+
+    // The config.json from tier definitions won't be found but that's fine
+    const result = loadTierInternal('lite', path.join(fixture.cwd, '.planning'), { cwd: fixture.cwd });
+    assert.equal(result.tier, 'lite');
+    // PROJECT.md and STATE.md should be found
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(filePaths.some(p => p.includes('PROJECT.md')), 'PROJECT.md should be present');
+    assert.ok(filePaths.some(p => p.includes('STATE.md')), 'STATE.md should be present');
+  });
+});
+
+// ─── CLI integration ─────────────────────────────────────────────────────────
+
+describe('CLI integration', () => {
+  let fixture;
+
+  beforeEach(() => {
+    resetTierCache();
+  });
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    resetTierCache();
+  });
+
+  it('context load-tier lite returns JSON with correct structure', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+    });
+
+    const result = runContext(fixture.cwd, 'load-tier lite');
+    assert.ok(Array.isArray(result.files), 'output should have files array');
+    assert.equal(result.tier, 'lite', 'output should have tier: "lite"');
+    assert.ok(result.scope !== undefined, 'output should have scope');
+  });
+
+  it('context load-tier none returns empty files via CLI', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    const result = runContext(fixture.cwd, 'load-tier none');
+    assert.equal(result.tier, 'none');
+    assert.equal(result.files.length, 0, 'none tier should have 0 files');
+  });
+
+  it('context load-tier planning includes inherited lite files via CLI', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/STATE.md': '# State',
+      '.planning/PROJECT.md': '# Project',
+      '.planning/ROADMAP.md': '# Roadmap',
+      '.planning/REQUIREMENTS.md': '# Requirements',
+    });
+
+    const result = runContext(fixture.cwd, 'load-tier planning');
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(filePaths.some(p => p.includes('PROJECT.md')), 'should include lite tier PROJECT.md');
+    assert.ok(filePaths.some(p => p.includes('ROADMAP.md')), 'should include planning tier ROADMAP.md');
+  });
+
+  it('context load-tier with --phase flag works via CLI', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+      '.planning/PROJECT.md': '# Project',
+      '.planning/STATE.md': '# State',
+      '.planning/ROADMAP.md': '# Roadmap\n\n## Phases\n\n### Phase 1: Test Phase\n',
+      '.planning/REQUIREMENTS.md': '# Requirements',
+      '.planning/phases/01-test-phase/01-CONTEXT.md': '# Context',
+      '.planning/phases/01-test-phase/01-01-PLAN.md': '---\nphase: 01\nplan: 01\n---\n# Plan',
+    });
+
+    const result = runContext(fixture.cwd, 'load-tier execution --phase 1');
+    assert.equal(result.scope.phase, '1', 'scope should record phase');
+    const filePaths = result.files.map(f => f.path);
+    assert.ok(filePaths.some(p => p.includes('CONTEXT.md')), 'should include phase CONTEXT.md');
+  });
+
+  it('context without subcommand produces error', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    const stderr = runContextError(fixture.cwd, '');
+    assert.ok(stderr, 'should produce error');
+    assert.ok(stderr.includes('Unknown context command') || stderr.includes('Available: load-tier'),
+      'error should mention available subcommands');
+  });
+
+  it('context load-tier without tier name produces usage error', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    const stderr = runContextError(fixture.cwd, 'load-tier');
+    assert.ok(stderr, 'should produce error');
+    assert.ok(stderr.includes('Usage:') || stderr.includes('tier-name'),
+      'error should show usage');
+  });
+
+  it('context unknown-subcommand produces error', () => {
+    fixture = createFixture({
+      '.planning/config.json': JSON.stringify({}),
+    });
+
+    const stderr = runContextError(fixture.cwd, 'bogus');
+    assert.ok(stderr, 'should produce error');
+    assert.ok(stderr.includes('Unknown context command'), 'error should mention unknown command');
+  });
+});
+
+// ─── parseSimpleYaml ─────────────────────────────────────────────────────────
+
+describe('parseSimpleYaml', () => {
+  it('parses simple key-value pairs', () => {
+    const result = parseSimpleYaml('tier: none\nincludes_tier: null');
+    assert.equal(result.tier, 'none');
+    assert.equal(result.includes_tier, null);
+  });
+
+  it('parses inline arrays', () => {
+    const result = parseSimpleYaml('files: []');
+    assert.deepEqual(result.files, []);
+  });
+
+  it('parses block arrays with object items', () => {
+    const yaml = 'files:\n  - path: "PROJECT.md"\n    category: "project"\n  - path: "STATE.md"\n    category: "state"';
+    const result = parseSimpleYaml(yaml);
+    assert.ok(Array.isArray(result.files), 'files should be array');
+    assert.equal(result.files.length, 2, 'should have 2 items');
+    assert.equal(result.files[0].path, 'PROJECT.md');
+    assert.equal(result.files[0].category, 'project');
+    assert.equal(result.files[1].path, 'STATE.md');
+    assert.equal(result.files[1].category, 'state');
+  });
+
+  it('parses boolean values', () => {
+    const result = parseSimpleYaml('enabled: true\ndisabled: false');
+    assert.equal(result.enabled, true);
+    assert.equal(result.disabled, false);
+  });
+
+  it('parses numeric values', () => {
+    const result = parseSimpleYaml('count: 42\npi: 3.14');
+    assert.equal(result.count, 42);
+    assert.equal(result.pi, 3.14);
+  });
+
+  it('handles empty objects', () => {
+    const result = parseSimpleYaml('scope_flags: {}');
+    assert.deepEqual(result.scope_flags, {});
+  });
+});
+
+// ─── resolveTierFiles ────────────────────────────────────────────────────────
+
+describe('resolveTierFiles', () => {
+  afterEach(() => {
+    resetTierCache();
+  });
+
+  it('returns empty array for non-existent tier', () => {
+    const tiers = parseTierDefinitions();
+    const result = resolveTierFiles('nonexistent', tiers);
+    assert.deepEqual(result, []);
+  });
+
+  it('returns empty array for none tier', () => {
+    const tiers = parseTierDefinitions();
+    const result = resolveTierFiles('none', tiers);
+    assert.equal(result.length, 0);
+  });
+
+  it('returns lite files for lite tier', () => {
+    const tiers = parseTierDefinitions();
+    const result = resolveTierFiles('lite', tiers);
+    assert.equal(result.length, 3);
+  });
+
+  it('planning tier inherits lite files', () => {
+    const tiers = parseTierDefinitions();
+    const result = resolveTierFiles('planning', tiers);
+    // lite has 3, planning adds 3 more
+    assert.equal(result.length, 6, 'planning should have 6 static files (3 lite + 3 planning)');
+  });
+
+  it('execution tier inherits planning+lite files', () => {
+    const tiers = parseTierDefinitions();
+    const result = resolveTierFiles('execution', tiers);
+    // execution has files: [] itself but inherits from planning which has 6
+    assert.equal(result.length, 6, 'execution inherits all planning files');
+  });
+});