claude-dev-env 7.7.1 → 8.0.0

package/bin/install.mjs

@@ -35,24 +35,20 @@ import {
     CODEX_RULES_PACKAGE_DIRECTORY_NAME,
     CURSOR_SYNC_SCRIPT_FILE_NAME,
     CURSOR_RULES_DIRECTORY_NAME,
-    PSTACK_MODEL_RULE_FILE_NAME,
     SUBAGENT_MODEL_POLICY_FILE_NAME,
-    PSTACK_SEEDED_MODEL_PREFERENCES_FILE_NAMES,
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
     CODEX_NATIVE_ROUTING_MATCHER,
 } from './install-constants.mjs';
 import {
-    PSTACK_PLUGIN_DIRECTORY_NAME,
-    PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH,
-    refreshPstackPluginManifest,
-} from '../scripts/refresh_pstack_plugin_skills.mjs';
-import { installPstack } from './pstack.mjs';
+    installPstackPlugin,
+    shouldInstallPstackPlugin,
+} from './install-pstack-plugin.mjs';
 import {
-    configureContinuityHosts,
     continuityHostConfigurationPaths,
     removeContinuityHooks,
-} from './install-session-continuity.mjs';
+} from './prune-session-continuity.mjs';
+import { removeRetiredPstackInstallation } from './prune-retired-pstack-store.mjs';
 import {
     resolveInstallRoot,
     parseExplicitTargetFromArgv,
@@ -432,90 +428,22 @@ export function runCursorRuleSync(pythonCommand, scriptPath, claudeRoot, cursorR
     );
 }
 
-const PSTACK_RELEASE_OPT_OUT_FLAG = '--no-pstack';
-const PSTACK_RELEASE_OPT_OUT_VARIABLE = 'CDE_INSTALL_PSTACK';
-const PSTACK_RELEASE_OPT_OUT_VALUE = '0';
-
-/**
- * Decide whether a full install also installs the pstack release.
- *
- * The step reaches the network for the pinned upstream commit. `--no-pstack`
- * on the command line, or `CDE_INSTALL_PSTACK=0` in the environment, turns it
- * off for an air-gapped or offline run.
- *
- * @param {string[]} [argumentList] The command-line arguments after the script.
- * @param {Record<string, string|undefined>} [environment] The process environment.
- * @returns {boolean} True when this run installs the pstack release.
- */
-export function shouldInstallPstackRelease(
-    argumentList = process.argv.slice(2),
-    environment = process.env,
-) {
-    if (argumentList.includes(PSTACK_RELEASE_OPT_OUT_FLAG)) return false;
-    return environment[PSTACK_RELEASE_OPT_OUT_VARIABLE] !== PSTACK_RELEASE_OPT_OUT_VALUE;
-}
-
-/**
- * Install the pstack release into a managed root without failing the run.
- *
- * The pstack store keeps its own state and its own skill pointers, so this
- * step reports its outcome rather than adding paths to the install manifest.
- * A network failure returns a warning so the rules, hooks, and skills this
- * run already wrote still reach their durable places.
- *
- * @param {object} [options] Options for `installPstack`, including `root`.
- * @param {object} [dependencies] Seams `installPstack` accepts, such as `fetchSource`.
- * @returns {{status: string, release: string|null, warning: string|null}} The outcome.
- */
-export function installPstackRelease(options = {}, dependencies = {}) {
-    try {
-        const installation = installPstack(options, dependencies);
-        return {
-            status: installation.status,
-            release: installation.release,
-            warning: installation.warning ?? null,
-        };
-    } catch (installError) {
-        return { status: 'failed', release: null, warning: installError.message };
-    }
-}
-
 /**
- * Refresh the pstack plugin manifest Claude Code reads, when this home has one.
+ * Install the pstack plugin from its marketplace into the hosts this run serves.
  *
- * Claude Code loads a skills-directory folder as a plugin when it holds
- * `.claude-plugin/plugin.json`, and namespaces its skills as `pstack:how`.
- * Without the manifest, a folder of skill folders loads nothing.
+ * The plugin carries its own skills, agents, and SessionStart hook, so the step
+ * reports its outcome rather than adding paths to the install manifest. A host
+ * without its command-line tool is skipped and a failing command is reported,
+ * so the rules, hooks, and skills this run already wrote still reach their
+ * durable places.
  *
- * @param {string} [skillsRoot] The skills root to read. Defaults to the root
- *   this run installs into.
- * @returns {string|null} The manifest path when this run wrote it, else null.
+ * @returns {{status: string, hosts: object[], warning: string|null}} The outcome.
  */
