claude-dev-env 7.7.1 → 8.1.0

package/bin/install.test.mjs

@@ -11,8 +11,6 @@ import {
     readdirSync,
     existsSync,
     copyFileSync,
-    cpSync,
-    lstatSync,
 } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
@@ -20,8 +18,6 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import {
     collectPackageSourceConflicts,
-    installPstackRelease,
-    shouldInstallPstackRelease,
     CONTENT_DIRECTORIES,
     CORE_INCLUDE_DIRECTORIES,
     CORE_SKILLS,
@@ -54,7 +50,6 @@ import {
     hookCommandComparisonSpelling,
     detectPython,
     retainNewestRunBackupOnly,
-    refreshInstalledPstackPluginManifest,
 } from './install.mjs';
 import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
 
@@ -2881,42 +2876,6 @@ test('pruneStaleInstalledFiles leaves the run backup root standing when the rena
     }
 });
 
-test('the pstack step writes a manifest for a skills root that carries pstack', () => {
-    const skillsRoot = mkdtempSync(join(tmpdir(), 'cdev-pstack-step-'));
-    try {
-        const skillDirectory = join(skillsRoot, 'pstack', 'how');
-        mkdirSync(skillDirectory, { recursive: true });
-        writeFileSync(join(skillDirectory, 'SKILL.md'), '---\nname: how\n---\n');
-
-        const manifestPath = refreshInstalledPstackPluginManifest(skillsRoot);
-
-        assert.equal(
-            manifestPath,
-            join(skillsRoot, 'pstack', '.claude-plugin', 'plugin.json'),
-            'the step reports the manifest it wrote so the run records the path',
-        );
-        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        assert.deepEqual(manifest.skills, ['./how']);
-        assert.equal(
-            refreshInstalledPstackPluginManifest(skillsRoot),
-            null,
-            'a second run writes nothing and reports no path',
-        );
-    } finally {
-        rmSync(skillsRoot, { recursive: true, force: true });
-    }
-});
-
-test('the pstack step reports no path for a skills root without pstack', () => {
-    const skillsRoot = mkdtempSync(join(tmpdir(), 'cdev-pstack-absent-'));
-    try {
-        assert.equal(refreshInstalledPstackPluginManifest(skillsRoot), null);
-        assert.equal(existsSync(join(skillsRoot, 'pstack')), false);
-    } finally {
-        rmSync(skillsRoot, { recursive: true, force: true });
-    }
-});
-
 const RETIRED_SKILLS = ['pr-small-cl', 'session-log', 'session-tidy'];
 
 test('each core skill has a shipped entry point', () => {
@@ -2934,13 +2893,9 @@ test('retired skills leave install groups and stay in the cleanup registry', ()
     }
 });
 
