claude-dev-env 7.7.0 → 8.0.0

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"' }] }]);
+});

package/bin/resolve-install-root.mjs

@@ -60,6 +60,7 @@ export const MANIFEST_FILE_NAME = '.claude-dev-env-manifest.json';
  *   hooksLookupDirectory: string,
  *   scriptsLookupDirectory: string,
  *   codexHooksInstallDirectory: string,
+ *   codexHomeDirectory: string,
  * }} InstallRootResolution
  */
 
@@ -179,6 +180,7 @@ export function resolveInstallRoot(options = {}) {
         hooksLookupDirectory,
         scriptsLookupDirectory,
         codexHooksInstallDirectory,
+        codexHomeDirectory,
     };
 }
 

package/bin/resolve-install-root.test.mjs

@@ -0,0 +1,69 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    resolveInstallRoot,
+    CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE,
+    DEFAULT_CLAUDE_DIRECTORY_NAME,
+} from './resolve-install-root.mjs';
+import {
+    CODEX_HOME_ENVIRONMENT_VARIABLE,
+    CODEX_HOOKS_DIRECTORY_NAME,
+    CODEX_RULES_DIRECTORY_NAME,
+    DEFAULT_CODEX_DIRECTORY_NAME,
+    MANAGED_SKILLS_DIRECTORY_NAME,
+    PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+} from './install-constants.mjs';
+
+const HOME_DIRECTORY = join(tmpdir(), 'cdev-resolve-roots-home');
+
+function resolveFrom(environment, explicitTarget = null) {
+    return resolveInstallRoot({ homeDirectory: HOME_DIRECTORY, environment, explicitTarget });
+}
+
+test('the managed root falls back to the default Claude directory under the home', () => {
+    const resolution = resolveFrom({});
+    assert.equal(resolution.managedRoot, join(HOME_DIRECTORY, DEFAULT_CLAUDE_DIRECTORY_NAME));
+    assert.equal(resolution.source, 'default-home');
+});
+
+test('CLAUDE_CONFIG_DIR names the managed root and an explicit target outranks it', () => {
+    const configuredRoot = join(tmpdir(), 'cdev-configured');
+    const explicitRoot = join(tmpdir(), 'cdev-explicit');
+    const configured = resolveFrom({ [CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE]: configuredRoot });
+    assert.equal(configured.managedRoot, configuredRoot);
+    assert.equal(configured.source, 'claude-config-dir');
+
+    const explicit = resolveFrom(
+        { [CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE]: configuredRoot },
+        explicitRoot,
+    );
+    assert.equal(explicit.managedRoot, explicitRoot);
+    assert.equal(explicit.source, 'explicit-target');
+});
+
+test('the Codex home is the directory holding the rules and hooks destinations', () => {
+    const resolution = resolveFrom({});
+    const codexHome = join(HOME_DIRECTORY, DEFAULT_CODEX_DIRECTORY_NAME);
+    assert.equal(resolution.codexHomeDirectory, codexHome);
+    assert.equal(resolution.codexRulesInstallDirectory, join(codexHome, CODEX_RULES_DIRECTORY_NAME));
+    assert.equal(resolution.codexHooksInstallDirectory, join(codexHome, CODEX_HOOKS_DIRECTORY_NAME));
+});
+
+test('CODEX_HOME relocates the Codex home the pstack plugin step installs into', () => {
+    const relocatedHome = join(tmpdir(), 'cdev-relocated-codex');
+    const resolution = resolveFrom({ [CODEX_HOME_ENVIRONMENT_VARIABLE]: relocatedHome });
+    assert.equal(resolution.codexHomeDirectory, relocatedHome);
+    assert.equal(resolution.codexRulesInstallDirectory, join(relocatedHome, CODEX_RULES_DIRECTORY_NAME));
+});
+
+test('a managed root named .claude pairs with the sibling agents home', () => {
+    const resolution = resolveFrom({});
+    assert.equal(resolution.agentsHome, join(HOME_DIRECTORY, PACKAGE_AGENTS_HOME_DIRECTORY_NAME));
+    assert.equal(resolution.skillsInstallDirectory, join(HOME_DIRECTORY, PACKAGE_AGENTS_HOME_DIRECTORY_NAME, MANAGED_SKILLS_DIRECTORY_NAME));
+    assert.equal(
+        resolution.skillsLookupDirectory,
+        join(HOME_DIRECTORY, DEFAULT_CLAUDE_DIRECTORY_NAME, MANAGED_SKILLS_DIRECTORY_NAME),
+    );
+});

