@boyingliu01/xp-gate 0.19.3 → 0.20.0

package/lib/__tests__/qoder-delphi-agents.test.js

@@ -0,0 +1,285 @@
+/**
+ * @test qoder-delphi-agents
+ * @intent Guard the invariants behind Issue #417: Qoder Custom Agents must bind a
+ * built-in model as "[DisplayName](modelId)", stale or diverged deployments must
+ * surface a warning instead of silently falling back to the session model, and
+ * agent deployment must never abort an in-flight setup.
+ */
+const fs = require('fs');
+const path = require('path');
+const childProcess = require('child_process');
+const {
+  resetLibModules, muteConsole, makeTempDirs, removeTempDirs,
+} = require('./helpers/lib-sandbox.cjs');
+
+const LIB_MODULES = ['../init', '../detect-deps.js', '../shared-paths'].map(name => require.resolve(name));
+
+describe('Qoder Delphi agent templates (#417)', () => {
+  let tmpDirs;
+  let tmpHome;
+  let logSpy;
+  let warnSpy;
+  let originalHome;
+
+  beforeEach(() => {
+    tmpDirs = makeTempDirs(['xpgate-agents-home']);
+    tmpHome = tmpDirs['xpgate-agents-home'];
+    originalHome = process.env.HOME;
+    process.env.HOME = tmpHome;
+    fs.mkdirSync(path.join(tmpHome, '.qoder', 'skills'), { recursive: true });
+    resetLibModules(vi, LIB_MODULES);
+    ({ log: logSpy, warn: warnSpy } = muteConsole(vi));
+    vi.spyOn(childProcess, 'execSync').mockReturnValue(Buffer.from(''));
+    vi.spyOn(childProcess, 'spawnSync').mockReturnValue({ status: 0, stdout: Buffer.from(''), stderr: Buffer.from('') });
+  });
+
+  afterEach(() => {
+    if (originalHome === undefined) delete process.env.HOME; else process.env.HOME = originalHome;
+    removeTempDirs(tmpDirs);
+    vi.restoreAllMocks();
+  });
+
+  function repoRoot() {
+    // __dirname = src/npm-package/lib/__tests__
+    return path.join(__dirname, '..', '..', '..', '..');
+  }
+
+  function warned() {
+    return warnSpy.mock.calls.map(c => String(c[0])).join('\n');
+  }
+
+  function logged() {
+    return logSpy.mock.calls.map(c => String(c[0])).join('\n');
+  }
+
+  function agentTemplate(modelLine, name) {
+    return `---\nname: ${name}\n${modelLine}\n---\n# ${name}\n`;
+  }
+
+  function tempAgentPair(filename, srcBody, destBody) {
+    const dirs = makeTempDirs(['xpgate-agentsrc', 'xpgate-agentdst']);
+    const srcDir = dirs['xpgate-agentsrc'];
+    const targetRoot = dirs['xpgate-agentdst'];
+    const srcAgents = path.join(srcDir, 'plugins', 'qoder', 'agents');
+    const destAgents = path.join(targetRoot, '.qoder', 'agents');
+    fs.mkdirSync(srcAgents, { recursive: true });
+    fs.mkdirSync(destAgents, { recursive: true });
+    if (srcBody !== null) fs.writeFileSync(path.join(srcAgents, filename), srcBody);
+    if (destBody !== null) fs.writeFileSync(path.join(destAgents, filename), destBody);
+    return { dirs, srcDir, targetRoot, srcAgents, destAgents };
+  }
+
+  function withDirs(dirs, fn) {
+    try {
+      return fn();
+    } finally {
+      removeTempDirs(dirs.dirs);
+    }
+  }
+
+  it('binds every expert template mirror to three distinct, identical built-in models', () => {
+    const { readQoderModelId } = require('../init');
+    const mirrors = [
+      path.join(repoRoot(), 'plugins', 'qoder', 'agents'),
+      path.join(repoRoot(), '.qoder', 'agents'),
+      path.join(repoRoot(), 'src', 'npm-package', 'plugins', 'qoder', 'agents'),
+    ];
+    const names = ['delphi-architecture', 'delphi-technical', 'delphi-feasibility'];
+
+    for (const dir of mirrors) {
+      const models = names.map(name => {
+        const file = path.join(dir, `${name}.md`);
+        expect(fs.existsSync(file)).toBe(true);
+        const modelId = readQoderModelId(file);
+        expect(modelId).not.toBeNull();
+        return modelId;
+      });
+      expect(new Set(models).size).toBe(3);
+      // Bodies may diverge (`.qoder/agents/` is this repo's own install), but the
+      // model each expert pins must not.
+      for (const [index, name] of names.entries()) {
+        const ids = mirrors.map(dir => readQoderModelId(path.join(dir, `${name}.md`)));
+        expect(new Set(ids).size).toBe(1);
+        expect(ids[0]).toBe(models[index]);
+      }
+    }
+  });
+
+  it('reads the modelId only from a quoted frontmatter binding', () => {
+    const { readQoderModelId } = require('../init');
+    const dirs = tempAgentPair('probe.md', null, null);
+    return withDirs(dirs, () => {
+      const write = body => {
+        const file = path.join(dirs.destAgents, 'probe.md');
+        fs.writeFileSync(file, body);
+        return readQoderModelId(file);
+      };
+      expect(write('---\nmodel: "[Qwen3.8-Flash](qfmodel)"\n---\n')).toBe('qfmodel');
+      expect(write("---\nmodel: '[Qwen3.8-Flash](qfmodel)'\n---\n")).toBe('qfmodel');
+      // Unquoted is not a legal Custom Agent binding: the docs require
+      // "[Name](modelId)", and accepting the bare form lets a hand-edited file
+      // pass the audit while Qoder reads something else entirely.
+      expect(write('---\nmodel: [Qwen3.8-Flash](qfmodel)\n---\n')).toBeNull();
+      expect(write('---\nmodel: "[Qwen3.8-Flash](qfmodel)\n---\n')).toBeNull(); // unbalanced quote
+      expect(write('---\nmodel: Qwen3.7-Max\n---\n')).toBeNull(); // bare name
+      expect(write('---\nname: x\n---\n\nExample:\n```md\nmodel: "[Doc](docmodel)"\n```\n')).toBeNull();
+    });
+  });
+
+  it('warns about a preserved existing agent whose model binding is stale', () => {
+    const dirs = tempAgentPair(
+      'delphi-technical.md',
+      agentTemplate('model: "[DeepSeek-Flash](dfmodel)"', 'delphi-technical'),
+      agentTemplate('model: GLM-5.2', 'delphi-technical')
+    );
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(warned()).toContain('delphi-technical.md');
+      expect(warned()).toContain('session model');
+      expect(fs.readFileSync(path.join(dirs.destAgents, 'delphi-technical.md'), 'utf8')).toContain('GLM-5.2');
+    });
+  });
+
+  it('warns when a preserved agent binds a different model than this version ships', () => {
+    const dirs = tempAgentPair(
+      'delphi-feasibility.md',
+      agentTemplate('model: "[DeepSeek-Flash](dfmodel)"', 'delphi-feasibility'),
+      agentTemplate('model: "[GLM-5.3-Flash](gfmodel)"', 'delphi-feasibility')
+    );
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(warned()).toContain('binds "gfmodel"');
+      expect(warned()).toContain('pins "dfmodel"');
+      expect(fs.existsSync(path.join(dirs.destAgents, 'delphi-feasibility.md'))).toBe(true);
+    });
+  });
+
+  it('audits deployed agents even when the bundled templates are missing', () => {
+    const dirs = tempAgentPair('delphi-architecture.md', null, agentTemplate('model: Qwen3.7-Max', 'delphi-architecture'));
+    fs.rmSync(dirs.srcAgents, { recursive: true, force: true });
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(warned()).toContain('templates not bundled');
+      expect(warned()).toContain('delphi-architecture.md');
+      // Nothing came from this install, so the summary must not claim there were
+      // simply no templates, nor lecture about a binding we never deployed.
+      expect(logged()).not.toContain('no agent templates found');
+      expect(warned()).not.toContain('does not adopt');
+    });
+  });
+
+  it('refuses a bundled template whose binding is unquoted', () => {
+    const dirs = tempAgentPair(
+      'delphi-technical.md',
+      agentTemplate('model: [DeepSeek-Flash](dfmodel)', 'delphi-technical'),
+      null
+    );
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(fs.existsSync(path.join(dirs.destAgents, 'delphi-technical.md'))).toBe(false);
+      expect(warned()).toContain('1 bundled template(s) rejected');
+    });
+  });
+
+  it('leaves unrelated user agents alone', () => {
+    const dirs = tempAgentPair(
+      'delphi-technical.md',
+      agentTemplate('model: "[DeepSeek-Flash](dfmodel)"', 'delphi-technical'),
+      null
+    );
+    fs.writeFileSync(path.join(dirs.destAgents, 'my-other-agent.md'), '# no frontmatter at all\n');
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(warned()).not.toContain('my-other-agent.md');
+    });
+  });
+
+  it('refuses to deploy a bundled template without a valid model binding', () => {
+    const dirs = tempAgentPair('delphi-architecture.md', agentTemplate('model: Qwen3.7-Max', 'delphi-architecture'), null);
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(fs.existsSync(path.join(dirs.destAgents, 'delphi-architecture.md'))).toBe(false);
+      expect(warned()).toContain('no valid model binding');
+      expect(warned()).toContain('1 bundled template(s) rejected');
+      expect(logged()).not.toContain('no agent templates found');
+      expect(warned()).not.toContain('does not adopt');
+    });
+  });
+
+  it('swallows deployment failures instead of aborting setup half-installed', () => {
+    const dirs = tempAgentPair(
+      'delphi-technical.md',
+      agentTemplate('model: "[DeepSeek-Flash](dfmodel)"', 'delphi-technical'),
+      null
+    );
+    const originalCopy = fs.copyFileSync;
+    try {
+      fs.copyFileSync = () => { throw 'EPERM: operation not permitted'; };
+      const { deployQoderDelphiAgents } = require('../init');
+      expect(() => deployQoderDelphiAgents(dirs.srcDir, dirs.targetRoot)).not.toThrow();
+      expect(warned()).toContain('deployment failed: EPERM: operation not permitted');
+    } finally {
+      fs.copyFileSync = originalCopy;
+      fs.rmSync(dirs.srcDir, { recursive: true, force: true });
+      fs.rmSync(dirs.targetRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('states the platform boundary even when every deployed binding is valid', () => {
+    const dirs = tempAgentPair(
+      'delphi-architecture.md',
+      agentTemplate('model: "[Qwen3.8-Flash](qfmodel)"', 'delphi-architecture'),
+      null
+    );
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      // A legal binding is not an executed binding. Without this line the user
+      // leaves `init` believing three experts now run on three models.
+      expect(fs.existsSync(path.join(dirs.destAgents, 'delphi-architecture.md'))).toBe(true);
+      expect(warned()).toContain('does not adopt');
+      expect(warned()).toContain('.delphi-config.json');
+    });
+  });
+
+  it('does not state the boundary on a non-Qoder platform', () => {
+    // Remove the whole ~/.qoder dir (#424): any ~/.qoder content now means Qoder.
+    fs.rmSync(path.join(tmpHome, '.qoder'), { recursive: true, force: true });
+    const dirs = tempAgentPair(
+      'delphi-architecture.md',
+      agentTemplate('model: "[Qwen3.8-Flash](qfmodel)"', 'delphi-architecture'),
+      null
+    );
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(warned()).not.toContain('does not adopt');
+    });
+  });
+
+  it('reports the detected platform when skipping agent deployment', () => {
+    fs.rmSync(path.join(tmpHome, '.qoder'), { recursive: true, force: true });
+    const dirs = tempAgentPair('delphi-technical.md', null, null);
+    withDirs(dirs, () => {
+      const { configureQoderDelphiAgents } = require('../init');
+      configureQoderDelphiAgents(dirs.srcDir, dirs.targetRoot);
+
+      expect(logged()).toContain('platform detected:');
+      expect(warned()).not.toContain('templates not bundled');
+    });
+  });
+});