-test('README and vault guidance use current session tools', () => {
+test('the README names current session tools', () => {
     const readme = readFileSync(new URL('../../../README.md', import.meta.url), 'utf8');
-    const vaultRule = readFileSync(new URL('../rules/vault-context.md', import.meta.url), 'utf8');
     assert.doesNotMatch(readme, /--only journal|session-log|session-tidy/);
-    assert.doesNotMatch(vaultRule, /`session-log`|`recall`/);
-    assert.match(vaultRule, /obsidian MCP tools/);
-    assert.match(vaultRule, /project.*frontmatter/);
 });
 
 test('the help output states that the installer reads only flags', () => {
@@ -2980,43 +2935,24 @@ test('pruneRetiredHookEntriesFromSettings warns and returns 0 when the host conf
 
 const PSTACK_TEST_PACKAGE_ROOT = dirname(fileURLToPath(new URL('./install.mjs', import.meta.url)));
 const PSTACK_TEST_INSTALLER_PATH = fileURLToPath(new URL('./install.mjs', import.meta.url));
-const PSTACK_TEST_LOCK = JSON.parse(readFileSync(
-    new URL('../scripts/pstack.lock.json', import.meta.url),
-    'utf8',
-));
-
-function writePstackFixtureFile(filePath, fileContent) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, fileContent);
-}
 
-function pstackUpstreamFixture(t) {
-    const temporaryRoot = mkdtempSync(join(tmpdir(), 'cdev-install-pstack-'));
-    t.after(() => rmSync(temporaryRoot, { recursive: true, force: true }));
-    const checkout = join(temporaryRoot, 'checkout');
-    for (const [component, allSkillNames] of Object.entries(PSTACK_TEST_LOCK.requiredSkills)) {
-        for (const skillName of allSkillNames) {
-            writePstackFixtureFile(
-                join(checkout, component, 'skills', skillName, 'SKILL.md'),
-                `---\nname: ${skillName}\ndescription: Test ${skillName}.\n---\n\nRun ${skillName}.\n`,
-            );
-        }
-    }
-    const managedRoot = join(temporaryRoot, 'home', '.claude');
-    return {
-        managedRoot,
-        options: {
-            root: managedRoot,
-            lock: structuredClone(PSTACK_TEST_LOCK),
-            packageRoot: dirname(PSTACK_TEST_PACKAGE_ROOT),
-        },
-        dependencies: {
-            fetchSource: (_lock, destination) => cpSync(checkout, destination, { recursive: true }),
-        },
-    };
+function writeRecordingHostCommand(directory, name, logPath) {
+    mkdirSync(directory, { recursive: true });
+    if (process.platform === 'win32') {
+        const batchPath = join(directory, `${name}.cmd`);
+        writeFileSync(batchPath, `@echo off\r\n>>"${logPath}" echo ${name} %*\r\n`);
+        return batchPath;
+    }
+    const commandPath = join(directory, name);
+    writeFileSync(
+        commandPath,
+        `#!/bin/sh\nprintf '%s %s\\n' "${name}" "$*" >> "${logPath}"\n`,
+        { mode: 0o755 },
+    );
+    return commandPath;
 }
 
-function runPstackInstaller(homeDirectory, extraArguments) {
+function runPstackInstaller(homeDirectory, extraArguments, environmentOverrides = {}) {
     return execFileSync('node', [PSTACK_TEST_INSTALLER_PATH, ...extraArguments], {
         cwd: dirname(PSTACK_TEST_PACKAGE_ROOT),
         encoding: 'utf8',
@@ -3028,82 +2964,80 @@ function runPstackInstaller(homeDirectory, extraArguments) {
             CLAUDE_CONFIG_DIR: join(homeDirectory, '.claude'),
             GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
             CDE_INSTALL_PSTACK: '1',
-            GIT_ALLOW_PROTOCOL: 'none',
+            ...environmentOverrides,
         },
     });
 }
 
-function withPstackTemporaryHome(t, runAssertions) {
+function pstackPluginSandbox(t) {
     const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-install-pstack-run-'));
     t.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
-    runAssertions(homeDirectory);
+    const commandLogPath = join(homeDirectory, 'host-commands.log');
+    const commandDirectory = join(homeDirectory, 'host-commands');
+    return {
+        homeDirectory,
+        commandLogPath,
+        environment: {
+            CDE_CLAUDE_EXECUTABLE: writeRecordingHostCommand(commandDirectory, 'claude', commandLogPath),
+            CDE_CODEX_EXECUTABLE: writeRecordingHostCommand(commandDirectory, 'codex', commandLogPath),
+        },
+        recordedCommands() {
+            if (!existsSync(commandLogPath)) return [];
+            return readFileSync(commandLogPath, 'utf8')
+                .split(/\r?\n/)
+                .map(eachLine => eachLine.trim())
+                .filter(Boolean);
+        },
+    };
 }
 
-test('the base install publishes the pstack poteto-mode entry into the managed skills home', t => {
-    const fixture = pstackUpstreamFixture(t);
+test('a full install adds the pstack marketplace and plugin on both hosts', t => {
+    const sandbox = pstackPluginSandbox(t);
 
-    const outcome = installPstackRelease(fixture.options, fixture.dependencies);
+    const installerOutput = runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
 
-    assert.equal(outcome.status, 'installed');
-    assert.equal(outcome.warning, null);
-    const pstackRoot = join(fixture.managedRoot, 'skills', 'pstack');
-    const entryPath = join(pstackRoot, 'poteto-mode');
-    assert.equal(lstatSync(pstackRoot).isSymbolicLink(), true, 'the pstack root is a pointer into the release');
-    assert.equal(existsSync(join(entryPath, 'SKILL.md')), true, 'the nested entry resolves to a skill');
+    assert.deepEqual(sandbox.recordedCommands(), [
+        'claude plugin marketplace add michael-denyer/pstack-claude',
+        'claude plugin install pstack@pstack-claude',
+        'codex plugin marketplace add michael-denyer/pstack-claude',
+        'codex plugin add pstack@pstack-claude',
+    ]);
+    assert.match(installerOutput, /Pstack \(claude\): installed/);
+    assert.match(installerOutput, /Pstack \(codex\): installed/);
 });
 
-test('an unreachable pstack upstream reports a warning and keeps the base install going', t => {
-    const fixture = pstackUpstreamFixture(t);
+test('an absent host command is reported and leaves the other host installed', t => {
+    const sandbox = pstackPluginSandbox(t);
 
-    const outcome = installPstackRelease(fixture.options, {
-        fetchSource: () => { throw new Error('network unavailable'); },
+    const installerOutput = runPstackInstaller(sandbox.homeDirectory, [], {
+        ...sandbox.environment,
+        CDE_CODEX_EXECUTABLE: join(sandbox.homeDirectory, 'host-commands', 'absent-codex-command'),
     });
 
-    assert.equal(outcome.status, 'failed');
-    assert.equal(outcome.release, null);
-    assert.match(outcome.warning, /network unavailable/);
-});
-
-test('--no-pstack and CDE_INSTALL_PSTACK=0 each turn the pstack step off', () => {
-    assert.equal(shouldInstallPstackRelease([], {}), true);
-    assert.equal(shouldInstallPstackRelease(['--no-pstack'], {}), false);
-    assert.equal(shouldInstallPstackRelease([], { CDE_INSTALL_PSTACK: '0' }), false);
-    assert.equal(shouldInstallPstackRelease([], { CDE_INSTALL_PSTACK: '1' }), true);
+    assert.match(installerOutput, /Pstack \(claude\): installed/);
+    assert.match(
+        installerOutput,
+        /Pstack \(codex\): (skipped|failed)/,
+        'the absent host is reported either way, and the two unit tests pin which signal maps to skipped',
+    );
+    assert.doesNotMatch(installerOutput, /Pstack \(codex\): installed/);
+    assert.deepEqual(
+        sandbox.recordedCommands().filter(eachCommand => eachCommand.startsWith('codex')),
+        [],
+    );
 });
 
-test('a full install runs the pstack step and reports an upstream failure without stopping', t => {
-    withPstackTemporaryHome(t, homeDirectory => {
-        const installerOutput = runPstackInstaller(homeDirectory, []);
-
-        assert.match(installerOutput, /Pstack:/, 'the run reports the pstack step');
-        assert.equal(existsSync(join(homeDirectory, '.claude', 'pstack')), true);
-    });
-});
+test('--no-pstack leaves both hosts untouched', t => {
+    const sandbox = pstackPluginSandbox(t);
 
-test('--no-pstack leaves the pstack store absent', t => {
-    withPstackTemporaryHome(t, homeDirectory => {
-        const installerOutput = runPstackInstaller(homeDirectory, ['--no-pstack']);
+    const installerOutput = runPstackInstaller(
+        sandbox.homeDirectory, ['--no-pstack'], sandbox.environment,
+    );
 
-        assert.doesNotMatch(installerOutput, /Pstack:/);
-        assert.equal(existsSync(join(homeDirectory, '.claude', 'pstack')), false);
-    });
+    assert.deepEqual(sandbox.recordedCommands(), []);
+    assert.doesNotMatch(installerOutput, /Pstack \(/);
 });
 
-function runContinuityInstaller(homeDirectory, extraArguments) {
-    return execFileSync('node', [PSTACK_TEST_INSTALLER_PATH, ...extraArguments], {
-        cwd: dirname(PSTACK_TEST_PACKAGE_ROOT),
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            CDE_INSTALL_PSTACK: '0',
-            HOME: homeDirectory,
-            USERPROFILE: homeDirectory,
-            GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
-            CODEX_HOME: join(homeDirectory, '.codex'),
-        },
-    });
-}
-
 function continuityCommandCount(configurationPath) {
     if (!existsSync(configurationPath)) return 0;
     const configuration = JSON.parse(readFileSync(configurationPath, 'utf8'));
@@ -3116,32 +3050,59 @@ function continuityCommandCount(configurationPath) {
     ).length;
 }
 
-test('a full install registers the session-continuity companion in every host, and uninstall takes it back out', t => {
-    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-continuity-install-'));
-    t.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
-    const allConfigurationPaths = [
-        join(homeDirectory, '.claude', 'settings.json'),
-        join(homeDirectory, '.codex', 'hooks.json'),
-        join(homeDirectory, '.cursor', 'hooks.json'),
+test('a full install removes the retired pstack pointers and release store', t => {
+    const sandbox = pstackPluginSandbox(t);
+    const managedRoot = join(sandbox.homeDirectory, '.claude');
+    const agentsSkillsRoot = join(sandbox.homeDirectory, '.agents', 'skills');
+    const releaseSkillsRoot = join(managedRoot, 'pstack', 'releases', 'abc123', 'runtime', 'pstack', 'skills');
+    mkdirSync(join(releaseSkillsRoot, 'poteto-mode'), { recursive: true });
+    mkdirSync(join(managedRoot, 'skills'), { recursive: true });
+    mkdirSync(agentsSkillsRoot, { recursive: true });
+    const allPointerPaths = [
+        join(managedRoot, 'skills', 'pstack'),
+        join(agentsSkillsRoot, 'pstack'),
     ];
+    for (const pointerPath of allPointerPaths) {
+        symlinkSync(releaseSkillsRoot, pointerPath, 'dir');
+    }
 
-    runContinuityInstaller(homeDirectory, []);
+    const installerOutput = runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
 
-    for (const configurationPath of allConfigurationPaths) {
+    for (const pointerPath of allPointerPaths) {
         assert.equal(
-            continuityCommandCount(configurationPath) > 0,
-            true,
-            `the install registers the companion in ${configurationPath} without a second setup command`,
+            existsSync(pointerPath),
+            false,
+            `the install removes ${pointerPath}, which Claude Code would load as a second pstack plugin`,
         );
     }
+    assert.equal(existsSync(join(managedRoot, 'pstack')), false);
+    assert.match(installerOutput, /Pstack: retired release store removed/);
+});
+
+test('a full install clears a retired session-continuity registration from every host', t => {
+    const sandbox = pstackPluginSandbox(t);
+    const companionCommand = 'node "/stale/.agents/skills/session-continuity/continuity.mjs" hook claude';
+    const allConfigurationPaths = [
+        join(sandbox.homeDirectory, '.claude', 'settings.json'),
+        join(sandbox.homeDirectory, '.codex', 'hooks.json'),
+        join(sandbox.homeDirectory, '.cursor', 'hooks.json'),
+    ];
+    for (const configurationPath of allConfigurationPaths) {
+        mkdirSync(dirname(configurationPath), { recursive: true });
+        writeFileSync(configurationPath, JSON.stringify({
+            hooks: {
+                SessionStart: [{ hooks: [{ type: 'command', command: companionCommand }] }],
+            },
+        }, null, 2) + '\n');
+    }
 
-    runContinuityInstaller(homeDirectory, ['--uninstall']);
+    runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
 
     for (const configurationPath of allConfigurationPaths) {
         assert.equal(
             continuityCommandCount(configurationPath),
             0,
-            `uninstall leaves no registration in ${configurationPath} pointing at a removed script`,
+            `the install leaves no registration in ${configurationPath} pointing at a removed script`,
         );
     }
 });

package/bin/prune-retired-pstack-store.mjs

@@ -0,0 +1,83 @@
+import {
+    existsSync,
+    lstatSync,
+    readdirSync,
+    readlinkSync,
+    rmSync,
+    unlinkSync,
+} from 'node:fs';
+import { isAbsolute, join, resolve, sep } from 'node:path';
+
+export const RETIRED_PSTACK_STORE_DIRECTORY_NAME = 'pstack';
+
+/**
+ * Name the store directory the retired pstack installer kept its releases in.
+ *
+ * @param {string} managedRoot The managed Claude root.
+ * @returns {string} The retired store root.
+ */
+export function retiredPstackStoreRoot(managedRoot) {
+    return join(managedRoot, RETIRED_PSTACK_STORE_DIRECTORY_NAME);
+}
+
+function pointsIntoStore(entryPath, storeRoot) {
+    let entryStats;
+    try {
+        entryStats = lstatSync(entryPath);
+    } catch {
+        return false;
+    }
+    if (!entryStats.isSymbolicLink()) return false;
+    let linkTarget;
+    try {
+        linkTarget = readlinkSync(entryPath);
+    } catch {
+        return false;
+    }
+    const resolvedTarget = isAbsolute(linkTarget)
+        ? resolve(linkTarget)
+        : resolve(join(entryPath, '..', linkTarget));
+    return resolvedTarget.startsWith(resolve(storeRoot) + sep);
+}
+
+function removePointersUnder(skillsRoot, storeRoot) {
+    if (!skillsRoot || !existsSync(skillsRoot)) return [];
+    const removedPointerPaths = [];
+    for (const entryName of readdirSync(skillsRoot)) {
+        const entryPath = join(skillsRoot, entryName);
+        if (!pointsIntoStore(entryPath, storeRoot)) continue;
+        unlinkSync(entryPath);
+        removedPointerPaths.push(entryPath);
+    }
+    return removedPointerPaths;
+}
+
+/**
+ * Remove the retired pstack installation this package used to publish.
+ *
+ * The retired installer kept a release store under the managed root and
+ * published one symlink per skill into it. Claude Code loads the `pstack`
+ * pointer as a skills-directory plugin, so a pointer left behind collides with
+ * the `pstack@pstack-claude` plugin the marketplace now installs.
+ *
+ * Only a symlink whose target resolves inside the store is removed, so a
+ * directory a user keeps under a similar name stays in place. A pointer left
+ * dangling by a store someone already deleted is removed too.
+ *
+ * @param {object} roots An `InstallRootResolution`.
+ * @returns {{removedPointerPaths: string[], removedStorePath: string|null}} What this call removed.
+ */
+export function removeRetiredPstackInstallation(roots) {
+    const storeRoot = retiredPstackStoreRoot(roots.managedRoot);
+    const allSkillsRoots = [...new Set([
+        roots.skillsLookupDirectory,
+        roots.skillsInstallDirectory,
+    ])];
+    const removedPointerPaths = allSkillsRoots
+        .flatMap(skillsRoot => removePointersUnder(skillsRoot, storeRoot));
+    if (!existsSync(storeRoot)) {
+        return { removedPointerPaths, removedStorePath: null };
+    }
+    rmSync(storeRoot, { recursive: true, force: true });
+    return { removedPointerPaths, removedStorePath: storeRoot };
+}

package/bin/prune-retired-pstack-store.test.mjs

@@ -0,0 +1,105 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    existsSync,
+    lstatSync,
+    mkdirSync,
+    mkdtempSync,
+    rmSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    removeRetiredPstackInstallation,
+    retiredPstackStoreRoot,
+} from './prune-retired-pstack-store.mjs';
+
+function retiredInstallationFixture(t) {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-retired-pstack-'));
+    t.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
+    const managedRoot = join(homeDirectory, '.claude');
+    const agentsHome = join(homeDirectory, '.agents');
+    const releaseRoot = join(managedRoot, 'pstack', 'releases', 'abc123', 'runtime');
+    mkdirSync(join(releaseRoot, 'pstack', 'skills', 'poteto-mode'), { recursive: true });
+    mkdirSync(join(releaseRoot, 'cursor-team-kit', 'skills', 'deslop'), { recursive: true });
+    writeFileSync(join(managedRoot, 'pstack', 'installed.json'), '{}\n');
+    const managedSkillsRoot = join(managedRoot, 'skills');
+    const agentsSkillsRoot = join(agentsHome, 'skills');
+    mkdirSync(managedSkillsRoot, { recursive: true });
+    mkdirSync(agentsSkillsRoot, { recursive: true });
+    const pointers = [
+        [join(managedSkillsRoot, 'pstack'), join(releaseRoot, 'pstack', 'skills')],
+        [join(agentsSkillsRoot, 'pstack'), join(releaseRoot, 'pstack', 'skills')],
+        [
+            join(agentsSkillsRoot, 'cursor-team-kit-deslop'),
+            join(releaseRoot, 'cursor-team-kit', 'skills', 'deslop'),
+        ],
+    ];
+    for (const [pointerPath, targetPath] of pointers) {
+        symlinkSync(targetPath, pointerPath, 'dir');
+    }
+    return {
+        roots: { managedRoot, agentsHome, skillsLookupDirectory: managedSkillsRoot, skillsInstallDirectory: agentsSkillsRoot },
+        managedSkillsRoot,
+        agentsSkillsRoot,
+        pointerPaths: pointers.map(([pointerPath]) => pointerPath),
+    };
+}
+
+test('the store root sits under the managed root', () => {
+    assert.equal(
+        retiredPstackStoreRoot(join('/managed', '.claude')),
+        join('/managed', '.claude', 'pstack'),
+    );
+});
+
+test('every pointer into the retired store is removed along with the store', t => {
+    const fixture = retiredInstallationFixture(t);
+
+    const outcome = removeRetiredPstackInstallation(fixture.roots);
+
+    assert.deepEqual(outcome.removedPointerPaths.sort(), fixture.pointerPaths.sort());
+    assert.equal(outcome.removedStorePath, retiredPstackStoreRoot(fixture.roots.managedRoot));
+    for (const pointerPath of fixture.pointerPaths) {
+        assert.equal(existsSync(pointerPath), false);
+    }
+    assert.equal(existsSync(retiredPstackStoreRoot(fixture.roots.managedRoot)), false);
+});
+
+test('a skill that is not a pointer into the store stays in place', t => {
+    const fixture = retiredInstallationFixture(t);
+    const ownSkillDirectory = join(fixture.agentsSkillsRoot, 'pull-request');
+    mkdirSync(ownSkillDirectory, { recursive: true });
+    writeFileSync(join(ownSkillDirectory, 'SKILL.md'), '---\nname: pull-request\n---\n');
+    const unrelatedTarget = join(fixture.roots.managedRoot, 'elsewhere', 'pstack');
+    mkdirSync(unrelatedTarget, { recursive: true });
+    const unrelatedPointer = join(fixture.agentsSkillsRoot, 'pstack-of-my-own');
+    symlinkSync(unrelatedTarget, unrelatedPointer, 'dir');
+
+    removeRetiredPstackInstallation(fixture.roots);
+
+    assert.equal(existsSync(join(ownSkillDirectory, 'SKILL.md')), true);
+    assert.equal(lstatSync(unrelatedPointer).isSymbolicLink(), true);
+});
+
+test('a home with no retired installation reports nothing removed', t => {
+    const fixture = retiredInstallationFixture(t);
+    removeRetiredPstackInstallation(fixture.roots);
+
+    const secondOutcome = removeRetiredPstackInstallation(fixture.roots);
+
+    assert.deepEqual(secondOutcome.removedPointerPaths, []);
+    assert.equal(secondOutcome.removedStorePath, null);
+});
+
+test('a dangling pointer into the store is removed after the store is gone', t => {
+    const fixture = retiredInstallationFixture(t);
+    rmSync(retiredPstackStoreRoot(fixture.roots.managedRoot), { recursive: true, force: true });
+
+    const outcome = removeRetiredPstackInstallation(fixture.roots);
+
+    assert.deepEqual(outcome.removedPointerPaths.sort(), fixture.pointerPaths.sort());
+    assert.equal(outcome.removedStorePath, null);
+});

package/bin/prune-session-continuity.mjs

@@ -0,0 +1,57 @@
+import { dirname, join } from 'node:path';
+
+export const CONTINUITY_SCRIPT_MARKER = '/session-continuity/continuity.mjs';
+
+/**
+ * True when a hook command calls the retired session-continuity companion.
+ *
+ * @param {unknown} command The `command` field of one host hook entry.
+ * @returns {boolean} True when this entry calls the retired companion.
+ */
+export function isContinuityHookCommand(command) {
+    return typeof command === 'string' && command.includes(CONTINUITY_SCRIPT_MARKER);
+}
+
+/**
+ * Locate the hook configuration file each host keeps its registrations in.
+ *
+ * @param {object} roots An `InstallRootResolution`.
+ * @returns {Record<string, string>} One configuration path per host.
+ */
+export function continuityHostConfigurationPaths(roots) {
+    return {
+        claude: join(roots.managedRoot, 'settings.json'),
+        codex: join(dirname(roots.codexRulesInstallDirectory), 'hooks.json'),
+        cursor: join(roots.cursorInstallDirectory, 'hooks.json'),
+    };
+}
+
+/**
+ * Strip every retired session-continuity registration from one host
+ * configuration, in place, and drop an event left with no entries.
+ *
+ * An earlier claude-dev-env registered this companion in each host. The pstack
+ * plugin now carries the SessionStart context the companion supplied, so a
+ * registration left behind points every session at a deleted script.
+ *
+ * @param {object} configuration A parsed host hook configuration.
+ * @returns {number} How many registrations this call removed.
+ */
+export function removeContinuityHooks(configuration) {
+    let removedCount = 0;
+    for (const [event, entries] of Object.entries(configuration.hooks || {})) {
+        const kept = entries.flatMap(entry => {
+            if (!entry.hooks) {
+                if (!isContinuityHookCommand(entry.command)) return [entry];
+                removedCount += 1;
+                return [];
+            }
+            const hooks = entry.hooks.filter(hook => !isContinuityHookCommand(hook.command));
+            removedCount += entry.hooks.length - hooks.length;
+            return hooks.length ? [{ ...entry, hooks }] : [];
+        });
+        if (kept.length) configuration.hooks[event] = kept;
+        else delete configuration.hooks[event];
+    }
+    return removedCount;
+}

package/bin/prune-session-continuity.test.mjs

@@ -0,0 +1,70 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { join } from 'node:path';
+import {
+    continuityHostConfigurationPaths,
+    isContinuityHookCommand,
+    removeContinuityHooks,
+} from './prune-session-continuity.mjs';
+
+const ROOTS = {
+    managedRoot: join('/managed', '.claude'),
+    codexRulesInstallDirectory: join('/managed', '.codex', 'rules'),
+    cursorInstallDirectory: join('/managed', '.cursor'),
+};
+
+const COMPANION_COMMAND = 'node "/managed/.agents/skills/session-continuity/continuity.mjs" hook claude';
+
+test('a companion command is recognized and another hook command is not', () => {
+    assert.equal(isContinuityHookCommand(COMPANION_COMMAND), true);
+    assert.equal(isContinuityHookCommand('node "/managed/.agents/hooks/routing/other.mjs"'), false);
+    assert.equal(isContinuityHookCommand(undefined), false);
+});
+
+test('each host names the configuration file that holds its registrations', () => {
+    assert.deepEqual(continuityHostConfigurationPaths(ROOTS), {
+        claude: join('/managed', '.claude', 'settings.json'),
+        codex: join('/managed', '.codex', 'hooks.json'),
+        cursor: join('/managed', '.cursor', 'hooks.json'),
+    });
+});
+
+test('a grouped registration is removed and the sibling hook stays', () => {
+    const configuration = {
+        hooks: {
+            SessionStart: [{
+                matcher: 'startup',
+                hooks: [
+                    { type: 'command', command: COMPANION_COMMAND },
+                    { type: 'command', command: 'node "/managed/.agents/hooks/keep.mjs"' },
+                ],
+            }],
+        },
+    };
+    assert.equal(removeContinuityHooks(configuration), 1);
+    assert.deepEqual(configuration.hooks.SessionStart[0].hooks, [
+        { type: 'command', command: 'node "/managed/.agents/hooks/keep.mjs"' },
+    ]);
+});
+
+test('an event left with no entries is dropped rather than left empty', () => {
+    const configuration = {
+        hooks: {
+            UserPromptExpansion: [{ hooks: [{ type: 'command', command: COMPANION_COMMAND }] }],
+        },
+    };
+    assert.equal(removeContinuityHooks(configuration), 1);
+    assert.deepEqual(configuration.hooks, {});
+});
+
+test("Cursor's flat entry shape is removed the same way", () => {
+    const configuration = { version: 1, hooks: { sessionStart: [{ command: COMPANION_COMMAND }] } };
+    assert.equal(removeContinuityHooks(configuration), 1);
+    assert.deepEqual(configuration.hooks, {});
+});
+
+test('a configuration holding no registration is left untouched', () => {
+    const configuration = { hooks: { SessionStart: [{ hooks: [{ command: 'node "/keep.mjs"' }] }] } };
+    assert.equal(removeContinuityHooks(configuration), 0);
+    assert.deepEqual(configuration.hooks.SessionStart, [{ hooks: [{ command: 'node "/keep.mjs"' }] }]);
+});