-export function refreshInstalledPstackPluginManifest(
-    skillsRoot = join(CLAUDE_HOME, MANAGED_SKILLS_DIRECTORY_NAME),
-) {
-    const pluginRoot = join(skillsRoot, PSTACK_PLUGIN_DIRECTORY_NAME);
-    const outcome = refreshPstackPluginManifest(pluginRoot);
-    if (!outcome.didWrite) return null;
-    return join(pluginRoot, PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH);
-}
-
-function seedPstackPreferences(preferenceFileName) {
-    const preferenceDirectory = join(AGENTS_HOME, CURSOR_RULES_DIRECTORY_NAME);
-    const preferencePath = join(preferenceDirectory, preferenceFileName);
-    const preferenceSource = join(PACKAGE_ROOT, 'bin', preferenceFileName);
-    mkdirSync(preferenceDirectory, { recursive: true });
-    try {
-        copyFileSync(
-            preferenceSource,
-            preferencePath,
-            filesystemConstants.COPYFILE_EXCL,
-        );
-        return preferencePath;
-    } catch (copyError) {
-        if (copyError.code === 'EEXIST') return null;
-        throw copyError;
-    }
+export function installPstackPluginForHosts() {
+    return installPstackPlugin({
+        claudeRoot: CLAUDE_HOME,
+        codexHome: INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
+    });
 }
 
 function seedSubagentModelPolicy() {
@@ -533,58 +461,30 @@ function seedSubagentModelPolicy() {
 }
 
 /**
- * Registers the session-continuity companion in each host configuration this
- * install root resolves. Without this step the companion ships to the agents
- * home but no host ever calls it, so Poteto Mode only activates when someone
- * remembers a second setup command.
+ * Removes the retired session-continuity registrations from the named hosts.
  *
- * A competing profile's registration, or an unwritable host configuration, is
- * reported and leaves the rest of the install intact.
- *
- * @returns {string[]} The host configuration paths this run registered.
- */
-function registerSessionContinuityHooks() {
-    const configurationPaths = continuityHostConfigurationPaths(INSTALL_ROOT_RESOLUTION);
-    const hosts = Object.keys(configurationPaths)
-        .filter(host => existsSync(dirname(configurationPaths[host])));
-    if (hosts.length === 0) return [];
-    try {
-        const results = configureContinuityHosts(INSTALL_ROOT_RESOLUTION, hosts);
-        for (const result of results) {
-            const state = result.changed ? 'registered' : 'already registered';
-            console.log(`  Session continuity: ${state} in ${result.path}`);
-        }
-        return results.map(result => result.path);
-    } catch (registrationError) {
-        console.warn(
-            `  Warning: session-continuity hooks were not registered (${registrationError.message}) — `
-            + 'run bin/install-session-continuity.mjs once the cause is resolved.',
-        );
-        return [];
-    }
-}
-
-/**
- * Removes the companion's registrations from the Codex and Cursor hook files
- * during an uninstall. The Claude settings.json copy is pruned inside the
- * settings block, which owns that file's single write.
- *
- * Each host this installer registered is a host it has to clean, or the host
- * keeps calling a script the uninstall deleted.
+ * An earlier claude-dev-env registered the companion in Claude, Codex, and
+ * Cursor. The pstack plugin now carries the SessionStart context the companion
+ * supplied, so a registration left behind points every session at a deleted
+ * script. Every install clears all three hosts; an uninstall passes the two the
+ * settings block does not already own.
  *
+ * @param {string[]} [hosts] The hosts to clear. Defaults to all three.
  * @returns {string[]} The host configuration paths this run changed.
  */
-function removeSessionContinuityHooksFromOtherHosts() {
+function removeRetiredSessionContinuityHooks(hosts = ['claude', 'codex', 'cursor']) {
     const configurationPaths = continuityHostConfigurationPaths(INSTALL_ROOT_RESOLUTION);
     const changedPaths = [];
-    for (const host of ['codex', 'cursor']) {
+    for (const host of hosts) {
         const configurationPath = configurationPaths[host];
         if (!existsSync(configurationPath)) continue;
-        const configuration = JSON.parse(readFileSync(configurationPath, 'utf8'));
+        const configurationText = readFileSync(configurationPath, 'utf8');
+        const configuration = JSON.parse(configurationText);
         if (removeContinuityHooks(configuration) === 0) continue;
-        writeFileSync(configurationPath, JSON.stringify(configuration, null, 2) + '\n');
+        const indent = hostConfigurationIndent(configurationText);
+        writeFileSync(configurationPath, JSON.stringify(configuration, null, indent) + '\n');
         changedPaths.push(configurationPath);
-        console.log(`  Session continuity: hook registrations removed from ${configurationPath}`);
+        console.log(`  Session continuity: retired hook registrations removed from ${configurationPath}`);
     }
     return changedPaths;
 }
@@ -2811,20 +2711,6 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         allInstalledFiles.push(...generatedCursorPaths);
         summary.cursorRules = { created: generatedCursorPaths.length, updated: 0, paths: generatedCursorPaths };
         syncWrittenPaths(allInstalledFiles);
-        const pstackRuleSource = join(INSTALL_ROOT_RESOLUTION.cursorRulesInstallDirectory, PSTACK_MODEL_RULE_FILE_NAME);
-        const sharedRuleDirectory = join(AGENTS_HOME, CURSOR_RULES_DIRECTORY_NAME);
-        const sharedRulePath = join(sharedRuleDirectory, PSTACK_MODEL_RULE_FILE_NAME);
-        mkdirSync(sharedRuleDirectory, { recursive: true });
-        copyFileSync(pstackRuleSource, sharedRulePath);
-        allInstalledFiles.push(sharedRulePath);
-        syncWrittenPaths(allInstalledFiles);
-        for (const eachPreferenceFileName of PSTACK_SEEDED_MODEL_PREFERENCES_FILE_NAMES) {
-            const seededPreferencePath = seedPstackPreferences(eachPreferenceFileName);
-            if (seededPreferencePath) {
-                allInstalledFiles.push(seededPreferencePath);
-                allUserOwnedPreferencePaths.add(seededPreferencePath);
-            }
-        }
         const seededPolicyPath = seedSubagentModelPolicy();
         if (seededPolicyPath) {
             allInstalledFiles.push(seededPolicyPath);
@@ -2860,16 +2746,28 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     }
     summary.skills = { created: skillsCreated, updated: skillsUpdated, pruned: 0, paths: skillPaths };
     allInstalledFiles.push(...skillPaths);
-    if (!selectedGroups && shouldInstallPstackRelease()) {
-        const pstackRelease = installPstackRelease({ root: CLAUDE_HOME });
-        summary.pstackRelease = pstackRelease;
-        console.log(pstackRelease.warning
-            ? `  Pstack: ${pstackRelease.status} \u2014 ${pstackRelease.warning}`
-            : `  Pstack: ${pstackRelease.status} (${pstackRelease.release})`);
-    }
-    const pstackManifestPath = refreshInstalledPstackPluginManifest();
-    if (pstackManifestPath) allInstalledFiles.push(pstackManifestPath);
-    summary.pstackPlugin = { manifestPath: pstackManifestPath };
+    if (!selectedGroups) {
+        summary.retiredSessionContinuity = {
+            changedPaths: removeRetiredSessionContinuityHooks(),
+        };
+        const retiredPstack = removeRetiredPstackInstallation(INSTALL_ROOT_RESOLUTION);
+        summary.retiredPstackStore = retiredPstack;
+        for (const pointerPath of retiredPstack.removedPointerPaths) {
+            console.log(`  Pstack: retired pointer removed from ${pointerPath}`);
+        }
+        if (retiredPstack.removedStorePath) {
+            console.log(`  Pstack: retired release store removed from ${retiredPstack.removedStorePath}`);
+        }
+    }
+    if (!selectedGroups && shouldInstallPstackPlugin()) {
+        const pstackPlugin = installPstackPluginForHosts();
+        summary.pstackPlugin = pstackPlugin;
+        for (const eachHost of pstackPlugin.hosts) {
+            console.log(eachHost.warning
+                ? `  Pstack (${eachHost.host}): ${eachHost.status} \u2014 ${eachHost.warning}`
+                : `  Pstack (${eachHost.host}): ${eachHost.status}`);
+        }
+    }
     syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
     throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
     throwIfFault(FAULT_PHASES.BEFORE_DURABLE_PROMOTION);
@@ -2999,9 +2897,6 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         console.log(`  \u2713 ${relative(CLAUDE_HOME, agentsHubDest)} (canonical guidance)`);
     }
     const isFullInstall = !selectedGroups;
-    if (isFullInstall && shouldInstallAnyHooks) {
-        summary.sessionContinuity = { configuredPaths: registerSessionContinuityHooks() };
-    }
     const didPruneRun = isFullInstall && UNRESOLVED_DEPENDENCY_NAMES.length === 0;
     let failedPrunePaths = [];
     let stalePrunedTotal = 0;
@@ -3268,7 +3163,7 @@ function executeUninstallPlan(plan, helpers = {}) {
     if (!codexRoutingHookExists()) {
         pruneManagedHooksFromHostConfiguration(CODEX_HOOKS_CONFIGURATION_PATH, 2);
     }
-    removeSessionContinuityHooksFromOtherHosts();
+    removeRetiredSessionContinuityHooks(['codex', 'cursor']);
     throwIfFault(FAULT_PHASES.AFTER_SETTINGS_WRITE);
 
     unsetGlobalGitHooksPathIfOurs();
@@ -3394,7 +3289,7 @@ Usage:
   npx ${PACKAGE_NAME} --target DIR Install into DIR instead of ~/.claude (overrides CLAUDE_CONFIG_DIR)
   npx ${PACKAGE_NAME} --profile ID Install into one named profile root (under the profiles root)
   npx ${PACKAGE_NAME} --profiles A,B  Install into each selected profile (one ownership manifest per target)
-  npx ${PACKAGE_NAME} --no-pstack  Full install without the pinned pstack release (also CDE_INSTALL_PSTACK=0)
+  npx ${PACKAGE_NAME} --no-pstack  Full install without the pstack plugin (also CDE_INSTALL_PSTACK=0)
   npx ${PACKAGE_NAME} --uninstall  Remove installed files from the selected root
   npx ${PACKAGE_NAME} --help       Show this help
 

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`,
         );
     }
 });