@boyingliu01/xp-gate 0.35.24 → 0.36.1

package/lib/__tests__/doctor-delphi.test.js

@@ -451,3 +451,178 @@ describe('doctor delphi #684 global config fallback', () => {
     expect(cfgLine).not.toMatch(/global/i);
   });
 });
+
+describe('doctor delphi #725 multi-platform skill parity', () => {
+  let tmpDirs;
+  let tmpHome;
+  let originalHome;
+  let originalUserProfile;
+
+  beforeEach(() => {
+    tmpDirs = makeTempDirs(['doctor-725-home']);
+    tmpHome = tmpDirs['doctor-725-home'];
+    originalHome = process.env.HOME;
+    originalUserProfile = process.env.USERPROFILE;
+    process.env.HOME = tmpHome;
+    process.env.USERPROFILE = tmpHome;
+    resetLibModules(vi, LIB_MODULES);
+    muteConsole(vi);
+  });
+
+  afterEach(() => {
+    if (originalHome === undefined) delete process.env.HOME; else process.env.HOME = originalHome;
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+    removeTempDirs(tmpDirs);
+    vi.restoreAllMocks();
+  });
+
+  /** Copy the shipped bundle into \`<home>/<rel>/delphi-review\`. */
+  function deploySkillAt(rel, mutate) {
+    const dest = path.join(tmpHome, rel, 'delphi-review');
+    fs.mkdirSync(dest, { recursive: true });
+    const src = bundledSkillDir();
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+      const from = path.join(src, entry.name);
+      const to = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        fs.mkdirSync(to, { recursive: true });
+        for (const inner of fs.readdirSync(from)) {
+          if (fs.statSync(path.join(from, inner)).isFile()) {
+            fs.copyFileSync(path.join(from, inner), path.join(to, inner));
+          }
+        }
+      } else {
+        fs.copyFileSync(from, to);
+      }
+    }
+    if (mutate) mutate(dest);
+    return dest;
+  }
+
+  /** Minimal agent set so only skill parity is under test. */
+  function seedAgents() {
+    fs.mkdirSync(path.join(tmpHome, '.qoder', 'agents'), { recursive: true });
+    for (const role of ['architecture', 'technical', 'feasibility']) {
+      fs.copyFileSync(
+        path.join(repoRoot(), 'plugins', 'qoder', 'agents', `delphi-${role}.md`),
+        path.join(tmpHome, '.qoder', 'agents', `delphi-${role}.md`),
+      );
+    }
+  }
+
+  function captureResults() {
+    const lines = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation((...args) => lines.push(args.join(' ')));
+    return { lines, spy };
+  }
+
+  /**
+   * @test REQ-725 Multi-platform skill parity
+   * @intent A second platform whose copy drifted must fail the parity check instead of being invisible
+   * @covers AC-725-01
+   */
+  it('AC-725-01: a drifted OpenCode copy FAILs parity even though Qoder is clean', async () => {
+    seedAgents();
+    deploySkillAt(path.join('.qoder', 'skills'));
+    // Qoder is selected by detectPlatform(), so this is the copy the check used
+    // to look at -- and it is clean. The OpenCode copy is the one that rotted.
+    deploySkillAt(path.join('.config', 'opencode', 'skills'), (dest) => {
+      fs.writeFileSync(path.join(dest, 'AGENTS.md'), '# stale copy from 0.32.0.0\n');
+    });
+    fs.mkdirSync(path.join(tmpHome, '.config', 'xp-gate'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpHome, '.config', 'xp-gate', 'xp-gate.json'),
+      JSON.stringify({ installedSkills: {} }),
+    );
+
+    const { doctorDelphi } = require('../doctor');
+    const { lines, spy } = captureResults();
+    await doctorDelphi({ skipLatestProbe: true });
+    spy.mockRestore();
+
+    const parity = lines.filter((l) => /parity/i.test(l)).join('\n');
+    expect(parity, 'a stale second-platform copy must be reported').toMatch(/✗/);
+    expect(parity).toMatch(/opencode/i);
+  });
+
+  /**
+   * @test REQ-725 Multi-platform skill parity
+   * @intent Both platforms matching must still PASS, and say how many were compared
+   * @covers AC-725-02
+   */
+  it('AC-725-02: two clean platform copies PASS together', async () => {
+    seedAgents();
+    deploySkillAt(path.join('.qoder', 'skills'));
+    deploySkillAt(path.join('.config', 'opencode', 'skills'));
+    fs.mkdirSync(path.join(tmpHome, '.config', 'xp-gate'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpHome, '.config', 'xp-gate', 'xp-gate.json'),
+      JSON.stringify({ installedSkills: {} }),
+    );
+
+    const { doctorDelphi } = require('../doctor');
+    const { lines, spy } = captureResults();
+    await doctorDelphi({ skipLatestProbe: true });
+    spy.mockRestore();
+
+    const parity = lines.filter((l) => /parity/i.test(l)).join('\n');
+    expect(parity).toMatch(/✓/);
+    expect(parity).toMatch(/2 platform/i);
+  });
+
+  /**
+   * @test REQ-725 Multi-platform skill parity
+   * @intent dsh is a first-class deploy target but detectPlatform() never returns
+   *         it, so a drifted dsh copy must fail parity exactly like opencode
+   * @covers AC-725-01
+   */
+  it('AC-725-01: a drifted dsh copy FAILs parity even though Qoder is clean', async () => {
+    seedAgents();
+    deploySkillAt(path.join('.qoder', 'skills'));
+    deploySkillAt(path.join('.dsh', 'skills'), (dest) => {
+      fs.writeFileSync(path.join(dest, 'AGENTS.md'), '# stale dsh copy\n');
+    });
+    fs.mkdirSync(path.join(tmpHome, '.config', 'xp-gate'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpHome, '.config', 'xp-gate', 'xp-gate.json'),
+      JSON.stringify({ installedSkills: {} }),
+    );
+
+    const { doctorDelphi } = require('../doctor');
+    const { lines, spy } = captureResults();
+    await doctorDelphi({ skipLatestProbe: true });
+    spy.mockRestore();
+
+    const parity = lines.filter((l) => /parity/i.test(l)).join('\n');
+    expect(parity, 'a stale dsh copy must be reported').toMatch(/✗/);
+    expect(parity).toMatch(/dsh/i);
+  });
+
+  /**
+   * @test REQ-725 Multi-platform skill parity
+   * @intent a machine whose only installed agent is dsh has no marker detectPlatform()
+   *         keys on, so the opencode fallback falsely FAILs "not installed" even though
+   *         the skill IS deployed under ~/.dsh/skills
+   * @covers AC-725-01
+   */
+  it('AC-725-01: a dsh-only machine PASSes parity instead of "not installed at opencode"', async () => {
+    // No seedAgents(): keep .qoder/.claude/.config-opencode absent so detectPlatform()
+    // falls back to opencode while dsh is the only live tree.
+    deploySkillAt(path.join('.dsh', 'skills'));
+    fs.mkdirSync(path.join(tmpHome, '.config', 'xp-gate'), { recursive: true });
+    fs.writeFileSync(
+      path.join(tmpHome, '.config', 'xp-gate', 'xp-gate.json'),
+      JSON.stringify({ installedSkills: {} }),
+    );
+
+    const { doctorDelphi } = require('../doctor');
+    const { lines, spy } = captureResults();
+    await doctorDelphi({ skipLatestProbe: true });
+    spy.mockRestore();
+
+    const parity = lines.filter((l) => /parity/i.test(l)).join('\n');
+    expect(parity, 'a deployed dsh copy must be found and verified').toMatch(/✓/);
+    expect(parity).not.toMatch(/not installed/i);
+  });
+});