package/lib/__tests__/shared-paths.test.js

@@ -86,6 +86,26 @@ describe('shared-paths', () => {
     expect(detectPlatform()).toBe('claude-code');
   });
 
+  // ── #424: brand-new Qoder installs have no skills/ subdirectory yet ──
+
+  it('detectPlatform returns qoder when only ~/.qoder exists (brand-new install, no skills dir)', () => {
+    fs.mkdirSync(path.join(tmpHome, '.qoder'), { recursive: true });
+    const { detectPlatform } = require('../shared-paths');
+    expect(detectPlatform()).toBe('qoder');
+  });
+
+  it('detectPlatform returns qoder when only ~/.qoder/agents exists (no skills dir)', () => {
+    fs.mkdirSync(path.join(tmpHome, '.qoder', 'agents'), { recursive: true });
+    const { detectPlatform } = require('../shared-paths');
+    expect(detectPlatform()).toBe('qoder');
+  });
+
+  it('detect-deps re-exports the SAME detectPlatform as shared-paths (no divergent copies)', () => {
+    const fromShared = require('../shared-paths').detectPlatform;
+    const fromDetectDeps = require('../detect-deps').detectPlatform;
+    expect(fromDetectDeps).toBe(fromShared);
+  });
+
   it('getTemplateDir returns correct path for each platform', () => {
     const { getTemplateDir } = require('../shared-paths');
 

package/lib/__tests__/shared-utils.test.js

@@ -0,0 +1,69 @@
+/**
+ * @test shared-utils
+ * @intent Verify copyAdapters deploys shipped gate scripts (gate-*.sh, sprint-gate.sh) from the package root so npm-installed init/setup-global produce working gates
+ * @covers gate-script deployment into ADAPTER_DIR / PROJECT_GITHOOKS for init and setup-global
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+describe('shared-utils', () => {
+  let tmpRoot;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-shared-utils-'));
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  describe('copyAdapters', () => {
+    it('copies gate-*.sh and sprint-gate.sh from the package root (npm install layout)', () => {
+      // npm install layout: the package root carries the shipped copies of
+      // gate-*.sh + sprint-gate.sh (placed by sync-package-content.js) and the
+      // repo-level githooks/ directory does not exist.
+      const pkgRoot = path.join(tmpRoot, 'node_modules', '@boyingliu01', 'xp-gate');
+      fs.mkdirSync(pkgRoot, { recursive: true });
+      fs.writeFileSync(path.join(pkgRoot, 'adapter-common.sh'), '# adapter-common');
+      fs.writeFileSync(path.join(pkgRoot, 'gate-3.sh'), '# gate-3');
+      fs.writeFileSync(path.join(pkgRoot, 'gate-12-file-hygiene.sh'), '# gate-12');
+      fs.writeFileSync(path.join(pkgRoot, 'sprint-gate.sh'), '# sprint-gate');
+      fs.mkdirSync(path.join(pkgRoot, 'adapters'), { recursive: true });
+      fs.writeFileSync(path.join(pkgRoot, 'adapters', 'typescript.sh'), '# ts');
+
+      const destDir = path.join(tmpRoot, 'project-githooks');
+      fs.mkdirSync(destDir, { recursive: true });
+
+      const { copyAdapters } = require('../shared-utils');
+      copyAdapters(pkgRoot, destDir);
+
+      expect(fs.existsSync(path.join(destDir, 'adapter-common.sh'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'typescript.sh'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'gate-3.sh'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'gate-12-file-hygiene.sh'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'sprint-gate.sh'))).toBe(true);
+    });
+
+    it('copies only gate-*.sh and sprint-gate.sh from the package root (filters other files)', () => {
+      const pkgRoot = path.join(tmpRoot, 'pkg');
+      fs.mkdirSync(path.join(pkgRoot, 'adapters'), { recursive: true });
+      fs.writeFileSync(path.join(pkgRoot, 'adapter-common.sh'), '# adapter-common');
+      fs.writeFileSync(path.join(pkgRoot, 'gate-3.sh'), '# gate-3');
+      fs.writeFileSync(path.join(pkgRoot, 'verify.sh'), '# verify');
+      fs.writeFileSync(path.join(pkgRoot, 'VERSION'), '1.0.0.0');
+
+      const destDir = path.join(tmpRoot, 'dest');
+      fs.mkdirSync(destDir, { recursive: true });
+
+      const { copyAdapters } = require('../shared-utils');
+      copyAdapters(pkgRoot, destDir);
+
+      expect(fs.existsSync(path.join(destDir, 'gate-3.sh'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'verify.sh'))).toBe(false);
+      expect(fs.existsSync(path.join(destDir, 'VERSION'))).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+/**
+ * @test REQ-416
+ * @intent install-skill 的用法字符串删掉了 --offline，但 parseOptions 对认不出的 flag
+ *         照旧静默忽略 —— 这正是 #488 给 doctor 修掉的同一类缺陷：用户执行了已不存在的
+ *         flag，得到 exit 0 与「安装成功」，而 flag 从未生效（Round 1 架构席位 MA-02）
+ * @covers AC-416-06
+ */
+const { parseSkillFlags } = require('../shared-utils');
+
+describe('parseSkillFlags (#416)', () => {
+  it('parses the flags the skill commands implement', () => {
+    const { options, unknown } = parseSkillFlags(['--verbose', '--force'], 'install-skill');
+
+    expect(options).toMatchObject({ verbose: true, force: true, all: false, check: false });
+    expect(unknown).toEqual([]);
+  });
+
+  it('names a flag it does not implement instead of swallowing it', () => {
+    const { unknown } = parseSkillFlags(['--offline', '--verbose'], 'install-skill');
+
+    expect(unknown).toEqual(['--offline']);
+  });
+
+  it('treats a value argument as unknown rather than silently dropping it', () => {
+    expect(parseSkillFlags(['main'], 'install-skill').unknown).toEqual(['main']);
+  });
+
+  it('reports no unknown flag for an empty argument list', () => {
+    expect(parseSkillFlags([], 'install-skill')).toEqual({
+      options: { verbose: false, force: false, all: false, check: false },
+      unknown: [],
+    });
+  });
+
+  // Round 2 architecture MI-04: one global table meant `install-skill x --all`
+  // parsed clean and then dropped options.all on the floor -- parsed-but-not-
+  // consumed is the same silent no-op this branch exists to remove.
+  it('accepts a flag only for the command that consumes it', () => {
+    expect(parseSkillFlags(['--all'], 'install-skill').unknown).toEqual(['--all']);
+    expect(parseSkillFlags(['--check'], 'uninstall-skill').unknown).toEqual(['--check']);
+    expect(parseSkillFlags(['--verbose'], 'uninstall-skill').unknown).toEqual(['--verbose']);
+
+    const update = parseSkillFlags(['--all', '--check', '--verbose'], 'update-skill');
+    expect(update.unknown).toEqual([]);
+    expect(update.options).toMatchObject({ all: true, check: true, verbose: true });
+    expect(parseSkillFlags(['--force'], 'uninstall-skill').unknown).toEqual([]);
+  });
+});

package/lib/__tests__/ui-detector.test.ts

@@ -372,13 +372,17 @@ describe('ui-detector', () => {
 
     const UI_DETECTOR_PATH = path.resolve(__dirname, '../ui-detector.ts');
 
+    // Resolve the local tsx CLI once: spawning `npx tsx` per test re-resolves
+    // the package each call and needs shell:true on Windows; running the
+    // resolved CLI through process.execPath is far faster and shell-free.
+    const tsxCli = require.resolve('tsx/cli');
+
     function runCli(args: string[], stdin?: string, cwd?: string): { code: number; stdout: string; stderr: string } {
       const coverageDir = process.env.NODE_V8_COVERAGE ?? path.join(process.cwd(), 'coverage', '.tmp');
-      const result = realSpawnSync('npx', ['tsx', UI_DETECTOR_PATH, ...args], {
+      const result = realSpawnSync(process.execPath, [tsxCli, UI_DETECTOR_PATH, ...args], {
         cwd: cwd ?? process.cwd(),
         encoding: 'utf-8',
         input: stdin,
-        shell: true, // Required for npx.cmd resolution on Windows
         env: { ...process.env, NODE_V8_COVERAGE: coverageDir },
       });
       return {

package/lib/__tests__/uninstall.test.js

@@ -97,6 +97,14 @@ describe('uninstall', () => {
     );
   }
 
+  function createXpGatePostMerge(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'post-merge'),
+      '#!/usr/bin/env bash\n# post-merge - XP-Gate VERSION sync hook\n'
+    );
+  }
+
   function createXpGateAdapterCommon(dir) {
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(
@@ -131,6 +139,7 @@ describe('uninstall', () => {
     // Create project .git/hooks with xp-gate hooks
     createXpGatePreCommit(projectHooksDir());
     createXpGatePrePush(projectHooksDir());
+    createXpGatePostMerge(projectHooksDir());
 
     // Create project githooks/ with adapters
     createXpGateAdapterCommon(projectGithooksDir());
@@ -248,6 +257,17 @@ describe('uninstall', () => {
     expect(cfg.uninstalled).toBeDefined();
   });
 
+  it('AC-01: uninstall in local mode removes the deployed post-merge hook', async () => {
+    setupLocalInstall();
+    mockExecSuccess();
+    const { uninstall } = require('../uninstall');
+
+    const result = await uninstall([]);
+
+    expect(result).toBe(0);
+    expect(fs.existsSync(path.join(projectHooksDir(), 'post-merge'))).toBe(false);
+  });
+
   it('AC-01: uninstall returns 0 even when no files exist (graceful)', async () => {
     fs.mkdirSync(path.dirname(configFile()), { recursive: true });
     fs.writeFileSync(configFile(), JSON.stringify({ mode: 'local', lastInit: '2025-01-01' }, null, 2));

package/lib/__tests__/update-hooks.test.js

@@ -44,6 +44,7 @@ describe('updateHooks', () => {
 
     fs.writeFileSync(path.join(hooksDir, 'pre-commit'), overrides['hooks/pre-commit'] || '#!/bin/bash\necho "hook-v2"');
     fs.writeFileSync(path.join(hooksDir, 'pre-push'), overrides['hooks/pre-push'] || '#!/bin/bash\necho "push-v2"');
+    fs.writeFileSync(path.join(hooksDir, 'post-merge'), overrides['hooks/post-merge'] || '#!/bin/bash\necho "merge-v2"');
     fs.writeFileSync(path.join(hooksLibDir, 'now-ms.sh'), overrides['hooks/lib/now-ms.sh'] || 'now_ms() { echo 123; }');
     fs.writeFileSync(path.join(tmpPackage, 'adapter-common.sh'), overrides['adapter-common.sh'] || '#!/bin/bash\necho "adapter-common-v2"');
     fs.writeFileSync(path.join(adaptersDir, 'typescript.sh'), overrides['adapters/typescript.sh'] || '#!/bin/bash\necho "ts-v2"');
@@ -81,6 +82,17 @@ describe('updateHooks', () => {
       expect(fs.readFileSync(path.join(dest, 'pre-push'), 'utf8')).toContain('push-v2');
     });
 
+    it('copies post-merge to destination (VERSION sync hook)', () => {
+      createPackageSource();
+      const mod = getModule();
+      const dest = path.join(tmpProject, 'hooks-postmerge');
+      fs.mkdirSync(dest, { recursive: true });
+
+      mod.copyHooks(tmpPackage, dest, false, true);
+
+      expect(fs.readFileSync(path.join(dest, 'post-merge'), 'utf8')).toContain('merge-v2');
+    });
+
     it('creates destination directory if it does not exist', () => {
       createPackageSource();
       const mod = getModule();

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

@@ -1,6 +1,7 @@
 /**
  * @test update-skill
  * @intent Verify updateSkill() handles check/all/single-name modes, config parsing, and delegates to installSkill correctly
+ * @covers AC-416-04
  */
 const fs = require('fs');
 const path = require('path');
@@ -218,21 +219,23 @@ describe('update-skill', () => {
     expect(logSpy).not.toHaveBeenCalledWith('✓ foo updated');
   });
 
-  it('removes existing targetDir before invoking installSkill', async () => {
+  it('leaves the target directory for installSkill to back up and replace', async () => {
     writeConfig({ foo: { version: '1.0.0' } });
     const dir = makeSkillDir('foo');
     expect(fs.existsSync(dir)).toBe(true);
 
-    let dirExistedDuringInstall = true;
+    let dirPresentDuringInstall = false;
     installSkillMock.mockImplementation(async () => {
-      dirExistedDuringInstall = fs.existsSync(dir);
+      dirPresentDuringInstall = fs.existsSync(dir);
       return 0;
     });
 
     const { updateSkill } = require('../update-skill');
     const result = await updateSkill('foo');
     expect(result).toBe(0);
-    expect(dirExistedDuringInstall).toBe(false); // rm'd before installSkill called
+    // update-skill has no delete of its own: installSkill backs the directory up
+    // before replacing it (#416).
+    expect(dirPresentDuringInstall).toBe(true);
   });
 
   it('does not crash when targetDir does not exist', async () => {

package/lib/detect-deps.js

@@ -3,7 +3,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const { HOME_DIR } = require('./shared-paths.js');
+const { HOME_DIR, detectPlatform } = require('./shared-paths.js');
 
 const REQUIRED_DEPS = [
   { name: 'superpowers', repo: 'obra/superpowers', minVersion: '1.0.0' },
@@ -257,25 +257,8 @@ const PLATFORM_PROFILES = {
   },
 };
 
-/**
- * Detect which AI agent platform is currently in use.
- * Checks for platform-specific directories in the user's home.
- * Falls back to 'opencode' if no platform is detected.
- *
- * @returns {'opencode' | 'claude-code' | 'qoder'}
- */
-function detectPlatform() {
-  // Check for Qoder-specific marker
-  if (fs.existsSync(path.join(HOME_DIR, '.qoder', 'skills'))) {
-    return 'qoder';
-  }
-  // Check for Claude Code-specific marker
-  if (fs.existsSync(path.join(HOME_DIR, '.claude', 'skills'))) {
-    return 'claude-code';
-  }
-  // Default to opencode (most common, backward compatible)
-  return 'opencode';
-}
+// detectPlatform() is re-exported from shared-paths.js — the single
+// implementation lives there (#424 removed the divergent copy).
 
 /**
  * Get the skills directories for a given platform.

package/lib/doctor-tui.js

@@ -64,13 +64,29 @@ function diagnoseTuiRegistration(checks) {
  * @returns {string|undefined}
  */
 function extractSkillVersion(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  // A line terminator, not "LF": a working tree checked out with
+  // core.autocrlf=true ships CRLF SKILL.md files, and the LF-only pattern
+  // returned undefined for every one of them -- pushing each skill into the
+  // byte-comparison branch and reporting it Outdated (#439).
+  const match = content.match(/^---(?:\r\n|\r|\n)([\s\S]*?)(?:\r\n|\r|\n)---/);
   if (!match) return undefined;
   const frontmatter = match[1];
   const versionMatch = frontmatter.match(/version:\s*(\S+)/);
   return versionMatch ? versionMatch[1] : undefined;
 }
 
+/**
+ * Compare two SKILL.md bodies ignoring line-ending style. Bundled copies come from
+ * whichever checkout packed them, installed copies come from whatever the platform's
+ * writer chose, so endings are never evidence of staleness (#439). Every convention
+ * normalizes: a lone CR is as much a line ending as CRLF, which is what this name
+ * already promises.
+ */
+function sameContentIgnoringLineEndings(a, b) {
+  const normalize = (s) => s.replace(/\r\n|\r|\n/g, '\n');
+  return normalize(a) === normalize(b);
+}
+
 /**
  * Compare two semver strings. Returns:
  *   -1 if a < b, 0 if a == b, 1 if a > b, undefined if either is not valid semver.
@@ -145,8 +161,8 @@ function diagnoseInstalledSkills(config, checks) {
     if (bundledVersion !== undefined && userVersion !== undefined) {
       const cmp = compareSemver(userVersion, bundledVersion);
       if (cmp === undefined) {
-        // Version strings not valid semver — fall back to byte comparison
-        if (bundledContent !== userContent) {
+        // Version strings not valid semver — fall back to content comparison
+        if (!sameContentIgnoringLineEndings(bundledContent, userContent)) {
           checks.push({
             name: `Skill: ${name}`,
             status: 'WARN',
@@ -168,8 +184,9 @@ function diagnoseInstalledSkills(config, checks) {
         checks.push({ name: `Skill: ${name}`, status: 'PASS', detail: 'Up to date' });
       }
     } else {
-      // No version in at least one file — fall back to byte-for-byte comparison
-      if (bundledContent !== userContent) {
+      // No version in at least one file — compare content, but not byte-for-byte:
+      // line endings alone are not evidence of staleness (#439).
+      if (!sameContentIgnoringLineEndings(bundledContent, userContent)) {
         checks.push({
           name: `Skill: ${name}`,
           status: 'WARN',