package/bin/subagent-model-policy.test.mjs

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { cpSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -35,6 +35,7 @@ const replacements = [
     [['Luna', 'low'], ['gpt-5.6-luna', 'high']],
     [['Luna', 'medium'], ['gpt-5.6-luna', 'high']],
     [['Sol', 'low'], ['gpt-5.6-luna', 'xhigh']],
+    [['Sol', 'medium'], ['gpt-5.6-luna', 'max']],
     [['Terra', 'low'], ['gpt-5.6-luna', 'xhigh']],
     [['Terra', 'medium'], ['gpt-5.6-luna', 'xhigh']],
     [['Terra', 'high'], ['gpt-5.6-luna', 'xhigh']],
@@ -59,7 +60,6 @@ test('every approved pair returns its literal native pair', () => {
         [['Luna', 'high'], ['gpt-5.6-luna', 'high']],
         [['Luna', 'xhigh'], ['gpt-5.6-luna', 'xhigh']],
         [['Luna', 'max'], ['gpt-5.6-luna', 'max']],
-        [['Sol', 'medium'], ['gpt-5.6-sol', 'medium']],
         [['Astra', 'low'], ['gpt-6-astra', 'low']],
         [['Astra', 'medium'], ['gpt-6-astra', 'medium']],
     ];
@@ -67,6 +67,9 @@ test('every approved pair returns its literal native pair', () => {
         const result = route({ model, reasoning_effort: effort });
         assert.ok(['pass', 'remapped'].includes(result.status));
         assert.deepEqual(result.selected, { model: expectedModel, effort: expectedEffort });
+        const nativeRoute = route({ model: expectedModel, reasoning_effort: expectedEffort });
+        assert.equal(nativeRoute.status, 'pass');
+        assert.deepEqual(nativeRoute.selected, { model: expectedModel, effort: expectedEffort });
     }
     const advisor = advisorRoute({
         model: 'Astra',
@@ -77,12 +80,12 @@ test('every approved pair returns its literal native pair', () => {
     assert.deepEqual(advisor.selected, { model: 'gpt-6-astra', effort: 'high' });
 });
 
-test('selector exclusions leave direct Sol Medium routing valid', () => {
+test('selector exclusions keep Sol Medium out while direct routing remaps', () => {
     const policy = loadSubagentModelPolicy();
     assert.equal(policy.selectorExclusions.has('sol/medium'), true);
     const result = route({ model: 'Sol', reasoning_effort: 'medium' });
-    assert.ok(['pass', 'remapped'].includes(result.status));
-    assert.deepEqual(result.selected, { model: 'gpt-5.6-sol', effort: 'medium' });
+    assert.equal(result.status, 'remapped');
+    assert.deepEqual(result.selected, { model: 'gpt-5.6-luna', effort: 'max' });
 
     const rawPolicy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
     rawPolicy.selectorExclusions = [{ model: 'missing', effort: 'medium' }];
@@ -174,6 +177,25 @@ test('the advisor bridge blocks malformed input', () => {
     );
 });
 
+test('the advisor bridge routes Sol Medium to Luna Max', () => {
+    const bridgePath = join(PACKAGE_ROOT, 'scripts', 'resolve_advisor_model_route.mjs');
+    const bridgeExecution = spawnSync(
+        process.execPath,
+        [bridgePath],
+        {
+            encoding: 'utf8',
+            input: JSON.stringify({ model: 'Sol', reasoning_effort: 'medium' }),
+        },
+    );
+    assert.equal(bridgeExecution.status, 0);
+    assert.equal(bridgeExecution.stderr, '');
+    const advisorDecision = JSON.parse(bridgeExecution.stdout);
+    assert.equal(advisorDecision.status, 'remapped');
+    assert.equal(advisorDecision.role, 'advisor');
+    assert.equal(advisorDecision.diagnostic, null);
+    assert.deepEqual(advisorDecision.selected, { model: 'gpt-5.6-luna', effort: 'max' });
+});
+
 test('missing worker settings preserve parent inheritance', () => {
     const input = { message: 'keep', agent_type: 'worker' };
     const result = routeSubagentToolInput(input);
@@ -181,6 +203,15 @@ test('missing worker settings preserve parent inheritance', () => {
     assert.strictEqual(result.updatedInput, input);
 });
 
+test('Sol without an effort stays blocked after its only approved pair is removed', () => {
+    const result = route(
+        { model: 'Sol' },
+        { allowMissingEffort: true },
+    );
+    assert.equal(result.status, 'blocked');
+    assert.equal(result.diagnostic, 'effort is required for this model');
+});
+
 test('unknown input holds with a short diagnostic', () => {
     assert.match(route({ model: 'Unknown', reasoning_effort: 'medium' }).diagnostic, /model is unknown/);
     assert.match(route({ model: 'Terra', reasoning_effort: 'future' }).diagnostic, /effort is unknown/);
@@ -201,16 +232,16 @@ test('native values with case or whitespace differences are canonicalized', () =
     });
     assert.equal(result.status, 'remapped');
     assert.deepEqual(result.updatedInput, {
-        model: 'gpt-5.6-sol',
-        reasoning_effort: 'medium',
+        model: 'gpt-5.6-luna',
+        reasoning_effort: 'max',
         message: 'keep',
     });
 });
 
 test('unavailable replacements hold the spawn', () => {
     const result = route(
-        { model: 'Terra', reasoning_effort: 'medium' },
-        { availableModelIds: ['gpt-5.6-terra'] },
+        { model: 'Sol', reasoning_effort: 'medium' },
+        { availableModelIds: ['gpt-5.6-sol'] },
     );
     assert.equal(result.status, 'blocked');
     assert.match(result.diagnostic, /replacement model is unavailable/);
@@ -246,7 +277,7 @@ test('the tool route copies every non-routing field', () => {
 
 test('a second route pass is idempotent', () => {
     const first = routeSubagentToolInput(
-        { model: 'Terra', reasoning_effort: 'medium', message: 'keep' },
+        { model: 'Sol', reasoning_effort: 'medium', message: 'keep' },
         {},
     );
     const second = routeSubagentToolInput(first.updatedInput);
@@ -261,17 +292,22 @@ test('a temporary policy copy changes the next route without source edits', () =
         const temporaryPolicy = join(temporaryRoot, 'policy.json');
         const sourceText = readFileSync(POLICY_SOURCE, 'utf8');
         const policy = JSON.parse(sourceText);
+        writeFileSync(temporaryPolicy, sourceText);
+        assert.deepEqual(route(
+            { model: 'Sol', reasoning_effort: 'medium' },
+            { policyPath: temporaryPolicy },
+        ).selected, { model: 'gpt-5.6-luna', effort: 'max' });
         policy.replacements = policy.replacements.map(replacement => (
-            replacement.requested.model === 'terra' && replacement.requested.effort === 'medium'
-                ? { ...replacement, selected: { model: 'luna', effort: 'max' } }
+            replacement.requested.model === 'sol' && replacement.requested.effort === 'medium'
+                ? { ...replacement, selected: { model: 'luna', effort: 'xhigh' } }
                 : replacement
         ));
         writeFileSync(temporaryPolicy, JSON.stringify(policy));
-        const result = route(
-            { model: 'Terra', reasoning_effort: 'medium' },
+        const updatedRoute = route(
+            { model: 'Sol', reasoning_effort: 'medium' },
             { policyPath: temporaryPolicy },
         );
-        assert.deepEqual(result.selected, { model: 'gpt-5.6-luna', effort: 'max' });
+        assert.deepEqual(updatedRoute.selected, { model: 'gpt-5.6-luna', effort: 'xhigh' });
         assert.equal(readFileSync(POLICY_SOURCE, 'utf8'), sourceText);
     } finally {
         rmSync(temporaryRoot, { recursive: true, force: true });
@@ -347,10 +383,11 @@ test('model names cannot collide after normalization', () => {
 
 test('combined role routes must end at an approved terminal pair', () => {
     const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
-    policy.replacements.push({
-        requested: { model: 'sol', effort: 'medium' },
-        selected: { model: 'astra', effort: 'low' },
-    });
+    const solMediumReplacement = policy.replacements.find(replacement => (
+        replacement.requested.model === 'sol'
+        && replacement.requested.effort === 'medium'
+    ));
+    solMediumReplacement.selected = { model: 'astra', effort: 'low' };
     policy.roleReplacements.push({
         role: 'worker',
         requested: { model: 'astra', effort: 'low' },

package/docs/CODE_RULES.md

@@ -31,7 +31,7 @@ Production and tests follow one rule. Changed directive, TODO, FIXME, HACK, XXX,
 
 no new comments · imports at top · logging format args (`log_*("...", arg)`) · no `%s`/`%d` printf tokens in a `str.format`-logger message (`log_*` imported from `automation_logging`; `str.format` drops the args — use `{}`) · no magic values in production bodies (0, 1, -1 exempt) · UPPER_SNAKE constants only in `config/` (exempt: `config/*`; `/migrations/`; Workflow registries: path contains any of these substrings — `/workflow/`, `_tab.py`, `/states.py`, or `/modules.py`, each matching independently as a substring, so `pkg/states.py` qualifies while a top-level `states.py` follows the standard `config/` rule; test files — path or filename matches `test_`, `_test.`, `.spec.`, `conftest`, or `/tests/`) · no hardcoded user home paths · guarded `sys.path.insert` · banned identifiers (`ctx`, `cfg`, `msg`, `btn`, `idx`, `cnt`, `tmp`, `elem`, `val`) · banned function prefixes (`handle_`, `process_`, `manage_`, `do_`) · no type escape hatches (`Any` import, `cast()`, inline `Any`, a parameter typed bare `object` whose body reads `param.attribute`) outside boundary files · no bare/broad `except` · no `Any` in signatures or class attributes · no stub bodies (`pass`/`...`/`raise NotImplementedError`) outside abstract/Protocol · TypedDict `_encode_*`/`_decode_*` companions in the same module · no test-mode branching in production (use dependency injection) · no thin wrapper modules · Google-style docstrings on public functions with `Args:` matching the signature · boolean names prefixed `is_`/`has_`/`should_`/`can_`/`was_`/`did_` (assignments AND bool-typed parameters) · must-check returns (`find_and_click`, `write_outcome`) assigned and checked · known pytest fixture parameters in test files annotated with their single documented type (`tmp_path: Path`, `monkeypatch: pytest.MonkeyPatch`, `capsys`, `caplog`, `request`, …) · known pytest fixture parameters a test function declares but never references (drop the unused parameter — pytest still pays its setup cost) · JavaScript/TypeScript boolean declarations (`const`/`let`/`var` bound to a boolean literal or negation) and `@param {boolean}` JSDoc names prefixed `is`/`has`/`should`/`can`/`was`/`did` (camelCase forms) · banned identifiers as `.mjs`/`.js` declaration names (`result`, `data`, `ctx`, `msg`, …), scoped to changed lines · in test files, banned identifiers fire on changed lines, and pytest-collectable `test_*` functions need a return annotation · unused module-level imports and unsorted import blocks are ruff's job (F401, isort I001), not this hook's · a `hooks/blocking/` command classifier anchors its multi-word command regex to the command start (`^`/`\A`) or tokenizes the first word (`shlex.split`), never matching a command as a bare substring
 
-Test files follow the comment policy above; other test-specific exemptions are listed here. The one annotation the test-file exemption does NOT cover is a known pytest builtin fixture parameter: `tmp_path`, `monkeypatch`, `capsys`, `capfd`, `caplog`, `request`, and `tmp_path_factory` each have a single documented injected type, so the gate requires that annotation (`tmp_path: Path`) even inside a test file. The same set of fixtures is also subject to a use check: a pytest-collected test function that declares one of these parameters and never references it in its body fails the gate, because pytest materializes the fixture's setup (the temp directory, the monkeypatch context, the output capture) on every run whether or not the body reads the value — drop the unused parameter. A parameter counts as referenced when its name is read, augmented-assigned, or deleted anywhere in the body, including inside a nested function or comprehension. Only pytest-collectable functions are inspected — those at module top level or defined directly in a class body; a function nested inside another function's body is a local helper pytest never collects, so its fixture-named parameter is exempt. A `@pytest.fixture`-decorated function is exempt from the use check, since injecting one fixture into another purely to order its setup is intentional. Ordinary test parameters stay exempt from both checks. See also the file-global constants use-count rule: [`rules/file-global-constants.md`](../rules/file-global-constants.md).
+Test files follow the comment policy above; other test-specific exemptions are listed here. The one annotation the test-file exemption does NOT cover is a known pytest builtin fixture parameter: `tmp_path`, `monkeypatch`, `capsys`, `capfd`, `caplog`, `request`, and `tmp_path_factory` each have a single documented injected type, so the gate requires that annotation (`tmp_path: Path`) even inside a test file. The same set of fixtures is also subject to a use check: a pytest-collected test function that declares one of these parameters and never references it in its body fails the gate, because pytest materializes the fixture's setup (the temp directory, the monkeypatch context, the output capture) on every run whether or not the body reads the value — drop the unused parameter. A parameter counts as referenced when its name is read, augmented-assigned, or deleted anywhere in the body, including inside a nested function or comprehension. Only pytest-collectable functions are inspected — those at module top level or defined directly in a class body; a function nested inside another function's body is a local helper pytest never collects, so its fixture-named parameter is exempt. A `@pytest.fixture`-decorated function is exempt from the use check, since injecting one fixture into another purely to order its setup is intentional. Ordinary test parameters stay exempt from both checks.
 
 ---
 

package/docs/agent-spawn-protocol.md

@@ -1,6 +1,6 @@
 # Agent Spawn Protocol
 
-Full protocol behind the always-on `rules/agent-spawn-protocol.md` kernel. It applies before any Agent or Task tool invocation — Explore, implementation, research, or team subagents.
+Full protocol for briefing a subagent. It applies before any Agent or Task tool invocation — Explore, implementation, research, or team subagents.
 
 ## Step 1: Context sufficiency check
 

package/docs/codex-compatibility.md

@@ -65,22 +65,10 @@ hand when the host should receive that context.
 
 ## Luna fast-mode guard
 
-`hooks/blocking/luna_fast_mode_gate.py` serves Claude and Codex. Codex reads its own `hooks.json`, so add this `PreToolUse` group to that file. Replace `<CODEX_HOOKS_ROOT>` with the directory that holds the shipped hook:
-
-```json
-{
-  "matcher": "Agent|Task|multi_agent_v1__spawn_agent",
-  "hooks": [
-    {
-      "type": "command",
-      "command": "python <CODEX_HOOKS_ROOT>/blocking/luna_fast_mode_gate.py",
-      "timeout": 10
-    }
-  ]
-}
-```
-
-The guard requires exact `fast` for Luna spawns through `Agent` and `Task`. Native Codex `multi_agent_v1__spawn_agent` accepts exact `fast` or `priority`. Other models and tools pass through.
+Commit `0f21faf8` retired `luna_fast_mode_gate.py` with the other blocking
+policy hooks. The package ships no replacement, so a Codex `hooks.json` needs
+no entry for it, and the spawn tier a Luna spawn asks for is the caller's to
+hold.
 
 ## Roots and safety
 

package/docs/nas-ssh-invocation.md

@@ -23,7 +23,7 @@ from there when something needs them, and keep them out of anything committed or
 
 Write the script file with the Write tool. Keeping the commands in a file has a second benefit: a
 destructive word such as `rm -rf` inside the file never appears in a Bash tool command string, so the
-`destructive_command_blocker` hook stays out of the way.
+harness permission prompt never fires on it and an unattended run keeps going.
 
 The script runs through `bash -s` in a single shell. Variables, `cd`, and `source` all carry from one
 line to the next. Standard output, standard error and the exit code all come back.

package/docs/references/prose-style-enforcement.md

@@ -10,8 +10,8 @@ The flag is `PROSE_STYLE_ENFORCEMENT_ENABLED` in `hooks/blocking/config/prose_st
 
 ## Always on
 
-Structural AskUserQuestion lean-block validation in `ask_user_question_shape_blocker` (chat detail, length caps on question blocks) stays active regardless of the flag. Historical/comparative language detection in `state_description_blocker.py` runs unconditionally and does not read this flag. Apply `rules/asd-ste100-language.md` for user-facing word choice and sentence style. Code-rules and security blockers are out of scope for this switch.
+Historical/comparative language detection in `state_description_blocker.py` runs unconditionally and does not read this flag. Apply `rules/asd-ste100-language.md` for user-facing word choice and sentence style. Code-rules and security blockers are out of scope for this switch.
 
 ## Hedging claims
 
-Hedge-word discipline is prose guidance, not a hook: `rules/hedging-claims.md`. State a claim with its evidence, or label it unverified in the same sentence as the hedge word.
+Hedge-word discipline is prose guidance, not a hook. State a claim with its evidence, or label it unverified in the same sentence as the hedge word.