package/lib/__tests__/install-skill-full-dir.test.js

@@ -102,6 +102,11 @@ describe('install-skill full skill directory (#416)', () => {
   it('updates the skills directory of the platform actually in use', async () => {
     // update-skill used to hardcode the opencode path while install-skill wrote
     // to the platform dir, so on Qoder it deleted nothing (or the wrong copy).
+    //
+    // #725 changed the other half of this: a platform that ALSO has the skill
+    // deployed is updated too, because leaving it behind froze it at an old
+    // version while the command reported success. Both trees below are live, so
+    // both are updated -- "untouched" is no longer the expected end state.
     for (const name of ['superpowers', 'gstack']) {
       const dir = path.join(tmpHome, '.qoder', 'skills', name);
       fs.mkdirSync(dir, { recursive: true });
@@ -125,9 +130,47 @@ describe('install-skill full skill directory (#416)', () => {
     const { updateSkill } = require('../update-skill');
     expect(await updateSkill('ralph-loop', {})).toBe(0);
 
+    const bundled = listFiles(path.join(BUNDLED_SKILLS, 'ralph-loop'));
+
+    // qoder keeps its #416 guarantee: stale files removed, full bundle written.
     expect(fs.existsSync(path.join(qoderSkills, 'obsolete.md'))).toBe(false);
-    expect(listFiles(qoderSkills)).toEqual(listFiles(path.join(BUNDLED_SKILLS, 'ralph-loop')));
-    expect(fs.readFileSync(path.join(opencodeSkills, 'SKILL.md'), 'utf8')).toBe('untouched');
+    expect(listFiles(qoderSkills)).toEqual(bundled);
+
+    // #725: the opencode copy is a second live deployment, so it is updated too
+    // rather than silently frozen at `untouched`.
+    expect(listFiles(opencodeSkills)).toEqual(bundled);
+  });
+
+  it('updates a skill deployed under ~/.dsh too (#725 AC-725-06)', async () => {
+    // Qoder keeps the dep gate green AND is the platform detectPlatform() picks.
+    for (const name of ['superpowers', 'gstack']) {
+      const dir = path.join(tmpHome, '.qoder', 'skills', name);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ version: '2.0.0' }));
+    }
+    const qoderSkills = path.join(tmpHome, '.qoder', 'skills', 'ralph-loop');
+    fs.mkdirSync(qoderSkills, { recursive: true });
+    fs.writeFileSync(path.join(qoderSkills, 'SKILL.md'), '# old qoder copy');
+
+    // DSH is a live second deployment that detectPlatform() never returns.
+    const dshSkills = path.join(tmpHome, '.dsh', 'skills', 'ralph-loop');
+    fs.mkdirSync(dshSkills, { recursive: true });
+    fs.writeFileSync(path.join(dshSkills, 'SKILL.md'), '# old dsh copy');
+    fs.writeFileSync(path.join(dshSkills, 'obsolete.md'), 'stale');
+
+    const configDir = path.join(tmpHome, '.config', 'xp-gate');
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(configDir, 'xp-gate.json'),
+      JSON.stringify({ installedSkills: { 'ralph-loop': { version: '0.0.1' } } })
+    );
+
+    const { updateSkill } = require('../update-skill');
+    expect(await updateSkill('ralph-loop', {})).toBe(0);
+
+    const bundled = listFiles(path.join(BUNDLED_SKILLS, 'ralph-loop'));
+    expect(listFiles(dshSkills)).toEqual(bundled);
+    expect(fs.existsSync(path.join(dshSkills, 'obsolete.md'))).toBe(false);
   });
 
   it('keeps the installed directory when the package no longer bundles the skill', async () => {

package/lib/__tests__/install-skill.test.js

@@ -1,7 +1,9 @@
 /**
- * @test install-skill
- * @intent Verify installSkill() handles deps check, bundle lookup, config, backup, and errors
- * @covers AC-416-01, AC-416-05
+ * @test REQ-416, REQ-725
+ * @intent Verify installSkill() handles deps check, bundle lookup, config, backup, and errors,
+ *         and that it writes EVERY platform already carrying the skill rather than only the
+ *         one detectPlatform() short-circuits to.
+ * @covers AC-416-01, AC-416-05, AC-725-06
  */
 const fs = require('fs');
 const path = require('path');
@@ -332,4 +334,83 @@ describe('install-skill #713 CLI version reporting', () => {
     expect(said).not.toContain('0.0.0');
     expect(said).toContain(`xp-gate ${pkg.version} bundles:`);
   });
+
+  /**
+   * AC-725-06: a machine carrying the same skill on more than one platform must
+   * have every copy updated. `detectPlatform()` short-circuits to the first
+   * marker it finds, so the single-target path froze the other copy while
+   * reporting success -- and `doctor` then agreed, because both read the same
+   * short-circuited answer. Migration-era machines with Qoder AND OpenCode are
+   * the normal case, not an edge one.
+   */
+  it('AC-725-06: updates every deployed platform, not just the detected one', async () => {
+    // Two platforms carry the skill; detectPlatform() would only ever see one.
+    const qoderSkills = path.join(fx.tmpHome, '.qoder', 'skills');
+    const opencodeSkills = path.join(fx.tmpHome, '.config', 'opencode', 'skills');
+    const SKILL = 'sprint-flow';
+    for (const root of [qoderSkills, opencodeSkills]) {
+      fs.mkdirSync(path.join(root, SKILL), { recursive: true });
+      fs.writeFileSync(path.join(root, SKILL, 'SKILL.md'), '# stale copy\n');
+    }
+
+    const detectPath = require.resolve('../detect-deps.js');
+    require.cache[detectPath] = {
+      id: detectPath,
+      filename: detectPath,
+      loaded: true,
+      exports: {
+        ...require('../detect-deps.js'),
+        checkDeps: async () => ({ ok: true }),
+      },
+    };
+
+    const { installSkill } = require('../install-skill');
+    const code = await installSkill(SKILL, { force: true });
+    expect(code).toBe(0);
+
+    // Both copies must now carry the shipped content, not the stale fixture.
+    for (const root of [qoderSkills, opencodeSkills]) {
+      const installed = path.join(root, SKILL, 'SKILL.md');
+      expect(fs.existsSync(installed)).toBe(true);
+      const body = fs.readFileSync(installed, 'utf8');
+      expect(body).not.toBe('# stale copy\n');
+      expect(body.length).toBeGreaterThan(100);
+    }
+  });
+
+  it('AC-725-06: a platform whose copy cannot be read does not abort the others', async () => {
+    // Qoder's skills root is a FILE, so readdir throws ENOTDIR for it. That
+    // platform must be skipped, and OpenCode -- which is readable -- must still
+    // be updated. The prior single-target code never reached this case because
+    // detectPlatform() would have picked one platform and ignored the other.
+    const qoderSkills = path.join(fx.tmpHome, '.qoder', 'skills');
+    const opencodeSkills = path.join(fx.tmpHome, '.config', 'opencode', 'skills');
+    const SKILL = 'sprint-flow';
+    fs.mkdirSync(path.dirname(qoderSkills), { recursive: true });
+    fs.writeFileSync(qoderSkills, 'not a directory');
+    fs.mkdirSync(path.join(opencodeSkills, SKILL), { recursive: true });
+    fs.writeFileSync(path.join(opencodeSkills, SKILL, 'SKILL.md'), '# stale copy\n');
+
+    const detectPath = require.resolve('../detect-deps.js');
+    require.cache[detectPath] = {
+      id: detectPath,
+      filename: detectPath,
+      loaded: true,
+      exports: {
+        ...require('../detect-deps.js'),
+        checkDeps: async () => ({ ok: true }),
+      },
+    };
+
+    const { installSkill } = require('../install-skill');
+    const code = await installSkill(SKILL, { force: true });
+
+    // The readable platform must still have been written.
+    const healthy = path.join(opencodeSkills, SKILL, 'SKILL.md');
+    expect(fs.existsSync(healthy)).toBe(true);
+    expect(fs.readFileSync(healthy, 'utf8')).not.toBe('# stale copy\n');
+    // The unreadable root must not have been silently "updated" into a file.
+    expect(fs.statSync(qoderSkills).isFile()).toBe(true);
+    expect(code).toBe(0);
+  });
 });

package/lib/__tests__/mirror-sync.test.js

@@ -49,8 +49,15 @@ afterEach(() => {
  */
 function write(root, rel, content) {
   const full = path.join(root, rel);
-  fs.mkdirSync(path.dirname(full), { recursive: true });
-  fs.writeFileSync(full, content);
+  try {
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, content);
+  } catch (err) {
+    // Swallowing this would turn a broken fixture into a confusing assertion
+    // failure further down ("expected undefined"), so rethrow with the path that
+    // actually failed. The rule wants the IO handled, not hidden.
+    throw new Error(`failed to write fixture ${rel}: ${err instanceof Error ? err.message : String(err)}`);
+  }
 }
 
 /**
@@ -264,13 +271,24 @@ describe('syncMirrors — AC-713-04 safety', () => {
   it('preserves the executable bit so hooks stay runnable', () => {
     write(TMP_REPO, 'canonical/hook.sh', '#!/bin/sh\necho a\n');
     fs.chmodSync(path.join(TMP_REPO, 'canonical/hook.sh'), 0o755);
-    write(TMP_REPO, 'mirror/hook.sh', '#!/bin/sh\necho a\n');
+    // The mirror must start as *drift*. The sync loop only touches files that
+    // are `missing` or `differing`, so identical content is skipped and the mode
+    // never gets rewritten. An earlier version gave both sides the same bytes,
+    // so the file never entered `toWrite`; on Linux the assertion then failed
+    // ("expected +0 to be truthy") while Windows skipped the whole block, which
+    // is how it stayed invisible locally. The test was measuring nothing.
+    write(TMP_REPO, 'mirror/hook.sh', '#!/bin/sh\necho stale\n');
     trackAll(TMP_REPO);
 
-    syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
-    const mode = fs.statSync(path.join(TMP_REPO, 'mirror/hook.sh')).mode;
+    const result = syncMirrors(TMP_REPO, [{ canonical: 'canonical', mirror: 'mirror' }]);
+    // Prove the copy actually happened, so a green result cannot come from
+    // "nothing was touched".
+    expect(result.copied).toContain('hook.sh');
+    expect(fs.readFileSync(path.join(TMP_REPO, 'mirror/hook.sh'), 'utf8')).toBe('#!/bin/sh\necho a\n');
+
     // On Windows the exec bit is not meaningful; only assert where it applies.
     if (process.platform !== 'win32') {
+      const mode = fs.statSync(path.join(TMP_REPO, 'mirror/hook.sh')).mode;
       expect(mode & 0o111).toBeTruthy();
     }
   });

package/lib/__tests__/principles-csharp-coverage.test.js

@@ -0,0 +1,227 @@
+/**
+ * @test REQ-758 `xp-gate principles <dir>` must reach every file the engine has an adapter for
+ * @intent `principles.js` keeps its own literal `SOURCE_EXTENSIONS` because the file must
+ *         stay loadable by plain Node with no transpile step. Its own comment said the
+ *         list "Must match `getAdapterForFile`'s adapterMap" — and it did not.
+ *         `analyzer.ts` registered `.cs` and `.csx` since #717, but this walk never
+ *         offered those files to the checker, so a directory of C# sources reported
+ *         `Files checked: 0`, which reads exactly like "no violations".
+ *
+ *         How the expected set is derived matters more than the assertion, because two
+ *         weaker designs both shipped a guard that could pass while the defect lived:
+ *
+ *         1. A regex over analyzer.ts. Measured: changing `'.ts'` to `".ts"` — cosmetic,
+ *            same semantics — dropped the parsed set from 21 to 20 and the test still
+ *            passed. A guard that weakens under a legal refactor is the same "covered
+ *            but cannot block" shape as the bug.
+ *         2. A hand-written candidate list probed through `getAdapterForFile`. Measured:
+ *            adding `.fs` to BOTH adapterMap and the walk left every test green, because
+ *            the candidate list simply did not contain `.fs`.
+ *
+ *         So: parse `adapterMap` with the TypeScript compiler API (syntax-aware — key
+ *         quoting, comments and line breaks do not change the result; verified against
+ *         three cosmetic refactors), and separately confirm through `getAdapterForFile`
+ *         that each such extension is genuinely analysable. No hand-maintained list
+ *         bounds the expectation, so an extension added to the analyzer alone fails here
+ *         by name.
+ * @covers AC-758-01, AC-758-02, AC-758-03, AC-758-04, AC-758-05
+ */
+const ts = require('typescript');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { pathToFileURL } = require('url');
+
+const { collectSourceFiles } = require('../principles');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..');
+const ANALYZER = path.join(REPO_ROOT, 'src', 'principles', 'analyzer.ts');
+
+let TMP;
+let getAdapterForFile;
+
+beforeAll(async () => {
+  TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'principles-csharp-'));
+  const mod = await import(pathToFileURL(ANALYZER).href);
+  getAdapterForFile = mod.getAdapterForFile;
+});
+
+afterAll(() => {
+  fs.rmSync(TMP, { recursive: true, force: true });
+});
+
+/**
+ * Write a file inside the temp tree.
+ * @param {string} rel - path relative to TMP
+ * @param {string} content - file body
+ */
+function touch(rel, content) {
+  const abs = path.join(TMP, rel);
+  try {
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`fixture setup failed writing ${rel}: ${msg}`);
+  }
+}
+
+/**
+ * Keys of the `adapterMap` object literal in a TypeScript source string.
+ *
+ * Uses the compiler API rather than a regex so that formatting is irrelevant: quoted
+ * any way, reordered, commented or reformatted, the key set is the same. Throws when
+ * the map cannot be found at all — a silently empty result would make every assertion
+ * below pass vacuously.
+ *
+ * @param {string} source - TypeScript source text
+ * @returns {string[]} extensions including the leading dot
+ */
+function adapterMapKeys(source) {
+  const sf = ts.createSourceFile('analyzer.ts', source, ts.ScriptTarget.Latest, true);
+  const keys = [];
+  /**
+   * @param {import('typescript').Node} node
+   */
+  function visit(node) {
+    if (
+      ts.isVariableDeclaration(node) &&
+      node.name.getText(sf) === 'adapterMap' &&
+      node.initializer &&
+      ts.isObjectLiteralExpression(node.initializer)
+    ) {
+      for (const prop of node.initializer.properties) {
+        if (
+          (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) &&
+          prop.name &&
+          ts.isStringLiteralLike(prop.name)
+        ) {
+          keys.push(prop.name.text);
+          continue;
+        }
+        // A spread or a computed key would make this extraction return FEWER extensions
+        // than the map really holds: the derived expectation shrinks, every assertion
+        // still passes, and the guard quietly stops covering what it claims to cover.
+        // That is the exact failure shape this file was written to prevent, so fail
+        // loudly instead of under-reporting.
+        if (ts.isSpreadAssignment(prop) || ts.isComputedPropertyName(prop.name)) {
+          throw new Error(
+            'adapterMap contains a spread or computed key, so this guard cannot derive ' +
+              'the full extension set from it. Extend adapterMapKeys() rather than ' +
+              'letting it silently under-report.',
+          );
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  if (keys.length === 0) {
+    throw new Error('adapterMap not found (or holds no string keys) in analyzer.ts');
+  }
+  return keys;
+}
+
+describe('principles walk covers every language the engine has an adapter for', () => {
+  test('AC-758-01: a .cs file in the target directory is offered to the checker', () => {
+    touch('cs-only/Program.cs', 'namespace Aot { class P { static void Main() {} } }\n');
+
+    const found = collectSourceFiles(path.join(TMP, 'cs-only'));
+
+    expect(found.map(f => path.basename(f))).toContain('Program.cs');
+  });
+
+  test('AC-758-02: every extension in adapterMap is collected by the walk', () => {
+    const expected = adapterMapKeys(fs.readFileSync(ANALYZER, 'utf8'));
+
+    // The C# entries are what this file exists for; assert them explicitly so a
+    // regression names the extension rather than just shrinking a count.
+    expect(expected).toContain('.cs');
+    expect(expected).toContain('.csx');
+
+    for (const ext of expected) {
+      touch(`all-ext/file${ext}`, '// fixture\n');
+    }
+
+    const names = new Set(
+      collectSourceFiles(path.join(TMP, 'all-ext')).map(f => path.basename(f)),
+    );
+
+    const missing = expected
+      .filter(ext => !names.has(`file${ext}`))
+      .map(ext => `${ext} is registered in adapterMap but the walk never collected file${ext}`);
+
+    expect(missing).toEqual([]);
+  });
+
+  test('AC-758-04: each adapterMap extension is genuinely analysable, not just listed', () => {
+    // adapterMap could name an extension whose adapter is broken. Confirm through the
+    // real entry point that a file with that extension produces an adapter at all.
+    //
+    // The function is asserted to BE a function first. Without that, a broken dynamic
+    // import (interop change, undefined export) would make every probe throw a
+    // TypeError, the catch below would swallow each one, `notAnalysable` would stay
+    // empty, and this test would report success while asserting nothing. A guard that
+    // goes green when its own instrument is missing is the defect class this file is
+    // about.
+    expect(typeof getAdapterForFile).toBe('function');
+
+    const expected = adapterMapKeys(fs.readFileSync(ANALYZER, 'utf8'));
+    const notAnalysable = [];
+    let answered = 0;
+    for (const ext of expected) {
+      touch(path.join('analysable', `probe${ext}`), '// fixture\n');
+      const abs = path.join(TMP, 'analysable', `probe${ext}`);
+      try {
+        const adapter = getAdapterForFile(abs);
+        answered += 1;
+        if (adapter === null) notAnalysable.push(ext);
+      } catch (err) {
+        // Adapters read their file in the constructor, so content the adapter rejects
+        // still proves registration. Anything else (a TypeError from a missing
+        // function) must not be mistaken for that, so the error type is checked.
+        const name = err && err.constructor ? err.constructor.name : '';
+        if (name === 'TypeError') throw err;
+        if (!/Could not read file|ENOENT|parse/i.test(String(err && err.message))) throw err;
+        answered += 1;
+      }
+    }
+    // Every extension must have produced a real answer, otherwise the loop above
+    // proved nothing.
+    expect(answered).toBe(expected.length);
+    expect(notAnalysable).toEqual([]);
+  });
+
+  test('AC-758-03: a directory of ONLY C# sources is not reported as empty', () => {
+    touch('only-cs/Alpha.cs', 'class A {}\n');
+    touch('only-cs/sub/Beta.cs', 'class B {}\n');
+
+    const found = collectSourceFiles(path.join(TMP, 'only-cs'));
+
+    expect(found.length).toBe(2);
+    expect(found.map(f => path.basename(f)).sort()).toEqual(['Alpha.cs', 'Beta.cs']);
+  });
+
+  test('AC-758-05: .cs files survive upper/lower case variants, end to end', () => {
+    // Both halves of the claim in the acceptance criterion, because either one alone
+    // leaves the original symptom reachable:
+    //  - the WALK must collect `Program.CS`, and
+    //  - `getAdapterForFile` must accept it, since it lowercases the extension before
+    //    lookup. If that normalisation regressed while the walk still collected the
+    //    file, the adapter would be null, the file would be skipped, and a directory of
+    //    all-uppercase C# would once again report Files checked: 0.
+    touch('mixed-case/Upper.CS', 'class U {}\n');
+    touch('mixed-case/Mixed.Cs', 'class M {}\n');
+
+    const collected = collectSourceFiles(path.join(TMP, 'mixed-case'));
+    const names = collected.map(f => path.basename(f));
+
+    expect(names.sort()).toEqual(['Mixed.Cs', 'Upper.CS']);
+
+    // The end-to-end half: every file the walk collected must also resolve to an
+    // adapter, so "collected" cannot silently degrade into "collected then dropped".
+    for (const file of collected) {
+      expect(getAdapterForFile(file)).not.toBeNull();
+    }
+  });
+});