claude-dev-env 7.7.1 → 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/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.

package/hooks/HOOK_SPECS_PROMPT_WORKFLOW.md

@@ -49,6 +49,4 @@ Generated prompt-workflow outputs must declare, in their audit frontmatter:
 - `base_minimal_instruction_layer: true`
 - `on_demand_skill_loading: true`
 
-The Stop guard blocks responses that omit either signal. These signals are
-the machine-checkable counterpart to the policy text in
-`rules/prompt-workflow-context-controls.md`.
+The Stop guard blocks responses that omit either signal.

package/hooks/blocking/code_rules_constants_config.py

@@ -1,4 +1,4 @@
-"""Constants-outside-config checks and the file-global constant use-count check.
+"""Constants-outside-config checks.
 
 Also carries check_config_duplicate_path_anchor, which flags a config module
 that rebuilds a directory a sibling module in the same package already
@@ -22,7 +22,6 @@ from code_rules_path_utils import (  # noqa: E402
     is_config_file,
 )
 from code_rules_shared import (  # noqa: E402
-    _build_parent_map,
     docstring_line_numbers,
     get_file_extension,
     is_migration_file,
@@ -35,7 +34,6 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
 )
 from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ALL_PYTHON_EXTENSIONS,
-    FILE_GLOBAL_UPPER_SNAKE_PATTERN,
 )
 
 
@@ -164,111 +162,6 @@ def check_constants_outside_config_advisory(content: str, file_path: str) -> Non
         sys.stderr.write(f"[CODE_RULES advisory] {file_path}: {each_issue}\n")
 
 
-def _is_upper_snake_constant_name(name: str) -> bool:
-    """Return True for UPPER_SNAKE identifiers including those with a leading underscore."""
-    return bool(FILE_GLOBAL_UPPER_SNAKE_PATTERN.match(name))
-
-
-def _collect_module_level_upper_snake_constants(
-    module_tree: ast.Module,
-) -> dict[str, int]:
-    """Return mapping of module-level UPPER_SNAKE constant name to its line number."""
-    constants_by_name: dict[str, int] = {}
-    for each_node in module_tree.body:
-        if isinstance(each_node, ast.Assign):
-            for each_target in each_node.targets:
-                if isinstance(each_target, ast.Name) and _is_upper_snake_constant_name(each_target.id):
-                    constants_by_name.setdefault(each_target.id, each_node.lineno)
-        elif isinstance(each_node, ast.AnnAssign):
-            if isinstance(each_node.target, ast.Name) and _is_upper_snake_constant_name(each_node.target.id):
-                constants_by_name.setdefault(each_node.target.id, each_node.lineno)
-    return constants_by_name
-
-
-def _resolve_enclosing_function_qname(
-    load_node: ast.Name,
-    parent_by_child_id: dict[int, ast.AST],
-) -> Optional[str]:
-    """Return 'ClassName.function_name' or 'function_name' for the enclosing function.
-
-    Returns None when the reference is at module scope (no enclosing function).
-    Decorator expressions on a function/method count as belonging to that function.
-    """
-    enclosing_function_name: Optional[str] = None
-    enclosing_class_name: Optional[str] = None
-    current_ancestor = parent_by_child_id.get(id(load_node))
-    while current_ancestor is not None:
-        if isinstance(current_ancestor, (ast.FunctionDef, ast.AsyncFunctionDef)) and enclosing_function_name is None:
-            enclosing_function_name = current_ancestor.name
-        elif isinstance(current_ancestor, ast.ClassDef):
-            enclosing_class_name = current_ancestor.name
-            break
-        current_ancestor = parent_by_child_id.get(id(current_ancestor))
-    if enclosing_function_name is None:
-        if enclosing_class_name is not None:
-            return f"<class:{enclosing_class_name}>"
-        return None
-    if enclosing_class_name is not None:
-        return f"{enclosing_class_name}.{enclosing_function_name}"
-    return enclosing_function_name
-
-
-def check_file_global_constants_use_count(content: str, file_path: str) -> list[str]:
-    """Flag module-level UPPER_SNAKE constants referenced by only one function/method.
-
-    Enforces the file-global-constants use-count rule: a constant used by just
-    one caller belongs in that caller's scope. Test files, config files,
-    workflow-registry files, and non-Python files are exempt. Constants with
-    zero references are out of scope. The enforcer entry module
-    (``hooks/blocking/code_rules_enforcer.py``) is exempt to avoid
-    self-blocking.
-    """
-    if is_test_file(file_path):
-        return []
-    if is_config_file(file_path):
-        return []
-    if is_workflow_registry_file(file_path):
-        return []
-    if get_file_extension(file_path) not in ALL_PYTHON_EXTENSIONS:
-        return []
-    if file_path.replace("\\", "/").endswith("hooks/blocking/code_rules_enforcer.py"):
-        return []
-
-    try:
-        module_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-
-    constants_by_name = _collect_module_level_upper_snake_constants(module_tree)
-    if not constants_by_name:
-        return []
-
-    parent_by_child_id = _build_parent_map(module_tree)
-    callers_by_constant: dict[str, set[str]] = {name: set() for name in constants_by_name}
-    for each_node in ast.walk(module_tree):
-        if not isinstance(each_node, ast.Name):
-            continue
-        if not isinstance(each_node.ctx, ast.Load):
-            continue
-        if each_node.id not in callers_by_constant:
-            continue
-        enclosing_qname = _resolve_enclosing_function_qname(each_node, parent_by_child_id)
-        if enclosing_qname is None:
-            callers_by_constant[each_node.id].add("<module-scope>")
-        else:
-            callers_by_constant[each_node.id].add(enclosing_qname)
-
-    issues: list[str] = []
-    for each_constant_name, each_line_number in sorted(constants_by_name.items(), key=lambda pair: pair[1]):
-        caller_count = len(callers_by_constant[each_constant_name])
-        if caller_count == 1:
-            issues.append(
-                f"Line {each_line_number}: File-global constant {each_constant_name} used by only 1 function/method - move to method scope or add a second caller"
-            )
-
-    return issues
-
-
 def _references_dunder_file(node: ast.AST) -> bool:
     """Return True when the expression tree reads ``__file__``."""
     return any(