@ktpartners/dgs-platform 2.6.2

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

@@ -0,0 +1,1882 @@
+/**
+ * Tests for repos.cjs — REPOS.md management, prefix-match resolution, discovery, .gitignore sync
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { createTempDir, cleanupDir } = require('./test-helpers.cjs');
+
+// Helper to create .planning/REPOS.md with given content
+function writeReposFile(cwd, content) {
+  const planningDir = path.join(cwd, '.planning');
+  fs.mkdirSync(planningDir, { recursive: true });
+  fs.writeFileSync(path.join(planningDir, 'REPOS.md'), content);
+}
+
+const VALID_REPOS_MD = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+| web-app | ./web-app | https://github.com/org/web-app | React frontend |
+| server | ./server | https://github.com/org/server | Node.js API |
+| shared-lib | ./shared-lib | | Shared TypeScript types and utilities |
+`;
+
+const {
+  parseReposMd,
+  writeReposMd,
+  validateReposMdEager,
+  resolveFileToRepo,
+  discoverRepos,
+  discoverSiblingRepos,
+  syncGitignore,
+  validateRepoPaths,
+  hasPathConflict,
+  writeProjectsMd,
+} = require('./repos.cjs');
+
+// ─── parseReposMd ────────────────────────────────────────────────────────────
+
+describe('parseReposMd', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('returns structured array from valid REPOS.md', () => {
+    writeReposFile(tmpDir, VALID_REPOS_MD);
+    const result = parseReposMd(tmpDir);
+    assert.ok(result);
+    assert.strictEqual(result.repos.length, 3);
+    assert.strictEqual(result.repos[0].name, 'web-app');
+    assert.strictEqual(result.repos[0].path, './web-app');
+    assert.strictEqual(result.repos[0].url, 'https://github.com/org/web-app');
+    assert.strictEqual(result.repos[0].description, 'React frontend');
+  });
+
+  it('returns null when file does not exist', () => {
+    fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true });
+    const result = parseReposMd(tmpDir);
+    assert.strictEqual(result, null);
+  });
+
+  it('returns null when file does not start with # Repos', () => {
+    writeReposFile(tmpDir, '# Something Else\n\nRandom content');
+    const result = parseReposMd(tmpDir);
+    assert.strictEqual(result, null);
+  });
+
+  it('returns empty repos when header exists but table is empty', () => {
+    writeReposFile(tmpDir, `# Repos
+
+Registered repositories.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+`);
+    const result = parseReposMd(tmpDir);
+    assert.ok(result);
+    assert.strictEqual(result.repos.length, 0);
+  });
+
+  it('correctly parses all 4 columns', () => {
+    writeReposFile(tmpDir, VALID_REPOS_MD);
+    const result = parseReposMd(tmpDir);
+    const server = result.repos[1];
+    assert.strictEqual(server.name, 'server');
+    assert.strictEqual(server.path, './server');
+    assert.strictEqual(server.url, 'https://github.com/org/server');
+    assert.strictEqual(server.description, 'Node.js API');
+  });
+
+  it('handles blank GitHub URL', () => {
+    writeReposFile(tmpDir, VALID_REPOS_MD);
+    const result = parseReposMd(tmpDir);
+    const lib = result.repos[2];
+    assert.strictEqual(lib.name, 'shared-lib');
+    assert.strictEqual(lib.url, '');
+  });
+
+  it('handles blank Description', () => {
+    writeReposFile(tmpDir, `# Repos
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+| minimal | ./minimal | | |
+`);
+    const result = parseReposMd(tmpDir);
+    assert.strictEqual(result.repos[0].description, '');
+  });
+
+  it('handles extra whitespace in cells', () => {
+    writeReposFile(tmpDir, `# Repos
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+|  spacey  |  ./spacey  |  https://github.com/x  |  Has spaces  |
+`);
+    const result = parseReposMd(tmpDir);
+    assert.strictEqual(result.repos[0].name, 'spacey');
+    assert.strictEqual(result.repos[0].path, './spacey');
+    assert.strictEqual(result.repos[0].url, 'https://github.com/x');
+    assert.strictEqual(result.repos[0].description, 'Has spaces');
+  });
+
+  it('handles malformed table rows with fewer than 2 columns', () => {
+    writeReposFile(tmpDir, `# Repos
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+| only-one |
+| good | ./good | https://github.com/x | OK |
+`);
+    const result = parseReposMd(tmpDir);
+    // Malformed row should be skipped, good row kept
+    assert.ok(result.repos.length >= 1);
+    const goodRepo = result.repos.find(r => r.name === 'good');
+    assert.ok(goodRepo);
+  });
+});
+
+// ─── writeReposMd ────────────────────────────────────────────────────────────
+
+describe('writeReposMd', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true }); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('creates file with # Repos header', () => {
+    writeReposMd(tmpDir, [{ name: 'app', path: './app', url: '', description: 'App' }]);
+    const content = fs.readFileSync(path.join(tmpDir, '.planning', 'REPOS.md'), 'utf-8');
+    assert.ok(content.startsWith('# Repos'));
+  });
+
+  it('includes explanatory text', () => {
+    writeReposMd(tmpDir, []);
+    const content = fs.readFileSync(path.join(tmpDir, '.planning', 'REPOS.md'), 'utf-8');
+    assert.ok(content.includes('Managed by DGS'));
+  });
+
+  it('writes properly formatted markdown table', () => {
+    writeReposMd(tmpDir, [
+      { name: 'web', path: './web', url: 'https://github.com/org/web', description: 'Frontend' },
+    ]);
+    const content = fs.readFileSync(path.join(tmpDir, '.planning', 'REPOS.md'), 'utf-8');
+    assert.ok(content.includes('| Name | Path | GitHub URL | Description |'));
+    assert.ok(content.includes('|------|------|------------|-------------|'));
+    assert.ok(content.includes('| web | ./web | https://github.com/org/web | Frontend |'));
+  });
+
+  it('handles empty repos array', () => {
+    writeReposMd(tmpDir, []);
+    const content = fs.readFileSync(path.join(tmpDir, '.planning', 'REPOS.md'), 'utf-8');
+    assert.ok(content.includes('| Name | Path | GitHub URL | Description |'));
+    // Should NOT have any data rows
+    const lines = content.split('\n').filter(l => l.startsWith('|'));
+    assert.strictEqual(lines.length, 2); // header + separator only
+  });
+
+  it('writes to .planning/REPOS.md', () => {
+    writeReposMd(tmpDir, []);
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'REPOS.md')));
+  });
+});
+
+// ─── resolveFileToRepo ───────────────────────────────────────────────────────
+
+describe('resolveFileToRepo', () => {
+  const repos = [
+    { name: 'web', path: './web' },
+    { name: 'web-app', path: './web-app' },
+    { name: 'services-api', path: './services/api' },
+    { name: 'services-api-gateway', path: './services/api-gateway' },
+    { name: 'server', path: './server' },
+  ];
+
+  it('matches web-app/src/App.tsx to web-app, NOT web', () => {
+    const result = resolveFileToRepo('web-app/src/App.tsx', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+
+  it('matches web/index.html to web', () => {
+    const result = resolveFileToRepo('web/index.html', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web');
+  });
+
+  it('matches services/api/src/index.ts to services-api, NOT services-api-gateway', () => {
+    const result = resolveFileToRepo('services/api/src/index.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'services-api');
+  });
+
+  it('matches services/api-gateway/routes.ts to services-api-gateway', () => {
+    const result = resolveFileToRepo('services/api-gateway/routes.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'services-api-gateway');
+  });
+
+  it('returns null for CLAUDE.md (product folder file)', () => {
+    const result = resolveFileToRepo('CLAUDE.md', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('returns null for .planning/STATE.md', () => {
+    const result = resolveFileToRepo('.planning/STATE.md', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('handles paths with leading ./', () => {
+    const result = resolveFileToRepo('./web-app/src/App.tsx', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+
+  it('handles repo paths without leading ./', () => {
+    const reposNoPrefix = [{ name: 'server', path: 'server' }];
+    const result = resolveFileToRepo('server/src/index.ts', reposNoPrefix);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'server');
+  });
+
+  it('works with single repo', () => {
+    const singleRepo = [{ name: 'app', path: './app' }];
+    const result = resolveFileToRepo('app/main.js', singleRepo);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'app');
+  });
+
+  it('returns name and path of matched repo', () => {
+    const result = resolveFileToRepo('server/api.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'server');
+    assert.strictEqual(result.path, './server');
+  });
+
+  it('resolves deeply nested paths correctly', () => {
+    const result = resolveFileToRepo('services/api/src/controllers/users/index.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'services-api');
+  });
+
+  it('returns null for empty repos array', () => {
+    const result = resolveFileToRepo('anything/file.ts', []);
+    assert.strictEqual(result, null);
+  });
+
+  it('handles undefined/null filePath gracefully', () => {
+    assert.strictEqual(resolveFileToRepo(null, repos), null);
+    assert.strictEqual(resolveFileToRepo(undefined, repos), null);
+    assert.strictEqual(resolveFileToRepo('', repos), null);
+  });
+});
+
+// ─── discoverRepos ───────────────────────────────────────────────────────────
+
+describe('discoverRepos', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('finds directories containing .git/', () => {
+    fs.mkdirSync(path.join(tmpDir, 'my-repo', '.git'), { recursive: true });
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].name, 'my-repo');
+  });
+
+  it('excludes node_modules', () => {
+    fs.mkdirSync(path.join(tmpDir, 'node_modules', '.git'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'real-repo', '.git'), { recursive: true });
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].name, 'real-repo');
+  });
+
+  it('excludes .planning', () => {
+    fs.mkdirSync(path.join(tmpDir, '.planning', '.git'), { recursive: true });
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('excludes dot-directories', () => {
+    fs.mkdirSync(path.join(tmpDir, '.hidden', '.git'), { recursive: true });
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('excludes non-directories', () => {
+    fs.writeFileSync(path.join(tmpDir, 'file.txt'), 'hello');
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('extracts description from package.json', () => {
+    const repoDir = path.join(tmpDir, 'pkg-repo');
+    fs.mkdirSync(path.join(repoDir, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(repoDir, 'package.json'), JSON.stringify({ description: 'A test package' }));
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result[0].description, 'A test package');
+  });
+
+  it('falls back to README first non-header line', () => {
+    const repoDir = path.join(tmpDir, 'readme-repo');
+    fs.mkdirSync(path.join(repoDir, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(repoDir, 'README.md'), '# Title\n\nThis is the description line.\n');
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result[0].description, 'This is the description line.');
+  });
+
+  it('returns empty description when no package.json or README', () => {
+    fs.mkdirSync(path.join(tmpDir, 'bare-repo', '.git'), { recursive: true });
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result[0].description, '');
+  });
+
+  it('returns repos with name, path, url, description', () => {
+    fs.mkdirSync(path.join(tmpDir, 'my-repo', '.git'), { recursive: true });
+    const result = discoverRepos(tmpDir);
+    assert.ok('name' in result[0]);
+    assert.ok('path' in result[0]);
+    assert.ok('url' in result[0]);
+    assert.ok('description' in result[0]);
+    assert.strictEqual(result[0].path, './my-repo');
+  });
+
+  it('returns empty array when directory has no git repos', () => {
+    fs.mkdirSync(path.join(tmpDir, 'not-a-repo'));
+    fs.mkdirSync(path.join(tmpDir, 'also-not'));
+    const result = discoverRepos(tmpDir);
+    assert.strictEqual(result.length, 0);
+  });
+});
+
+// ─── discoverSiblingRepos ─────────────────────────────────────────────────────
+
+describe('discoverSiblingRepos', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('finds sibling directories containing .git/', () => {
+    // tmpDir acts as parent; product-root and sibling-repo are siblings
+    fs.mkdirSync(path.join(tmpDir, 'product-root'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'sibling-repo', '.git'), { recursive: true });
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].name, 'sibling-repo');
+    assert.strictEqual(result[0].path, '../sibling-repo');
+  });
+
+  it('excludes the product root directory itself', () => {
+    fs.mkdirSync(path.join(tmpDir, 'product-root', '.git'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'sibling', '.git'), { recursive: true });
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].name, 'sibling');
+    // product-root must NOT appear
+    const names = result.map(r => r.name);
+    assert.ok(!names.includes('product-root'));
+  });
+
+  it('excludes dot-directories and node_modules', () => {
+    fs.mkdirSync(path.join(tmpDir, 'product-root'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, '.hidden', '.git'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'node_modules', '.git'), { recursive: true });
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('excludes directories without .git/', () => {
+    fs.mkdirSync(path.join(tmpDir, 'product-root'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'not-a-repo'), { recursive: true });
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result.length, 0);
+  });
+
+  it('uses ../ path prefix for sibling repos', () => {
+    fs.mkdirSync(path.join(tmpDir, 'product-root'), { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'my-app', '.git'), { recursive: true });
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result[0].path, '../my-app');
+  });
+
+  it('extracts description from sibling repo package.json', () => {
+    fs.mkdirSync(path.join(tmpDir, 'product-root'), { recursive: true });
+    const pkgRepo = path.join(tmpDir, 'pkg-repo');
+    fs.mkdirSync(path.join(pkgRepo, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(pkgRepo, 'package.json'), JSON.stringify({ description: 'Sibling package desc' }));
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result[0].description, 'Sibling package desc');
+  });
+
+  it('returns empty array when parent dir has no git repos besides self', () => {
+    fs.mkdirSync(path.join(tmpDir, 'product-root', '.git'), { recursive: true });
+    const result = discoverSiblingRepos(path.join(tmpDir, 'product-root'));
+    assert.strictEqual(result.length, 0);
+  });
+});
+
+// ─── syncGitignore ───────────────────────────────────────────────────────────
+
+describe('syncGitignore', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('creates .gitignore with DGS section when file does not exist', () => {
+    syncGitignore(tmpDir, ['./web-app', './server']);
+    assert.ok(fs.existsSync(path.join(tmpDir, '.gitignore')));
+  });
+
+  it('includes DGS marker comments', () => {
+    syncGitignore(tmpDir, ['./web-app']);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(content.includes('# DGS managed repos - do not edit below'));
+    assert.ok(content.includes('# end DGS managed repos'));
+  });
+
+  it('preserves existing non-DGS entries', () => {
+    fs.writeFileSync(path.join(tmpDir, '.gitignore'), 'node_modules/\n.env\n');
+    syncGitignore(tmpDir, ['./web-app']);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(content.includes('node_modules/'));
+    assert.ok(content.includes('.env'));
+  });
+
+  it('replaces DGS section on subsequent calls', () => {
+    syncGitignore(tmpDir, ['./web-app']);
+    syncGitignore(tmpDir, ['./server']);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(!content.includes('web-app/'));
+    assert.ok(content.includes('server/'));
+    // Only one pair of markers
+    const starts = content.split('# DGS managed repos - do not edit below').length - 1;
+    assert.strictEqual(starts, 1);
+  });
+
+  it('includes repo paths with trailing /', () => {
+    syncGitignore(tmpDir, ['./web-app']);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(content.includes('web-app/'));
+  });
+
+  it('handles empty repoPaths array (no-op)', () => {
+    // Empty array after filtering means no .gitignore modification
+    fs.writeFileSync(path.join(tmpDir, '.gitignore'), 'node_modules/\n');
+    syncGitignore(tmpDir, []);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.strictEqual(content, 'node_modules/\n', '.gitignore should be unchanged');
+    assert.ok(!content.includes('# DGS managed repos'), 'No DGS markers for empty paths');
+  });
+
+  it('strips ./ prefix from paths', () => {
+    syncGitignore(tmpDir, ['./web-app']);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(!content.includes('./web-app'));
+    assert.ok(content.includes('web-app/'));
+  });
+
+  it('second call with different list replaces first', () => {
+    syncGitignore(tmpDir, ['./alpha', './beta']);
+    syncGitignore(tmpDir, ['./gamma']);
+    const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(!content.includes('alpha/'));
+    assert.ok(!content.includes('beta/'));
+    assert.ok(content.includes('gamma/'));
+  });
+
+  it('preserves content before AND after DGS section', () => {
+    // Create initial .gitignore with content before the section
+    fs.writeFileSync(path.join(tmpDir, '.gitignore'), 'node_modules/\n.env\n');
+    syncGitignore(tmpDir, ['./web-app']);
+    // Now manually add content after the section
+    let content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    content += '\n# Custom trailing section\n*.log\n';
+    fs.writeFileSync(path.join(tmpDir, '.gitignore'), content);
+    // Now sync again — should preserve both before and after
+    syncGitignore(tmpDir, ['./server']);
+    const final = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf-8');
+    assert.ok(final.includes('node_modules/'));
+    assert.ok(final.includes('.env'));
+    assert.ok(final.includes('*.log'));
+    assert.ok(final.includes('server/'));
+    assert.ok(!final.includes('web-app/'));
+  });
+});
+
+// ─── validateRepoPaths ───────────────────────────────────────────────────────
+
+describe('validateRepoPaths', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('returns valid and missing arrays', () => {
+    fs.mkdirSync(path.join(tmpDir, 'existing'));
+    const repos = [
+      { name: 'existing', path: './existing' },
+      { name: 'gone', path: './gone' },
+    ];
+    const result = validateRepoPaths(tmpDir, repos);
+    assert.ok(Array.isArray(result.valid));
+    assert.ok(Array.isArray(result.missing));
+  });
+
+  it('reports existing repos in valid', () => {
+    fs.mkdirSync(path.join(tmpDir, 'myrepo'));
+    const repos = [{ name: 'myrepo', path: './myrepo' }];
+    const result = validateRepoPaths(tmpDir, repos);
+    assert.strictEqual(result.valid.length, 1);
+    assert.strictEqual(result.valid[0].name, 'myrepo');
+  });
+
+  it('reports missing repos in missing', () => {
+    const repos = [{ name: 'gone', path: './gone' }];
+    const result = validateRepoPaths(tmpDir, repos);
+    assert.strictEqual(result.missing.length, 1);
+    assert.strictEqual(result.missing[0].name, 'gone');
+  });
+
+  it('handles empty repos array', () => {
+    const result = validateRepoPaths(tmpDir, []);
+    assert.strictEqual(result.valid.length, 0);
+    assert.strictEqual(result.missing.length, 0);
+  });
+});
+
+// ─── hasPathConflict ─────────────────────────────────────────────────────────
+
+describe('hasPathConflict', () => {
+  it('detects new path as prefix of existing', () => {
+    const existing = [{ name: 'api', path: './services/api' }];
+    const result = hasPathConflict('./services', existing);
+    assert.strictEqual(result.conflict, true);
+  });
+
+  it('detects existing path as prefix of new', () => {
+    const existing = [{ name: 'services', path: './services' }];
+    const result = hasPathConflict('./services/api', existing);
+    assert.strictEqual(result.conflict, true);
+  });
+
+  it('no conflict for unrelated paths', () => {
+    const existing = [{ name: 'server', path: './server' }];
+    const result = hasPathConflict('./web-app', existing);
+    assert.strictEqual(result.conflict, false);
+  });
+
+  it('no conflict for paths sharing characters but not prefix boundary', () => {
+    const existing = [{ name: 'web', path: './web' }];
+    const result = hasPathConflict('./web-app', existing);
+    assert.strictEqual(result.conflict, false);
+  });
+
+  it('detects conflict with identical paths (same repo twice)', () => {
+    const existing = [{ name: 'api', path: './api' }];
+    const result = hasPathConflict('./api', existing);
+    assert.strictEqual(result.conflict, true);
+  });
+});
+
+// ─── writeProjectsMd ─────────────────────────────────────────────────────────
+
+describe('writeProjectsMd', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true }); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('creates file with # Projects header', () => {
+    writeProjectsMd(tmpDir, []);
+    const content = fs.readFileSync(path.join(tmpDir, '.planning', 'PROJECTS.md'), 'utf-8');
+    assert.ok(content.startsWith('# Projects'));
+  });
+
+  it('includes Active and Completed sections', () => {
+    writeProjectsMd(tmpDir, []);
+    const content = fs.readFileSync(path.join(tmpDir, '.planning', 'PROJECTS.md'), 'utf-8');
+    assert.ok(content.includes('## Active'));
+    assert.ok(content.includes('## Completed'));
+  });
+
+  it('writes to .planning/PROJECTS.md', () => {
+    writeProjectsMd(tmpDir, []);
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'PROJECTS.md')));
+  });
+});
+
+// ─── Roundtrip ───────────────────────────────────────────────────────────────
+
+describe('writeReposMd -> parseReposMd roundtrip', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); fs.mkdirSync(path.join(tmpDir, '.planning'), { recursive: true }); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('write then parse produces identical data', () => {
+    const repos = [
+      { name: 'web', path: './web', url: 'https://github.com/org/web', description: 'Frontend' },
+      { name: 'api', path: './api', url: '', description: 'Backend API' },
+    ];
+    writeReposMd(tmpDir, repos);
+    const parsed = parseReposMd(tmpDir);
+    assert.ok(parsed);
+    assert.strictEqual(parsed.repos.length, 2);
+    assert.deepStrictEqual(parsed.repos[0], repos[0]);
+    assert.deepStrictEqual(parsed.repos[1], repos[1]);
+  });
+});
+
+// ─── autoPopulateReposTags ──────────────────────────────────────────────────
+
+const { autoPopulateReposTags, validateReposConsistency } = require('./repos.cjs');
+
+describe('autoPopulateReposTags', () => {
+  const repos = [
+    { name: 'my-app', path: './my-app' },
+    { name: 'api-service', path: './api-service' },
+    { name: 'services-api', path: './services/api' },
+    { name: 'services', path: './services' },
+  ];
+
+  it('single file, single repo — populates repos tag', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('multiple files, same repo — single repo in tag', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/a.js, my-app/src/b.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+  });
+
+  it('multiple files, different repos — sorted alphabetically', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/a.js, api-service/src/b.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>api-service, my-app</repos>'));
+  });
+
+  it('file not matching any repo — warning about repo-relative paths, no repo added', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>unknown/file.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.warnings.length > 0);
+    // With repo-relative path support, unresolvable files trigger repo-relative warning
+    assert.ok(result.warnings[0].includes('repo-relative'));
+    // Content should be unchanged (no repos tag added)
+    assert.ok(!result.content.includes('<repos>'));
+  });
+
+  it('existing repos tag gets replaced with auto-populated values', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>old-repo</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+    assert.ok(!result.content.includes('old-repo'));
+  });
+
+  it('empty files block — empty repos tag, no error', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files></files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos></repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('multiple tasks each get their own repos tag', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>
+<task type="auto">
+  <name>Task 2</name>
+  <files>api-service/src/server.js</files>
+  <action>Do something else</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+    assert.ok(result.content.includes('<repos>api-service</repos>'));
+  });
+
+  it('repos not in initial_repos are accepted (auto-expansion)', () => {
+    const limitedRepos = [
+      { name: 'my-app', path: './my-app' },
+      { name: 'extra-repo', path: './extra-repo' },
+    ];
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>extra-repo/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, limitedRepos);
+    assert.ok(result.content.includes('<repos>extra-repo</repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('file paths with ./ prefix are normalized', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>./my-app/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+  });
+
+  it('longest-prefix-match: services/api/src/index.js matches services/api not services', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>services/api/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>services-api</repos>'));
+  });
+
+  it('files on separate lines are handled', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>
+my-app/src/a.js
+api-service/src/b.js
+  </files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>api-service, my-app</repos>'));
+  });
+
+  it('mixed known and unknown files — repos populated and warnings for unknowns', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js, unknown/file.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+    assert.ok(result.warnings.length > 0);
+  });
+});
+
+// ─── validateReposConsistency ───────────────────────────────────────────────
+
+describe('validateReposConsistency', () => {
+  const repos = [
+    { name: 'my-app', path: './my-app' },
+    { name: 'api-service', path: './api-service' },
+    { name: 'shared-lib', path: './shared-lib' },
+  ];
+
+  it('consistent plan passes validation', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, true);
+    assert.strictEqual(result.mismatches.length, 0);
+  });
+
+  it('extra repo in repos tag — mismatch with extra', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>my-app, shared-lib</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, false);
+    assert.strictEqual(result.mismatches.length, 1);
+    assert.ok(result.mismatches[0].extra.includes('shared-lib'));
+  });
+
+  it('missing repo in repos tag — mismatch with missing', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js, api-service/src/server.js</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, false);
+    assert.strictEqual(result.mismatches.length, 1);
+    assert.ok(result.mismatches[0].missing.includes('api-service'));
+  });
+
+  it('empty repos and files — valid', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files></files>
+  <repos></repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, true);
+    assert.strictEqual(result.mismatches.length, 0);
+  });
+
+  it('multiple mismatches across multiple tasks', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>shared-lib</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>
+<task type="auto">
+  <name>Task 2</name>
+  <files>api-service/src/server.js</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, false);
+    assert.strictEqual(result.mismatches.length, 2);
+  });
+
+  it('mismatch includes task name, repos_listed, repos_derived, extra, missing', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>my-app, shared-lib</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    const mm = result.mismatches[0];
+    assert.ok('task' in mm);
+    assert.ok('repos_listed' in mm);
+    assert.ok('repos_derived' in mm);
+    assert.ok('extra' in mm);
+    assert.ok('missing' in mm);
+  });
+
+  it('task without repos tag treated as empty listed repos', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, false);
+    assert.ok(result.mismatches[0].missing.includes('my-app'));
+  });
+});
+
+// ─── resolveFileToRepo edge cases (Pitfall 2) ──────────────────────────────
+
+describe('resolveFileToRepo edge cases (Pitfall 2)', () => {
+  const repos = [
+    { name: 'web', path: './web' },
+    { name: 'web-app', path: './web-app' },
+    { name: 'services-api', path: './services/api' },
+    { name: 'services-api-gateway', path: './services/api-gateway' },
+    { name: 'server', path: './server' },
+  ];
+
+  // 1. Bare repo path (no trailing slash, no file after it)
+  it('bare repo path "web-app" returns null (ambiguous)', () => {
+    const result = resolveFileToRepo('web-app', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('bare repo path "server" returns null (ambiguous)', () => {
+    const result = resolveFileToRepo('server', repos);
+    assert.strictEqual(result, null);
+  });
+
+  // 2. File path with trailing slash
+  it('repo path with trailing slash "web-app/" returns null (directory, not file)', () => {
+    const result = resolveFileToRepo('web-app/', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('subpath with trailing slash "web-app/src/" matches web-app (trailing slash normalized)', () => {
+    const result = resolveFileToRepo('web-app/src/', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+
+  // 3. Multiple ./ variations — explicit equality assertion
+  it('./web-app/file.ts and web-app/file.ts return identical results', () => {
+    const withDot = resolveFileToRepo('./web-app/file.ts', repos);
+    const without = resolveFileToRepo('web-app/file.ts', repos);
+    assert.deepStrictEqual(withDot, without);
+  });
+
+  // 4. Nested repos with confusing prefixes (explicit regression)
+  it('services/api-gateway/handler.ts must be services-api-gateway', () => {
+    const result = resolveFileToRepo('services/api-gateway/handler.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'services-api-gateway');
+  });
+
+  it('services/api/handler.ts must be services-api', () => {
+    const result = resolveFileToRepo('services/api/handler.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'services-api');
+  });
+
+  it('services/apifoo/handler.ts must be null (no matching repo)', () => {
+    const result = resolveFileToRepo('services/apifoo/handler.ts', repos);
+    assert.strictEqual(result, null);
+  });
+
+  // 5. Path with redundant separators
+  it('double slashes "web-app//src/file.ts" matches web-app (normalized)', () => {
+    const result = resolveFileToRepo('web-app//src/file.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+});
+
+// ─── Edge Cases: autoPopulateReposTags ──────────────────────────────────────
+
+describe('autoPopulateReposTags edge cases', () => {
+  const repos = [
+    { name: 'my-app', path: './my-app' },
+    { name: 'api-service', path: './api-service' },
+  ];
+
+  it('plan with no task blocks returns unchanged content', () => {
+    const plan = `---
+phase: 04
+plan: 01
+---
+<objective>Some plan</objective>
+<verification>Check stuff</verification>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.strictEqual(result.content, plan);
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('file path with trailing whitespace/newlines is trimmed', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>  my-app/src/index.js  </files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('repo path with ./ prefix in repos array is normalized correctly', () => {
+    const reposWithDotSlash = [
+      { name: 'my-app', path: './my-app' },
+    ];
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, reposWithDotSlash);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+  });
+
+  it('repos tag already correct matches derived — no change needed', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('roundtrip: autoPopulate then validate produces valid result', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/a.js, api-service/src/b.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const populated = autoPopulateReposTags(plan, repos);
+    const validation = validateReposConsistency(populated.content, repos);
+    assert.strictEqual(validation.valid, true);
+    assert.strictEqual(validation.mismatches.length, 0);
+  });
+
+  it('task with files tag but no closing files tag is handled gracefully', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    // No <files> closing tag means regex won't match — task returned unchanged
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(!result.content.includes('<repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+});
+
+// ─── autoPopulateReposTags with repo-relative paths ─────────────────────────
+
+describe('autoPopulateReposTags with repo-relative paths', () => {
+  const repos = [
+    { name: 'my-app', path: './my-app' },
+    { name: 'api-service', path: './api-service' },
+  ];
+
+  it('repo-relative files with existing <repos> tag — returns content unchanged, no warnings', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>src/index.ts, src/app.ts</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    // Content should be unchanged — existing repos tag preserved
+    assert.strictEqual(result.content, plan);
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('repo-relative files with NO <repos> tag — returns warning about manual tag needed', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>src/index.ts, src/app.ts</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    // Content should be unchanged (no repos could be derived)
+    assert.strictEqual(result.content, plan);
+    // Should have a warning about adding repos tag manually
+    assert.ok(result.warnings.length > 0);
+    assert.ok(result.warnings[0].includes('repo-relative'));
+  });
+
+  it('backwards compat: product-root-relative paths still auto-populate correctly', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js, api-service/src/server.js</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    assert.ok(result.content.includes('<repos>api-service, my-app</repos>'));
+    assert.strictEqual(result.warnings.length, 0);
+  });
+
+  it('mixed: some product-root-relative, some repo-relative — handles gracefully', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js, src/utils.ts</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = autoPopulateReposTags(plan, repos);
+    // my-app/src/index.js resolves to my-app, src/utils.ts does not resolve
+    // Since at least one file resolved, it populates repos from the resolved ones
+    assert.ok(result.content.includes('<repos>my-app</repos>'));
+  });
+});
+
+// ─── validateReposConsistency with repo-relative paths ───────────────────────
+
+describe('validateReposConsistency with repo-relative paths', () => {
+  const repos = [
+    { name: 'my-app', path: './my-app' },
+    { name: 'api-service', path: './api-service' },
+  ];
+
+  it('repo-relative files with matching <repos> tag — valid: true', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>src/index.ts, src/app.ts</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, true);
+    assert.strictEqual(result.mismatches.length, 0);
+  });
+
+  it('repo-relative files and no <repos> tag — valid: true (no repos on either side)', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>src/index.ts</files>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    // Neither derived nor listed repos — no mismatch
+    assert.strictEqual(result.valid, true);
+    assert.strictEqual(result.mismatches.length, 0);
+  });
+
+  it('backwards compat: product-root-relative files — works as before', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>my-app</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, true);
+    assert.strictEqual(result.mismatches.length, 0);
+  });
+
+  it('backwards compat: product-root-relative files with wrong repos tag — still detects mismatch', () => {
+    const plan = `<task type="auto">
+  <name>Task 1</name>
+  <files>my-app/src/index.js</files>
+  <repos>api-service</repos>
+  <action>Do something</action>
+  <verify>Check it</verify>
+  <done>Done</done>
+</task>`;
+    const result = validateReposConsistency(plan, repos);
+    assert.strictEqual(result.valid, false);
+    assert.strictEqual(result.mismatches.length, 1);
+  });
+});
+
+// ─── resolveFileToRepo with ../repo paths ───────────────────────────────────
+
+describe('resolveFileToRepo with ../repo paths', () => {
+  const repos = [
+    { name: 'web-app', path: '../web-app' },
+    { name: 'web', path: '../web' },
+    { name: 'api-service', path: '../api-service' },
+    { name: 'server', path: '../server' },
+  ];
+
+  it('matches ../web-app/src/App.tsx to web-app', () => {
+    const result = resolveFileToRepo('../web-app/src/App.tsx', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+    assert.strictEqual(result.path, '../web-app');
+  });
+
+  it('longest prefix: ../web-app matches over ../web', () => {
+    const result = resolveFileToRepo('../web-app/src/App.tsx', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+
+  it('bare path web-app/src/App.tsx also matches ../web-app repo', () => {
+    const result = resolveFileToRepo('web-app/src/App.tsx', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+
+  it('bare repo path ../web-app returns null (no file after it)', () => {
+    const result = resolveFileToRepo('../web-app', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('trailing slash ../web-app/ returns null (directory not file)', () => {
+    const result = resolveFileToRepo('../web-app/', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('double slash ../web-app//src/file.ts normalized and matches', () => {
+    const result = resolveFileToRepo('../web-app//src/file.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web-app');
+  });
+
+  it('absolute path resolves to correct repo when cwd is provided', () => {
+    const cwd = '/Users/foo/product-root';
+    const result = resolveFileToRepo('/Users/foo/api-service/src/bar.ts', repos, cwd);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'api-service');
+  });
+
+  it('../web/index.html matches web, not web-app', () => {
+    const result = resolveFileToRepo('../web/index.html', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'web');
+  });
+
+  it('returns null for unmatched ../unknown/file.ts', () => {
+    const result = resolveFileToRepo('../unknown/file.ts', repos);
+    assert.strictEqual(result, null);
+  });
+
+  it('handles deeply nested paths', () => {
+    const result = resolveFileToRepo('../api-service/src/controllers/users/index.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'api-service');
+  });
+
+  it('../server/api.ts returns name and path', () => {
+    const result = resolveFileToRepo('../server/api.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'server');
+    assert.strictEqual(result.path, '../server');
+  });
+});
+
+// ─── hasPathConflict with ../repo paths ─────────────────────────────────────
+
+describe('hasPathConflict with ../repo paths', () => {
+  it('../app and ../app-admin do NOT conflict (different directory boundary)', () => {
+    const existing = [{ name: 'app-admin', path: '../app-admin' }];
+    const result = hasPathConflict('../app', existing);
+    assert.strictEqual(result.conflict, false);
+  });
+
+  it('../app and ../app conflict (identical path)', () => {
+    const existing = [{ name: 'app', path: '../app' }];
+    const result = hasPathConflict('../app', existing);
+    assert.strictEqual(result.conflict, true);
+  });
+
+  it('../services/api conflicts with ../services (prefix conflict)', () => {
+    const existing = [{ name: 'services', path: '../services' }];
+    const result = hasPathConflict('../services/api', existing);
+    assert.strictEqual(result.conflict, true);
+  });
+
+  it('../services conflicts with ../services/api (reverse prefix conflict)', () => {
+    const existing = [{ name: 'services-api', path: '../services/api' }];
+    const result = hasPathConflict('../services', existing);
+    assert.strictEqual(result.conflict, true);
+  });
+
+  it('../web and ../web-app do NOT conflict', () => {
+    const existing = [{ name: 'web-app', path: '../web-app' }];
+    const result = hasPathConflict('../web', existing);
+    assert.strictEqual(result.conflict, false);
+  });
+});
+
+// ─── Path normalization for ../repo paths ───────────────────────────────────
+
+describe('Path normalization for ../repo paths', () => {
+  const repos = [
+    { name: 'repo', path: '../repo' },
+  ];
+
+  it('trailing slash stripped: ../repo/src/file.ts/ normalizes and matches', () => {
+    const result = resolveFileToRepo('../repo/src/file.ts/', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'repo');
+  });
+
+  it('double separator collapsed: ../repo//src/file.ts matches', () => {
+    const result = resolveFileToRepo('../repo//src/file.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'repo');
+  });
+
+  it('./repo/src/file.ts and ../repo/src/file.ts both normalize to match', () => {
+    const dotSlashRepos = [{ name: 'repo', path: './repo' }];
+    const dotDotRepos = [{ name: 'repo', path: '../repo' }];
+    const r1 = resolveFileToRepo('./repo/src/file.ts', dotSlashRepos);
+    const r2 = resolveFileToRepo('../repo/src/file.ts', dotDotRepos);
+    assert.ok(r1);
+    assert.ok(r2);
+    assert.strictEqual(r1.name, r2.name);
+  });
+
+  it('bare path repo/src/file.ts matches when repo is ../repo', () => {
+    const result = resolveFileToRepo('repo/src/file.ts', repos);
+    assert.ok(result);
+    assert.strictEqual(result.name, 'repo');
+  });
+});
+
+// ─── cmdReposAdd ../name format enforcement ──────────────────────────────────
+
+describe('cmdReposAdd ../name format enforcement', () => {
+  let tmpDir;
+  const { execSync } = require('child_process');
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    // Create a flat layout: product-root with .planning, and sibling repos
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+    // Write initial REPOS.md
+    const reposMd = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+`;
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    // Create sibling repo with .git
+    const siblingRepo = path.join(tmpDir, 'my-repo');
+    fs.mkdirSync(path.join(siblingRepo, '.git'), { recursive: true });
+    // Create sibling without .git
+    const noGitRepo = path.join(tmpDir, 'no-git-repo');
+    fs.mkdirSync(noGitRepo, { recursive: true });
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  // Helper to test cmdReposAdd via subprocess (it calls error() which does process.exit)
+  function runCmdReposAdd(cwd, repoPath, opts) {
+    const reposPath = require.resolve('./repos.cjs');
+    const script = `
+      const repos = require('${reposPath.replace(/\\/g, '\\\\')}');
+      let exitMsg = null;
+      let exitCode = null;
+      const origExit = process.exit;
+      process.exit = (code) => { exitCode = code; throw new Error('EXIT:' + code + ':' + exitMsg); };
+      const origStderr = process.stderr.write;
+      process.stderr.write = (data) => { exitMsg = data; };
+      const origStdout = process.stdout.write;
+      let stdoutData = '';
+      process.stdout.write = (data) => { stdoutData += data; };
+      try {
+        repos.cmdReposAdd('${cwd.replace(/\\/g, '\\\\')}', '${repoPath}', ${JSON.stringify(opts || {})}, true);
+        process.stdout.write = origStdout;
+        console.log(JSON.stringify({success: true, output: stdoutData}));
+      } catch (e) {
+        process.stderr.write = origStderr;
+        process.stdout.write = origStdout;
+        process.exit = origExit;
+        if (exitCode === 0) {
+          console.log(JSON.stringify({success: true, output: stdoutData}));
+        } else {
+          console.log(JSON.stringify({success: false, error: e.message}));
+        }
+      }
+    `;
+    const result = execSync(`node -e '${script.replace(/'/g, "'\\''")}'`, { encoding: 'utf-8', timeout: 5000 }).trim();
+    return JSON.parse(result);
+  }
+
+  it('rejects ./repo path', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, './my-repo', {});
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('Repo paths must use ../name format'));
+  });
+
+  it('rejects ../../deep/repo path', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../../deep/repo', {});
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('Repo paths must use ../name format'));
+  });
+
+  it('rejects /absolute/path', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '/absolute/path', {});
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('Repo paths must use ../name format'));
+  });
+
+  it('rejects bare repo path (no ../ prefix)', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, 'repo', {});
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('Repo paths must use ../name format'));
+  });
+
+  it('validates .git exists in target directory', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../no-git-repo', {});
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('not a git repository'));
+  });
+
+  it('error message includes fix suggestion when repo not found', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../nonexistent', {});
+    assert.strictEqual(result.success, false);
+    assert.ok(result.error.includes('not found at'));
+    assert.ok(result.error.includes('check the path in REPOS.md or clone the repo there'));
+  });
+
+  it('accepts valid ../repo path with .git', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../my-repo', {});
+    assert.strictEqual(result.success, true);
+  });
+});
+
+// ─── cmdReposAdd trailing slash normalization ────────────────────────────────
+
+describe('cmdReposAdd trailing slash normalization', () => {
+  let tmpDir;
+  const { execSync } = require('child_process');
+
+  beforeEach(() => {
+    tmpDir = createTempDir();
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+    const reposMd = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+`;
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    // Create sibling repo with .git
+    const siblingRepo = path.join(tmpDir, 'sibling-repo');
+    fs.mkdirSync(path.join(siblingRepo, '.git'), { recursive: true });
+  });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  function runCmdReposAdd(cwd, repoPath, opts) {
+    const reposPath = require.resolve('./repos.cjs');
+    const script = `
+      const repos = require('${reposPath.replace(/\\/g, '\\\\')}');
+      let exitMsg = null;
+      let exitCode = null;
+      const origExit = process.exit;
+      process.exit = (code) => { exitCode = code; throw new Error('EXIT:' + code + ':' + exitMsg); };
+      const origStderr = process.stderr.write;
+      process.stderr.write = (data) => { exitMsg = data; };
+      const origStdout = process.stdout.write;
+      let stdoutData = '';
+      process.stdout.write = (data) => { stdoutData += data; };
+      try {
+        repos.cmdReposAdd('${cwd.replace(/\\/g, '\\\\')}', '${repoPath}', ${JSON.stringify(opts || {})}, true);
+        process.stdout.write = origStdout;
+        console.log(JSON.stringify({success: true, output: stdoutData}));
+      } catch (e) {
+        process.stderr.write = origStderr;
+        process.stdout.write = origStdout;
+        process.exit = origExit;
+        if (exitCode === 0) {
+          console.log(JSON.stringify({success: true, output: stdoutData}));
+        } else {
+          console.log(JSON.stringify({success: false, error: e.message}));
+        }
+      }
+    `;
+    const result = execSync(`node -e '${script.replace(/'/g, "'\\''")}'`, { encoding: 'utf-8', timeout: 5000 }).trim();
+    return JSON.parse(result);
+  }
+
+  function getStoredPath(productRoot) {
+    const content = fs.readFileSync(path.join(productRoot, '.planning', 'REPOS.md'), 'utf-8');
+    const lines = content.split('\n').filter(l => l.startsWith('|') && !l.includes('---') && !l.includes('Name'));
+    if (lines.length === 0) return null;
+    const cols = lines[0].split('|').map(c => c.trim()).filter(Boolean);
+    return cols[1]; // Path column
+  }
+
+  it('strips single trailing slash from ../repo/', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../sibling-repo/', {});
+    assert.strictEqual(result.success, true);
+    const storedPath = getStoredPath(productRoot);
+    assert.strictEqual(storedPath, '../sibling-repo');
+  });
+
+  it('strips multiple trailing slashes from ../repo///', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../sibling-repo///', {});
+    assert.strictEqual(result.success, true);
+    const storedPath = getStoredPath(productRoot);
+    assert.strictEqual(storedPath, '../sibling-repo');
+  });
+
+  it('works normally without trailing slash', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    const result = runCmdReposAdd(productRoot, '../sibling-repo', {});
+    assert.strictEqual(result.success, true);
+    const storedPath = getStoredPath(productRoot);
+    assert.strictEqual(storedPath, '../sibling-repo');
+  });
+});
+
+// ─── validateReposMdEager ────────────────────────────────────────────────────
+
+describe('validateReposMdEager', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  function setupFlatLayout(tmpDir, entries) {
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+
+    let reposMd = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+`;
+    for (const entry of entries) {
+      reposMd += `| ${entry.name} | ${entry.path} | | Test repo |\n`;
+      if (entry.createDir) {
+        fs.mkdirSync(path.join(tmpDir, entry.name), { recursive: true });
+      }
+      if (entry.createGit) {
+        fs.mkdirSync(path.join(tmpDir, entry.name, '.git'), { recursive: true });
+      }
+    }
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    return productRoot;
+  }
+
+  it('detects missing directory', () => {
+    const cwd = setupFlatLayout(tmpDir, [
+      { name: 'ghost-repo', path: '../ghost-repo', createDir: false, createGit: false },
+    ]);
+    const result = validateReposMdEager(cwd);
+    assert.ok(result.errors.length > 0);
+    assert.ok(result.errors[0].includes('not found at'));
+  });
+
+  it('detects missing .git', () => {
+    const cwd = setupFlatLayout(tmpDir, [
+      { name: 'no-git', path: '../no-git', createDir: true, createGit: false },
+    ]);
+    const result = validateReposMdEager(cwd);
+    assert.ok(result.errors.length > 0);
+    assert.ok(result.errors[0].includes('not a git repository'));
+  });
+
+  it('detects duplicate absolute paths', () => {
+    // Create a repo that will be referenced by two different names
+    const repoDir = path.join(tmpDir, 'shared');
+    fs.mkdirSync(path.join(repoDir, '.git'), { recursive: true });
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+
+    const reposMd = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+| shared-a | ../shared | | First ref |
+| shared-b | ../shared | | Duplicate ref |
+`;
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    const result = validateReposMdEager(productRoot);
+    assert.ok(result.errors.length > 0);
+    assert.ok(result.errors[0].includes('Duplicate path'));
+  });
+
+  it('passes for valid ../repo entries', () => {
+    const cwd = setupFlatLayout(tmpDir, [
+      { name: 'valid-repo', path: '../valid-repo', createDir: true, createGit: true },
+    ]);
+    const result = validateReposMdEager(cwd);
+    assert.strictEqual(result.errors.length, 0);
+    assert.strictEqual(result.repos.length, 1);
+    assert.strictEqual(result.repos[0].name, 'valid-repo');
+  });
+
+  it('rejects ./repo path format', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+    fs.mkdirSync(path.join(productRoot, 'local-repo', '.git'), { recursive: true });
+
+    const reposMd = `# Repos
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+| local-repo | ./local-repo | | Local repo |
+`;
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    const result = validateReposMdEager(productRoot);
+    assert.ok(result.errors.length > 0);
+    assert.ok(result.errors[0].includes('Repo paths must use ../name format'));
+  });
+});
+
+// ─── validateRepoPaths with ../repo paths ────────────────────────────────────
+
+describe('validateRepoPaths with ../repo paths', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('validates ../repo paths that exist on disk', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(productRoot, { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'sibling-repo'), { recursive: true });
+
+    const repos = [{ name: 'sibling-repo', path: '../sibling-repo' }];
+    const result = validateRepoPaths(productRoot, repos);
+    assert.strictEqual(result.valid.length, 1);
+    assert.strictEqual(result.missing.length, 0);
+  });
+
+  it('detects missing ../repo paths', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(productRoot, { recursive: true });
+
+    const repos = [{ name: 'gone-repo', path: '../gone-repo' }];
+    const result = validateRepoPaths(productRoot, repos);
+    assert.strictEqual(result.valid.length, 0);
+    assert.strictEqual(result.missing.length, 1);
+  });
+});
+
+// ─── syncGitignore skip for flat layout ──────────────────────────────────────
+
+describe('syncGitignore skip for flat layout', () => {
+  let tmpDir;
+  const { execSync } = require('child_process');
+
+  beforeEach(() => { tmpDir = createTempDir(); });
+  afterEach(() => { cleanupDir(tmpDir); });
+
+  it('cmdReposInitProduct with no local repos does NOT create .gitignore DGS section', () => {
+    // Set up a product root with no subdirectory repos (flat layout)
+    // discoverRepos will find nothing -> localPaths is empty -> syncGitignore not called
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+    // Create sibling repos (outside product root — discoverRepos won't find them)
+    fs.mkdirSync(path.join(tmpDir, 'sibling-app', '.git'), { recursive: true });
+
+    const reposPath = require.resolve('./repos.cjs');
+    const script = `
+      const repos = require('${reposPath.replace(/\\/g, '\\\\')}');
+      const origExit = process.exit;
+      process.exit = (code) => { throw new Error('EXIT:' + code); };
+      const origStdout = process.stdout.write;
+      let stdoutData = '';
+      process.stdout.write = (data) => { stdoutData += data; };
+      try {
+        repos.cmdReposInitProduct('${productRoot.replace(/\\/g, '\\\\')}', {}, true);
+        process.stdout.write = origStdout;
+        console.log(stdoutData);
+      } catch (e) {
+        process.stdout.write = origStdout;
+        process.exit = origExit;
+        if (stdoutData) {
+          console.log(stdoutData);
+        } else {
+          console.log(JSON.stringify({error: e.message}));
+        }
+      }
+    `;
+    const result = execSync(`node -e '${script.replace(/'/g, "'\\''")}'`, {
+      encoding: 'utf-8', timeout: 5000,
+    }).trim();
+    const parsed = JSON.parse(result);
+    assert.strictEqual(parsed.initialized, true);
+    assert.strictEqual(parsed.gitignore_synced, false);
+
+    // .gitignore should not exist or should not contain DGS markers
+    const gitignorePath = path.join(productRoot, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf-8');
+      assert.ok(!content.includes('# DGS managed repos'), '.gitignore should not contain DGS markers');
+    }
+  });
+
+  it('cmdReposAdd with ../path does NOT modify .gitignore', () => {
+    // Set up product root with REPOS.md and a sibling repo
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+    const reposMd = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+`;
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    // Create sibling repo with .git
+    fs.mkdirSync(path.join(tmpDir, 'sibling-repo', '.git'), { recursive: true });
+
+    // Create an initial .gitignore with user content
+    fs.writeFileSync(path.join(productRoot, '.gitignore'), 'node_modules/\n.env\n');
+    const beforeContent = fs.readFileSync(path.join(productRoot, '.gitignore'), 'utf-8');
+
+    const reposPath = require.resolve('./repos.cjs');
+    const script = `
+      const repos = require('${reposPath.replace(/\\/g, '\\\\')}');
+      const origExit = process.exit;
+      process.exit = (code) => { throw new Error('EXIT:' + code); };
+      const origStdout = process.stdout.write;
+      let stdoutData = '';
+      process.stdout.write = (data) => { stdoutData += data; };
+      try {
+        repos.cmdReposAdd('${productRoot.replace(/\\/g, '\\\\')}', '../sibling-repo', {}, true);
+        process.stdout.write = origStdout;
+        console.log(stdoutData);
+      } catch (e) {
+        process.stdout.write = origStdout;
+        process.exit = origExit;
+        console.log(JSON.stringify({error: e.message}));
+      }
+    `;
+    execSync(`node -e '${script.replace(/'/g, "'\\''")}'`, {
+      encoding: 'utf-8', timeout: 5000,
+    });
+
+    // .gitignore should be unchanged (no DGS markers added)
+    const afterContent = fs.readFileSync(path.join(productRoot, '.gitignore'), 'utf-8');
+    assert.strictEqual(afterContent, beforeContent, '.gitignore should not be modified for ../repo paths');
+    assert.ok(!afterContent.includes('# DGS managed repos'), '.gitignore should not contain DGS markers');
+  });
+
+  it('cmdReposRemove with ../path does NOT modify .gitignore', () => {
+    // Set up product root with REPOS.md containing a ../repo entry
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(path.join(productRoot, '.planning'), { recursive: true });
+    const reposMd = `# Repos
+
+Registered repositories for this product. Managed by DGS — manual edits may be overwritten.
+
+| Name | Path | GitHub URL | Description |
+|------|------|------------|-------------|
+| sibling-repo | ../sibling-repo | | Test repo |
+`;
+    fs.writeFileSync(path.join(productRoot, '.planning', 'REPOS.md'), reposMd);
+    // Create sibling repo with .git
+    fs.mkdirSync(path.join(tmpDir, 'sibling-repo', '.git'), { recursive: true });
+
+    // Create an initial .gitignore with user content
+    fs.writeFileSync(path.join(productRoot, '.gitignore'), 'node_modules/\n.env\n');
+    const beforeContent = fs.readFileSync(path.join(productRoot, '.gitignore'), 'utf-8');
+
+    const reposPath = require.resolve('./repos.cjs');
+    const script = `
+      const repos = require('${reposPath.replace(/\\/g, '\\\\')}');
+      const origExit = process.exit;
+      process.exit = (code) => { throw new Error('EXIT:' + code); };
+      const origStdout = process.stdout.write;
+      let stdoutData = '';
+      process.stdout.write = (data) => { stdoutData += data; };
+      try {
+        repos.cmdReposRemove('${productRoot.replace(/\\/g, '\\\\')}', 'sibling-repo', { force: true }, true);
+        process.stdout.write = origStdout;
+        console.log(stdoutData);
+      } catch (e) {
+        process.stdout.write = origStdout;
+        process.exit = origExit;
+        console.log(JSON.stringify({error: e.message}));
+      }
+    `;
+    execSync(`node -e '${script.replace(/'/g, "'\\''")}'`, {
+      encoding: 'utf-8', timeout: 5000,
+    });
+
+    // .gitignore should be unchanged
+    const afterContent = fs.readFileSync(path.join(productRoot, '.gitignore'), 'utf-8');
+    assert.strictEqual(afterContent, beforeContent, '.gitignore should not be modified when removing ../repo paths');
+    assert.ok(!afterContent.includes('# DGS managed repos'), '.gitignore should not contain DGS markers');
+  });
+
+  it('syncGitignore silently filters out ../paths passed directly', () => {
+    // Even if a caller passes ../paths directly to syncGitignore,
+    // they should be filtered out (belt-and-suspenders defense)
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(productRoot, { recursive: true });
+    fs.writeFileSync(path.join(productRoot, '.gitignore'), 'node_modules/\n');
+
+    // Pass only ../paths - should result in no DGS section at all
+    syncGitignore(productRoot, ['../sibling-a', '../sibling-b']);
+
+    const content = fs.readFileSync(path.join(productRoot, '.gitignore'), 'utf-8');
+    assert.strictEqual(content, 'node_modules/\n', '.gitignore should be unchanged');
+    assert.ok(!content.includes('# DGS managed repos'), 'No DGS markers should be added');
+  });
+
+  it('syncGitignore filters ../paths but keeps ./paths in mixed input', () => {
+    const productRoot = path.join(tmpDir, 'product-root');
+    fs.mkdirSync(productRoot, { recursive: true });
+    fs.writeFileSync(path.join(productRoot, '.gitignore'), 'node_modules/\n');
+
+    // Pass mix of ./paths and ../paths - only ./paths should appear
+    syncGitignore(productRoot, ['./local-repo', '../sibling-a', './another-local']);
+
+    const content = fs.readFileSync(path.join(productRoot, '.gitignore'), 'utf-8');
+    assert.ok(content.includes('local-repo/'), 'Should contain local-repo');
+    assert.ok(content.includes('another-local/'), 'Should contain another-local');
+    assert.ok(!content.includes('sibling-a'), 'Should NOT contain sibling-a');
+    assert.ok(content.includes('# DGS managed repos'), 'DGS markers should exist for local repos');
+  });
+});