@wipcomputer/wip-ldm-os 0.4.85-alpha.3 → 0.4.85-alpha.30

package/scripts/test-ldm-status-timeout.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const tempRoot = mkdtempSync(join(tmpdir(), 'ldm-status-timeout-'));
+const sourceVersion = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version;
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function runStatus({ home, registryUrl }) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [join(root, 'bin', 'ldm.js'), 'status'], {
+      cwd: root,
+      env: {
+        ...process.env,
+        HOME: home,
+        LDM_STATUS_NPM_REGISTRY_URL: registryUrl,
+        LDM_STATUS_NPM_TIMEOUT_MS: '75',
+        LDM_STATUS_TOTAL_BUDGET_MS: '250',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('close', status => resolve({ status, stdout, stderr }));
+  });
+}
+
+function listen(server) {
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve(server.address()));
+  });
+}
+
+try {
+  const home = join(tempRoot, 'home');
+  const extensions = join(home, '.ldm', 'extensions');
+
+  mkdirSync(extensions, { recursive: true });
+  writeFileSync(join(home, '.ldm', 'version.json'), JSON.stringify({
+    version: '0.0.0-test',
+    installed: '2026-05-12T00:00:00.000Z',
+    updated: '2026-05-12T00:00:00.000Z',
+  }, null, 2) + '\n');
+  writeFileSync(join(extensions, 'registry.json'), JSON.stringify({
+    extensions: {
+      'hung-extension': {
+        source: { npm: 'hung-extension' },
+        installed: { version: '1.0.0' },
+      },
+      'second-extension': {
+        source: { npm: 'second-extension' },
+        installed: { version: '1.0.0' },
+      },
+    },
+  }, null, 2) + '\n');
+
+  const server = createServer((_req, res) => {
+    setTimeout(() => {
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ 'dist-tags': { latest: '9.9.9' } }));
+    }, 2000);
+  });
+  const address = await listen(server);
+
+  const startedAt = Date.now();
+  const result = await runStatus({ home, registryUrl: `http://${address.address}:${address.port}` });
+  const elapsedMs = Date.now() - startedAt;
+  server.closeAllConnections();
+  server.close();
+
+  assert(result.status === 0, `ldm status exited ${result.status}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  assert(elapsedMs < 2500, `ldm status should return before the process timeout; elapsed ${elapsedMs}ms`);
+  assert(result.stdout.includes(`LDM OS v${sourceVersion}`), `status should print installed LDM OS version\n${result.stdout}`);
+  assert(result.stdout.includes('Extensions: 2'), `status should print extension count\n${result.stdout}`);
+  assert(result.stdout.includes('Checking updates:'), `status should show progress before update checks\n${result.stdout}`);
+  assert(result.stdout.includes('hung-extension: checking npm'), `status should print the extension name before probing it\n${result.stdout}`);
+  assert(result.stdout.includes('Update checks skipped:'), `status should report skipped checks instead of hanging\n${result.stdout}`);
+  assert(/hung-extension: \[timeout \d+(ms|\.\d+s)\] hung-extension/.test(result.stdout), `hung extension should be reported as a timeout with elapsed time\n${result.stdout}`);
+} finally {
+  rmSync(tempRoot, { recursive: true, force: true });
+}
+
+console.log('ldm status timeout regression passed');

package/scripts/test-legacy-npm-sources-migration.mjs

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+// Fixture test for the Phase 1 source-types migration planner.
+// See lib/registry-migrations.mjs and
+// ai/product/bugs/installer/2026-05-13--cc-mini--installer-source-npm-honest-cleanup.md
+
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  planLegacyNpmSourcesMigration,
+  summaryHasChanges,
+  emptyLegacyNpmSourcesSummary,
+  executeDirectoryMoves,
+} from '../lib/registry-migrations.mjs';
+
+function fail(msg) {
+  throw new Error(msg);
+}
+
+function assertEqual(actual, expected, label) {
+  if (actual !== expected) {
+    fail(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+function assertDeepEqual(actual, expected, label) {
+  const a = JSON.stringify(actual, Object.keys(actual || {}).sort());
+  const e = JSON.stringify(expected, Object.keys(expected || {}).sort());
+  if (a !== e) {
+    fail(`${label}: expected ${e}, got ${a}`);
+  }
+}
+
+// Mirrors the shape we see on Parker's machine in the 2026-05-13 dogfood.
+function buildFixtureRegistry() {
+  return {
+    _format: 'v2',
+    extensions: {
+      // 404 npm + on-disk: should migrate to untracked.
+      'cc-session-export': {
+        source: { type: 'github', npm: 'session-export', repo: 'wipcomputer/cc-session-export' },
+        installed: { version: '1.0.0' },
+      },
+      // Duplicate of cc-session-export: should be deduped (removed).
+      'session-export': {
+        source: { type: 'github', npm: 'session-export' },
+        installed: { version: '1.0.0' },
+      },
+      'compaction-indicator': {
+        source: { type: 'github', npm: 'compaction-indicator' },
+        installed: { version: '1.0.1' },
+      },
+      'lesa-bridge': {
+        source: { type: 'github', npm: 'lesa-bridge' },
+        installed: { version: '0.3.0' },
+      },
+      // Duplicate of wip-branch-guard: should be deduped.
+      'package': {
+        source: { type: 'github', npm: '@wipcomputer/wip-branch-guard' },
+        installed: { version: '1.0.0' },
+      },
+      'wip-branch-guard': {
+        source: { type: 'github', npm: '@wipcomputer/wip-branch-guard' },
+        installed: { version: '1.0.0' },
+      },
+      // Real npm package: should be left alone.
+      'memory-crystal': {
+        source: { type: 'github', npm: '@wipcomputer/memory-crystal' },
+        installed: { version: '2.0.0' },
+      },
+      // Phantom: no on-disk directory. Should be removed.
+      'tavily': {
+        source: { type: 'github', npm: '@wipcomputer/openclaw-tavily' },
+        installed: { version: '0.1.0' },
+      },
+      // Mystery row: no source info at all but on-disk. Should be classified
+      // untracked (Step 4 path in the planner).
+      //
+      // Note: on Parker's real machine the `run` entry has no on-disk
+      // directory, so it hits Step 1 (phantom removal) instead. We exercise
+      // the Step 4 path here via this fixture; Step 1 is covered by the
+      // `tavily` fixture below.
+      'run': {
+        installed: { version: 'unknown' },
+      },
+      // Already migrated: must be skipped (idempotency).
+      'already-untracked': {
+        updateSource: { type: 'untracked' },
+        provenance: { 'legacy-npm-name': 'already-untracked', untrackedSince: '2026-05-13T00:00:00.000Z' },
+        installed: { version: '0.1.0' },
+      },
+      // Probe will fail (timeout). Should be left alone, listed in probeFailures.
+      'flaky-network': {
+        source: { type: 'github', npm: 'flaky-network' },
+        installed: { version: '0.1.0' },
+      },
+      // Custom-path entry: declares `paths.ldm` pointing outside the default
+      // ~/.ldm/extensions/<name> location. The planner must NOT classify
+      // this as a phantom. Its source.npm is 404, so it should be migrated
+      // to untracked while the custom path is preserved.
+      'custom-path-untracked': {
+        source: { type: 'github', npm: 'custom-path-untracked' },
+        paths: { ldm: '/custom/location/path' },
+        installed: { version: '1.0.0' },
+      },
+      // Legacy custom-path field (`ldmPath` flat). Same expectation.
+      'legacy-custom-path': {
+        source: { type: 'github', npm: 'legacy-custom-path' },
+        ldmPath: '/legacy/custom/path',
+        installed: { version: '0.2.0' },
+      },
+    },
+  };
+}
+
+const NPM_404 = new Set([
+  'session-export',
+  'compaction-indicator',
+  'lesa-bridge',
+  'custom-path-untracked',
+  'legacy-custom-path',
+  // @wipcomputer/wip-branch-guard simulated as 200 (exists). But the dedupe
+  // happens first, so `package` is gone before the probe runs.
+  // The remaining `wip-branch-guard` will see exists=true and be left alone.
+]);
+const NPM_200 = new Set([
+  '@wipcomputer/memory-crystal',
+  '@wipcomputer/wip-branch-guard',
+]);
+const NPM_FAIL = new Set([
+  'flaky-network',
+]);
+
+function fakeProbeNpm(name) {
+  if (NPM_FAIL.has(name)) return Promise.resolve(null);
+  if (NPM_200.has(name)) return Promise.resolve(true);
+  if (NPM_404.has(name)) return Promise.resolve(false);
+  // Fail loudly when the planner probes an npm name the test forgot to
+  // enumerate. Future planner changes that call probeNpm with new names
+  // must explicitly declare expected behavior here; silent 404 defaults
+  // would swallow regressions.
+  fail(`fakeProbeNpm called with un-enumerated name "${name}"`);
+}
+
+// On-disk extension simulator. `tavily` is a phantom (no directory at any
+// location). All other names get a default directory unless they declare a
+// custom path, in which case we honor the custom path. The planner must
+// pass the entry to extensionExists for this to work.
+const PHANTOM_NAMES = new Set(['tavily']);
+const CUSTOM_PATH_EXISTS = new Set(['/custom/location/path', '/legacy/custom/path']);
+function fakeExtensionExists(name, entry) {
+  if (entry?.paths?.ldm) return CUSTOM_PATH_EXISTS.has(entry.paths.ldm);
+  if (entry?.ldmPath) return CUSTOM_PATH_EXISTS.has(entry.ldmPath);
+  return !PHANTOM_NAMES.has(name);
+}
+
+const FIXED_NOW = () => new Date('2026-05-13T18:00:00.000Z');
+
+// ── Test 1: full migration on fixture ──────────────────────────────────────
+{
+  const input = buildFixtureRegistry();
+  const inputSnapshot = JSON.stringify(input);
+
+  const { newRegistry, summary } = await planLegacyNpmSourcesMigration({
+    registry: input,
+    probeNpm: fakeProbeNpm,
+    extensionExists: fakeExtensionExists,
+    now: FIXED_NOW,
+  });
+
+  // Input must not be mutated.
+  assertEqual(JSON.stringify(input), inputSnapshot, 'input registry mutated');
+
+  // Phantoms removed.
+  assertEqual(summary.phantomsRemoved.length, 1, 'phantomsRemoved.length');
+  assertEqual(summary.phantomsRemoved[0].name, 'tavily', 'phantom name');
+  assertEqual(newRegistry.extensions.tavily, undefined, 'phantom still in registry');
+
+  // Duplicates removed.
+  assertEqual(summary.duplicatesRemoved.length, 2, 'duplicatesRemoved.length');
+  const removedDupes = summary.duplicatesRemoved.map(d => d.removed).sort();
+  assertDeepEqual(removedDupes, ['package', 'session-export'], 'dedupe targets');
+  assertEqual(newRegistry.extensions['session-export'], undefined, 'session-export still in registry');
+  assertEqual(newRegistry.extensions['package'], undefined, 'package still in registry');
+  if (!newRegistry.extensions['cc-session-export']) fail('canonical cc-session-export removed');
+  if (!newRegistry.extensions['wip-branch-guard']) fail('canonical wip-branch-guard removed');
+
+  // Each removed duplicate must also produce a directoryMoves entry. The
+  // wrapper in bin/ldm.js executes these moves after the registry write so
+  // autoDetectExtensions cannot re-register the duplicate on the same install
+  // run. Without this contract, the registry dedup reverts (see
+  // ai/product/bugs/installer/2026-05-13--cc-mini--installer-dedup-reverts-between-installs.md).
+  assertEqual(summary.directoryMoves.length, 2, 'directoryMoves.length');
+  const moveNames = summary.directoryMoves.map(m => m.name).sort();
+  assertDeepEqual(moveNames, ['package', 'session-export'], 'directoryMoves names');
+  for (const m of summary.directoryMoves) {
+    assertEqual(m.reason, 'deduplicated', `directoryMoves[${m.name}].reason`);
+    if (!m.trashName.startsWith(`${m.name}-deduplicated-`)) {
+      fail(`directoryMoves[${m.name}].trashName should start with "${m.name}-deduplicated-" but was "${m.trashName}"`);
+    }
+    if (!m.trashName.includes('2026-05-13T18-00-00-000Z')) {
+      fail(`directoryMoves[${m.name}].trashName should embed the fixed-now timestamp but was "${m.trashName}"`);
+    }
+  }
+
+  // The planner is pure: it must NOT pre-populate directoryMovesPerformed or
+  // directoryMovesSkipped. Those are wrapper outputs from real filesystem I/O.
+  assertEqual(summary.directoryMovesPerformed.length, 0, 'directoryMovesPerformed should be empty from pure planner');
+  assertEqual(summary.directoryMovesSkipped.length, 0, 'directoryMovesSkipped should be empty from pure planner');
+
+  // Migrated entries: cc-session-export, compaction-indicator, lesa-bridge,
+  // run, plus the two custom-path entries (custom-path-untracked,
+  // legacy-custom-path). `session-export` and `package` were deduped before
+  // probe. `wip-branch-guard` exists on npm. `flaky-network` probe failed.
+  const migratedNames = summary.migrated.map(m => m.name).sort();
+  assertDeepEqual(migratedNames, [
+    'cc-session-export', 'compaction-indicator', 'custom-path-untracked',
+    'legacy-custom-path', 'lesa-bridge', 'run',
+  ], 'migrated names');
+
+  // Custom-path entries must NOT be removed as phantoms. The planner must
+  // pass the entry to extensionExists so the custom path is honored.
+  // Regression guard for the round-3 Codex blocker (data-loss path on
+  // entries with entry.paths.ldm or entry.ldmPath).
+  const cpu = newRegistry.extensions['custom-path-untracked'];
+  if (!cpu) fail('custom-path-untracked was removed as phantom (extensionExists ignored entry.paths.ldm)');
+  assertEqual(cpu.updateSource?.type, 'untracked', 'custom-path-untracked.updateSource.type');
+  assertEqual(cpu.paths?.ldm, '/custom/location/path', 'custom-path-untracked.paths.ldm preserved');
+  const lcp = newRegistry.extensions['legacy-custom-path'];
+  if (!lcp) fail('legacy-custom-path was removed as phantom (extensionExists ignored entry.ldmPath)');
+  assertEqual(lcp.updateSource?.type, 'untracked', 'legacy-custom-path.updateSource.type');
+  assertEqual(lcp.ldmPath, '/legacy/custom/path', 'legacy-custom-path.ldmPath preserved');
+
+  // Each migrated entry has updateSource.type=untracked.
+  for (const name of migratedNames) {
+    const e = newRegistry.extensions[name];
+    if (!e) fail(`migrated entry ${name} missing from newRegistry`);
+    assertEqual(e.updateSource?.type, 'untracked', `${name}.updateSource.type`);
+    if ('source' in e) fail(`${name}.source should be deleted`);
+    if (!e.provenance) fail(`${name}.provenance missing`);
+    assertEqual(e.provenance.untrackedSince, '2026-05-13T18:00:00.000Z', `${name}.provenance.untrackedSince`);
+  }
+
+  // cc-session-export specifically: legacy-npm-name + repo preserved.
+  const ccse = newRegistry.extensions['cc-session-export'];
+  assertEqual(ccse.provenance['legacy-npm-name'], 'session-export', 'cc-session-export legacy-npm-name');
+  assertEqual(ccse.provenance.repo, 'wipcomputer/cc-session-export', 'cc-session-export legacy repo');
+
+  // `run` had no source info: legacy-npm-name absent, no repo, but still classified.
+  const runEntry = newRegistry.extensions.run;
+  if ('legacy-npm-name' in runEntry.provenance) fail('run.provenance should not have legacy-npm-name');
+  if ('repo' in runEntry.provenance) fail('run.provenance should not have repo');
+
+  // Real npm package left alone.
+  const mc = newRegistry.extensions['memory-crystal'];
+  if (mc.updateSource) fail('memory-crystal should not be migrated (real npm pkg)');
+  assertEqual(mc.source?.npm, '@wipcomputer/memory-crystal', 'memory-crystal source preserved');
+
+  // wip-branch-guard left alone (real npm pkg).
+  const wbg = newRegistry.extensions['wip-branch-guard'];
+  if (wbg.updateSource) fail('wip-branch-guard should not be migrated (real npm pkg)');
+
+  // Already-untracked entry is unchanged.
+  const au = newRegistry.extensions['already-untracked'];
+  assertEqual(au.provenance.untrackedSince, '2026-05-13T00:00:00.000Z', 'already-untracked untracked since preserved');
+
+  // Probe failures recorded, entry untouched.
+  assertEqual(summary.probeFailures.length, 1, 'probeFailures.length');
+  assertEqual(summary.probeFailures[0].name, 'flaky-network', 'probe failure name');
+  const fn = newRegistry.extensions['flaky-network'];
+  if (fn.updateSource) fail('flaky-network should not be migrated (probe failed)');
+  assertEqual(fn.source?.npm, 'flaky-network', 'flaky-network source preserved');
+
+  // summaryHasChanges flips true when anything happens.
+  assertEqual(summaryHasChanges(summary), true, 'summaryHasChanges on populated summary');
+}
+
+// ── Test 2: idempotency on a fully-migrated registry ───────────────────────
+{
+  const registry = {
+    extensions: {
+      'a': {
+        updateSource: { type: 'untracked' },
+        provenance: { untrackedSince: '2026-05-13T00:00:00.000Z' },
+        installed: { version: '1.0.0' },
+      },
+      'b': {
+        updateSource: { type: 'untracked' },
+        provenance: { 'legacy-npm-name': 'b', untrackedSince: '2026-05-13T00:00:00.000Z' },
+        installed: { version: '0.1.0' },
+      },
+    },
+  };
+  const before = JSON.stringify(registry);
+  const { newRegistry, summary } = await planLegacyNpmSourcesMigration({
+    registry,
+    probeNpm: () => fail('probeNpm should not be called on fully-migrated registry'),
+    extensionExists: () => true,
+    now: FIXED_NOW,
+  });
+  assertEqual(JSON.stringify(registry), before, 'input mutated on idempotent run');
+  assertEqual(summary.migrated.length, 0, 'migrated.length on idempotent run');
+  assertEqual(summary.phantomsRemoved.length, 0, 'phantomsRemoved.length on idempotent run');
+  assertEqual(summary.duplicatesRemoved.length, 0, 'duplicatesRemoved.length on idempotent run');
+  assertEqual(summary.directoryMoves.length, 0, 'directoryMoves.length on idempotent run');
+  assertEqual(summaryHasChanges(summary), false, 'summaryHasChanges on empty summary');
+  assertDeepEqual(
+    Object.keys(newRegistry.extensions).sort(),
+    ['a', 'b'],
+    'extensions preserved on idempotent run',
+  );
+}
+
+// ── Test 3: emptyLegacyNpmSourcesSummary returns the canonical shape ───────
+{
+  const e = emptyLegacyNpmSourcesSummary();
+  assertDeepEqual(Object.keys(e).sort(), [
+    'directoryMoves',
+    'directoryMovesPerformed',
+    'directoryMovesSkipped',
+    'duplicatesRemoved',
+    'migrated',
+    'phantomsRemoved',
+    'probeFailures',
+    'probedCount',
+    'timestamp',
+  ], 'empty summary keys');
+  // Wrapper-output fields start empty even though the planner doesn't
+  // populate them ... the wrapper is responsible for appending.
+  assertEqual(e.directoryMoves.length, 0, 'empty.directoryMoves');
+  assertEqual(e.directoryMovesPerformed.length, 0, 'empty.directoryMovesPerformed');
+  assertEqual(e.directoryMovesSkipped.length, 0, 'empty.directoryMovesSkipped');
+}
+
+// ── Test 4: executeDirectoryMoves against a real temp filesystem ──────────
+// Regression guard for the bug fixed by this PR
+// (ai/product/bugs/installer/2026-05-13--cc-mini--installer-dedup-reverts-between-installs.md).
+// The planner emits directoryMoves entries; the executor must actually move
+// the on-disk directories into trash so autoDetectExtensions cannot
+// re-register them on the next install scan.
+{
+  const tmpHome = mkdtempSync(join(tmpdir(), 'ldm-dedup-trash-'));
+  try {
+    const extensionsRoot = join(tmpHome, 'extensions');
+    const trashRoot = join(tmpHome, '_trash');
+    mkdirSync(extensionsRoot, { recursive: true });
+
+    // Stand up the two duplicate directories the planner would dedup.
+    for (const name of ['session-export', 'package']) {
+      const dir = join(extensionsRoot, name);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, 'package.json'), JSON.stringify({ name, version: '1.0.0' }) + '\n');
+    }
+    // And a non-duplicate that must be left alone (proxy for cc-session-export).
+    const ccsePath = join(extensionsRoot, 'cc-session-export');
+    mkdirSync(ccsePath, { recursive: true });
+    writeFileSync(join(ccsePath, 'package.json'), JSON.stringify({ name: 'cc-session-export', version: '1.0.0' }) + '\n');
+
+    // Run the planner with the fixture to get a real directoryMoves plan.
+    const registry = {
+      extensions: {
+        'cc-session-export': { source: { npm: 'session-export' }, installed: { version: '1.0.0' } },
+        'session-export':    { source: { npm: 'session-export' }, installed: { version: '1.0.0' } },
+        'wip-branch-guard':  { source: { npm: '@wipcomputer/wip-branch-guard' }, installed: { version: '1.0.0' } },
+        'package':           { source: { npm: '@wipcomputer/wip-branch-guard' }, installed: { version: '1.0.0' } },
+      },
+    };
+    const { summary } = await planLegacyNpmSourcesMigration({
+      registry,
+      probeNpm: (name) => Promise.resolve(name === '@wipcomputer/wip-branch-guard'),
+      extensionExists: () => true,
+      now: FIXED_NOW,
+    });
+    assertEqual(summary.directoryMoves.length, 2, 'dedup plan produces 2 directoryMoves');
+
+    // Execute the moves against the temp filesystem.
+    const { performed, skipped } = executeDirectoryMoves({
+      directoryMoves: summary.directoryMoves,
+      extensionsRoot,
+      trashRoot,
+    });
+    assertEqual(performed.length, 2, 'executor performed 2 moves');
+    assertEqual(skipped.length, 0, 'executor did not skip any moves');
+
+    // Source directories are gone.
+    if (existsSync(join(extensionsRoot, 'session-export'))) {
+      fail('session-export directory should have been moved out of extensions/');
+    }
+    if (existsSync(join(extensionsRoot, 'package'))) {
+      fail('package directory should have been moved out of extensions/');
+    }
+
+    // Trash directory now has the moved entries with the deduplicated suffix.
+    const trashContents = readdirSync(trashRoot);
+    if (!trashContents.some(name => name.startsWith('session-export-deduplicated-'))) {
+      fail(`trash should contain session-export-deduplicated-* but had: ${trashContents.join(', ')}`);
+    }
+    if (!trashContents.some(name => name.startsWith('package-deduplicated-'))) {
+      fail(`trash should contain package-deduplicated-* but had: ${trashContents.join(', ')}`);
+    }
+
+    // Non-duplicate must NOT have been touched.
+    if (!existsSync(ccsePath)) fail('cc-session-export directory should be untouched');
+
+    // autoDetectExtensions simulation: a fresh scan of extensionsRoot must
+    // NOT see the moved duplicates. We replicate the production logic
+    // (bin/ldm.js autoDetectExtensions): scan top-level dirs in
+    // extensionsRoot, skip dirs named `_trash` or starting with `.` or
+    // `ldm-install-`, and treat any remaining dir with a package.json as a
+    // candidate for auto-registration.
+    const candidatesAfterMove = readdirSync(extensionsRoot, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .filter(name => name !== '_trash' && !name.startsWith('.') && !name.startsWith('ldm-install-'))
+      .filter(name => existsSync(join(extensionsRoot, name, 'package.json')))
+      .sort();
+    assertDeepEqual(
+      candidatesAfterMove,
+      ['cc-session-export'],
+      'autoDetect should see only the non-duplicate after the moves; duplicates must be gone',
+    );
+
+    // Idempotency: running executeDirectoryMoves again must skip all
+    // (source-missing) and not fail.
+    const second = executeDirectoryMoves({
+      directoryMoves: summary.directoryMoves,
+      extensionsRoot,
+      trashRoot,
+    });
+    assertEqual(second.performed.length, 0, 'second execute call performs nothing');
+    assertEqual(second.skipped.length, 2, 'second execute call skips both moves');
+    for (const s of second.skipped) {
+      assertEqual(s.reason, 'source-missing', `second-call skip reason for ${s.name}`);
+    }
+  } finally {
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+}
+
+// ── Test 5: executeDirectoryMoves with no moves is a no-op ───────────────
+{
+  const tmpHome = mkdtempSync(join(tmpdir(), 'ldm-dedup-trash-empty-'));
+  try {
+    const result = executeDirectoryMoves({
+      directoryMoves: [],
+      extensionsRoot: join(tmpHome, 'extensions'),
+      trashRoot: join(tmpHome, '_trash'),
+    });
+    assertEqual(result.performed.length, 0, 'empty plan -> no performed');
+    assertEqual(result.skipped.length, 0, 'empty plan -> no skipped');
+    if (existsSync(join(tmpHome, '_trash'))) {
+      fail('executor should not pre-create trashRoot when there are no moves');
+    }
+  } finally {
+    rmSync(tmpHome, { recursive: true, force: true });
+  }
+}
+
+console.log('test-legacy-npm-sources-migration: all tests passed');

package/scripts/test-readme-install-prompt.mjs

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+const readme = readFileSync(new URL("../README.md", import.meta.url), "utf8");
+const promptTemplate = readFileSync(
+  new URL("../shared/templates/install-prompt.md", import.meta.url),
+  "utf8",
+);
+const skill = readFileSync(new URL("../SKILL.md", import.meta.url), "utf8");
+
+const promptStart = readme.indexOf("Read https://wip.computer/install/wip-ldm-os.txt");
+const promptEnd = readme.indexOf("```", promptStart);
+
+assert(promptStart >= 0, "README install prompt must point at the public install document");
+assert(promptEnd > promptStart, "README install prompt must be fenced");
+
+const readmePrompt = readme.slice(promptStart, promptEnd);
+
+for (const [label, prompt] of [
+  ["README install prompt", readmePrompt],
+  ["shared install prompt template", promptTemplate],
+]) {
+  assert(
+    prompt.includes("Read https://wip.computer/install/wip-ldm-os.txt"),
+    `${label} must delegate to the public install document`,
+  );
+
+  assert(
+    prompt.includes("Use the install document and live local checks as the source of truth."),
+    `${label} must name the install document as source of truth`,
+  );
+
+  assert(
+    prompt.includes("use the selected track's dry-run path from the install document"),
+    `${label} must delegate dry-run command mapping to SKILL.md`,
+  );
+
+  assert(
+    prompt.includes("use the selected track's install path from the install document"),
+    `${label} must delegate install command mapping to SKILL.md`,
+  );
+
+  for (const forbidden of [
+    "Track choices:",
+    "ldm install --alpha",
+    "ldm install --beta",
+    "ldm install --dry-run",
+  ]) {
+    assert(!prompt.includes(forbidden), `${label} must not include ${forbidden}`);
+  }
+}
+
+for (const required of [
+  "## Tracks",
+  "npm view @wipcomputer/wip-ldm-os dist-tags --json",
+  "stable/current/latest: `ldm install --dry-run`",
+  "beta/latest beta: `ldm install --beta --dry-run`",
+  "alpha/latest alpha: `ldm install --alpha --dry-run`",
+  "beta/latest beta: `npm install -g @wipcomputer/wip-ldm-os@beta`",
+  "alpha/latest alpha: `npm install -g @wipcomputer/wip-ldm-os@alpha`",
+  "The README prompt should stay short. This install document owns the detailed track rules.",
+]) {
+  assert(skill.includes(required), `SKILL.md must own track-selection logic: ${required}`);
+}
+
+console.log("readme-install-prompt: prompt stays short and delegates track rules to SKILL.md");

package/shared/templates/install-prompt.md

@@ -6,7 +6,19 @@ Open your AI and paste this:
 
 Read https://wip.computer/install/wip-ldm-os.txt
 
-Check if LDM OS is already installed. If it is, run ldm install --dry-run and show me what I have and what's new.
+Use the install document and live local checks as the source of truth.
+Do not search memory or prior notes for this install. Do not pre-load context from `MEMORY.md`, `crystal_search`, local skill dev guides, or other local memory before fetching the install document.
+Do not run GitHub commands during this install flow. Do not run or request approval for `gh release`, `gh api`, or `gh search`. If release notes are not available from local or npm metadata, say that and do not fetch them from GitHub.
+
+Check if LDM OS is installed (`which ldm && ldm --version`). Branch.
+
+If installed: run `ldm status`, check available npm tracks from the install document, and show me the version table, what's new for each component, and which stable/current, beta, and alpha versions are available. Then ask:
+- Do you have questions?
+- Want to see a dry run?
+
+If yes to dry run, use the selected track's dry-run path from the install document.
+
+If I say install, use the selected track's install path from the install document, then run `ldm doctor`.
 
 If not, walk me through setup and explain:
 
@@ -19,7 +31,13 @@ Then ask:
 - Do you have questions?
 - Want to see a dry run?
 
-If I say yes: Install the CLI first (npm install -g @wipcomputer/wip-ldm-os) and then run ldm install --dry-run.
+If yes to dry run, install the CLI first using the selected track's bootstrap command from the install document.
+
+Then run:
+`ldm init --dry-run`
+
+If I say install, run:
+`ldm init`
 
 Show me exactly what will change. Don't install anything until I say "install".