claude-dev-env 2.17.0 → 2.19.0

package/_shared/pr-loop/AGENTS.md

@@ -11,6 +11,7 @@ Runtime documents and scripts shared by every PR-loop skill. Changes here affect
 | `post-audit-thread-contract.md` | Single source of truth for the `post_audit_thread.py` invocation string, exit-code table, and per-caller policy (bugteam exit 2 = hard blocker; autoconverge clean-audit failed post = recorded bypass) |
 | `fix-protocol.md` | Ordered sequence a fix lens follows: read, capture SHA, TDD, apply, validate, self-audit, commit, push, reply + resolve |
 | `gh-payloads.md` | How to build GitHub review and reply payloads via MCP tools; describes the one-review-per-loop pattern |
+| `preflight-proposal.md` | Shared immutable proposal evidence and mutation-boundary contract for audit preflight worktrees |
 | `state-schema.md` | Fields each PR-loop workflow tracks across iterations; documents common fields and per-skill extensions |
 | `code-rules-gate.md` | Reference for the CODE_RULES pre-commit gate check; describes what the gate blocks and when it runs |
 | `precatch-rubric.md` | Shared pre-catch lane checklist — deterministic sweep, doc-vs-code parity, test-assertion completeness, PR-description parity, adversarial audit — that autoconverge's lenses and pr-converge's CODE_REVIEW step read on demand |
@@ -24,4 +25,4 @@ Runtime documents and scripts shared by every PR-loop skill. Changes here affect
 
 ## Breaking-change rule
 
-Any shape change in `audit-contract.md` or `audit-reply-template.md` requires updating every consuming skill in the same commit.
+Any shape change in a canonical contract listed under **Key documents** requires updating every consuming skill in the same commit.

package/_shared/pr-loop/preflight-proposal.md

@@ -0,0 +1,56 @@
+# Preflight proposal contract
+
+Audit skills use this contract when the caller selects `preflight-proposal`. The mode prepares a local candidate and returns evidence for downstream selection.
+
+Each skill hub defines its command name and finding classification. Commands use this shape:
+
+```text
+<audit-skill> preflight-proposal <pr_number> --base-sha <base_sha> --head-sha <head_sha> --worktree <isolated_worktree>
+```
+
+## Required inputs
+
+| Input | Contract |
+|---|---|
+| `pr_number` | Resolved open pull-request number |
+| `--base-sha` | Full immutable base commit SHA |
+| `--head-sha` | Full immutable head commit SHA |
+| `--worktree` | Caller-supplied isolated worktree path |
+
+## Contract
+
+1. Validate every required input before the first audit command.
+2. Run `git rev-parse HEAD` in the supplied worktree and require exact equality with the head SHA.
+3. Gather changed paths and audit scope from the exact `base_sha...head_sha` range. Use the resolved PR number for PR metadata.
+4. Run the complete audit and findings against the immutable range and worktree.
+5. Keep every audit edit and test inside the caller-supplied isolated worktree.
+6. Create an immutable proposal identity. Use the existing commit SHA for committed proposals. For working-tree edits, use a deterministic diff hash over the baseline `HEAD` SHA, base SHA, head SHA, sorted normalized changed paths, status records, and file bytes.
+7. Record every changed path, including tracked, untracked, renamed, and deleted paths.
+8. Record exact tests and outcomes: each test command, exit code, and outcome.
+9. Return selected-candidate-ready proposal evidence with the proposal ID, isolated worktree path, changed paths, findings, tests, and outcomes.
+10. Keep commit, push, pull-request body, pull-request comment, pull-request review, pull-request update, merge, rebase, and Ready-state mutations disabled.
+11. Return the proposal for downstream disposition. The downstream owner adds the proposal ID to its selected or dispositioned proposal collection. Reapplication uses exactly the selected records and their changed paths. Give each later finding a new proposal ID and evidence record.
+
+## Evidence record
+
+Use this record shape:
+
+```yaml
+mode: preflight-proposal
+pr_number: <resolved PR number>
+base_sha: <immutable base SHA>
+head_sha: <immutable head SHA>
+proposal_id:
+  kind: commit-sha | diff-sha256
+  value: <immutable identity>
+isolated_worktree: <caller-supplied path>
+changed_paths:
+  - <normalized path>
+findings:
+  - <audit-classified finding>
+tests:
+  - command: <exact command>
+    exit_code: <integer>
+    outcome: <exact outcome>
+downstream_selection: required
+```

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_gate_running.py

@@ -3,14 +3,23 @@
 from pathlib import Path
 
 import pytest
-from code_rules_gate_parts import gate_running
 
+from code_rules_gate_parts import enforcer_loading, gate_running
+from code_rules_gate_parts.tests._repo_test_helpers import (
+    init_repository,
+    write_commit_and_stage_change,
+)
 
-def _clean_validate(_content: str, _path: str, _prior: str = "", **_kwargs: object) -> list[str]:
+
+def _clean_validate(
+    _content: str, _path: str, _prior: str = "", **_kwargs: object
+) -> list[str]:
     return []
 
 
-def _dirty_validate(_content: str, _path: str, _prior: str = "", **_kwargs: object) -> list[str]:
+def _dirty_validate(
+    _content: str, _path: str, _prior: str = "", **_kwargs: object
+) -> list[str]:
     return ["Line 1: bad"]
 
 
@@ -92,8 +101,42 @@ def test_print_violation_section_groups_by_relative_path(
 ) -> None:
     module_path = (tmp_path / "module.py").resolve()
 
-    gate_running.print_violation_section("HEADER", {module_path: ["Line 1: issue"]}, tmp_path)
+    gate_running.print_violation_section(
+        "HEADER", {module_path: ["Line 1: issue"]}, tmp_path
+    )
 
     captured = capsys.readouterr()
     assert "HEADER" in captured.err
     assert "Line 1: issue" in captured.err
+
+
+def test_gate_caller_scans_staged_content_with_commit_stage_scope(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    repository_root = tmp_path / "repository"
+    repository_root.mkdir()
+    init_repository(repository_root)
+    committed_source = "def calculate_total() -> int:\n    return 0\n"
+    staged_source = (
+        "def calculate_total() -> int:\n    total = 9999\n    return total\n"
+    )
+    file_path = write_commit_and_stage_change(
+        repository_root,
+        "service.py",
+        committed_source,
+        staged_source,
+    )
+
+    resolved_file_path = file_path.resolve()
+    exit_code = gate_running.run_gate(
+        validate_content=enforcer_loading.load_validate_content(),
+        all_file_paths=[resolved_file_path],
+        repository_root=repository_root,
+        all_added_lines_by_path={resolved_file_path: {2, 3}},
+        should_read_staged_content=True,
+    )
+
+    captured = capsys.readouterr()
+    assert exit_code == 1
+    assert "9999" in captured.err

package/_shared/pr-loop/worker-spawn.md

@@ -121,13 +121,14 @@ preflight/runner classification strings (for example `grok_binary_missing`,
 After a grok fallthrough the dispatcher calls `detect_host_profile()` from
 `tier_model_ids` (advisor scripts). Detection order:
 
-1. `ADVISOR_HOST_PROFILE` when set — must be `Claude` or `ThirdParty` (any letter case).
+1. `ADVISOR_HOST_PROFILE` when set — must be `Claude`, `Codex`, or `ThirdParty` (any letter case).
 2. `THIRD_PARTY` when truthy — `1`, `true`, `yes`, or `on`.
 3. Default: `Claude`.
 
-Profiles are the real names `Claude` and `ThirdParty` (not a separate Grok host
+Profiles are the real names `Claude`, `Codex`, and `ThirdParty` (not a separate Grok host
 profile). Grok is tier 1 on every host; host profile only chooses the post-grok
-branch (Agent-tool handoff vs headless claude chain).
+branch (Agent-tool handoff vs headless claude chain). A Codex profile takes the
+non-Claude branch.
 
 ## Code-review host routing
 

package/bin/ever-shipped-skills.mjs

@@ -30,6 +30,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'build-goal-prompt',
     'bugteam',
     'caveman',
+    'cert-classification-rule',
     'closeout',
     'code',
     'comments',
@@ -40,6 +41,9 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'copilot-review',
     'deep-research',
     'descriptions',
+    'e-code-review',
+    'e-simplify',
+    'eli5',
     'emergencies',
     'everything-search',
     'findbugs',
@@ -64,6 +68,8 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'midjourney-prompt',
     'midjourney-submit',
     'monitor-open-prs',
+    'pr-name-by-capability',
+    'pr-refinement',
     'orchestrator',
     'orchestrator-refresh',
     'plan-to-pr',
@@ -71,6 +77,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'pmid',
     'pmin',
     'post-audit-findings',
+    'pr-cleanup',
     'pr-consistency-audit',
     'pr-converge',
     'pr-fix-protocol',
@@ -80,6 +87,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'pr-scope-resolve',
     'pre-compact',
     'privacy-hygiene',
+    'prototype',
     'prompt-generator',
     'qbug',
     'rebase',
@@ -90,14 +98,20 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'release-notes-html',
     'remember',
     'research-mode',
+    'review-router',
+    'review-tier',
     'reviewer-gates',
     'reviews',
     'run-claude-dev-env',
     'session-log',
     'session-tidy',
+    'pr-shared-extraction',
     'show',
     'skill-builder',
     'small-cl',
+    'pr-small-cl',
+    'source-command-logifix',
+    'source-command-sr-loop',
     'split-pr',
     'structure-prompt',
     'task-build',

package/bin/install-constants.mjs

@@ -170,3 +170,8 @@ export const CURSOR_SYNC_SCRIPT_FILE_NAME = 'sync_to_cursor.py';
  * Windows Python launcher command the installer may bake into hook settings.
  */
 export const WINDOWS_PYTHON_LAUNCHER_COMMAND = 'py -3';
+
+/**
+ * Maximum time each Python interpreter probe may run during detection.
+ */
+export const PYTHON_PROBE_TIMEOUT_MILLISECONDS = 10_000;

package/bin/install.agents-home.test.mjs

@@ -33,6 +33,10 @@ const SHIPPED_SKILL_NAME = 'privacy-hygiene';
 const ELI5_SKILL_NAME = 'eli5';
 const SHIPPED_AGENT_FILE_NAME = 'clean-coder.md';
 const PERSONAL_SKILL_NAME = 'my-notes';
+const SHARED_DIRECTORY_NAME = '_shared';
+const PR_LOOP_DIRECTORY_NAME = 'pr-loop';
+const PREFLIGHT_PROPOSAL_FILE_NAME = 'preflight-proposal.md';
+const PREFLIGHT_PROPOSAL_POINTER = '@~/.claude/_shared/pr-loop/preflight-proposal.md';
 
 /**
  * @param {string} homeDirectory
@@ -53,6 +57,24 @@ function runInstaller(homeDirectory, extraArguments) {
     });
 }
 
+/**
+ * @param {{ homeDirectory: string, skillsInstallDirectory: string }} installationPaths
+ */
+function assertProposalContractInstallation(installationPaths) {
+    const { homeDirectory, skillsInstallDirectory } = installationPaths;
+    const allContractPathSegments = [
+        SHARED_DIRECTORY_NAME, PR_LOOP_DIRECTORY_NAME, PREFLIGHT_PROPOSAL_FILE_NAME,
+    ];
+    const installedPointerPath = join(skillsInstallDirectory, ...allContractPathSegments);
+    const pointerLine = readFileSync(installedPointerPath, 'utf8').trimEnd().split('\n').at(-1);
+    const allTargetSegments = pointerLine.slice('@~/'.length).split('/');
+    const installedContractPath = join(homeDirectory, ...allTargetSegments);
+    const sourceContractPath = join(PACKAGE_DIRECTORY, ...allContractPathSegments);
+
+    assert.equal(pointerLine, PREFLIGHT_PROPOSAL_POINTER);
+    assert.equal(readFileSync(installedContractPath, 'utf8'), readFileSync(sourceContractPath, 'utf8'));
+}
+
 test('CONTENT_DIRECTORIES omits agents because that tree installs to the agents home', () => {
     assert.equal(CONTENT_DIRECTORIES.includes(MANAGED_AGENTS_DIRECTORY_NAME), false);
 });
@@ -106,6 +128,7 @@ test('a full install writes skills and agents under .agents and points .claude a
         );
         assert.equal(realpathSync(lookupSkillFile), realpathSync(canonicalSkillFile));
         assert.equal(realpathSync(lookupEli5SkillFile), realpathSync(canonicalEli5SkillFile));
+        assertProposalContractInstallation({ homeDirectory, skillsInstallDirectory });
         assert.equal(
             readFileSync(lookupAgentFile, 'utf8'),
             readFileSync(canonicalAgentFile, 'utf8'),

package/bin/install.codex-rules.test.mjs

@@ -23,16 +23,32 @@ import {
     CODEX_RULES_SHIPPED_FILE_NAME,
     DEFAULT_CODEX_DIRECTORY_NAME,
 } from './install-constants.mjs';
-import { CONTENT_DIRECTORIES, INSTALL_GROUPS } from './install.mjs';
+import {
+    CONTENT_DIRECTORIES,
+    detectPython,
+    INSTALL_GROUPS,
+    pythonFileAndPrefixArguments,
+} from './install.mjs';
 
 const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
 const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
 const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
+const INSTALLER_PROCESS_TIMEOUT_MS = 60_000;
 const SHIPPED_RULES_SOURCE_PATH = join(
     PACKAGE_DIRECTORY,
     CODEX_RULES_PACKAGE_DIRECTORY_NAME,
     CODEX_RULES_SHIPPED_FILE_NAME,
 );
+const BLOCKING_HOOKS_DIRECTORY = join(PACKAGE_DIRECTORY, 'hooks', 'blocking');
+const PYTHON_PII_SCAN_SCRIPT = [
+    'import json',
+    'import sys',
+    'from dataclasses import asdict',
+    'from pii_scanner import scan_text_for_pii',
+    'all_findings = scan_text_for_pii(sys.stdin.read())',
+    "home_path_findings = [asdict(each_finding) for each_finding in all_findings if each_finding.category == 'home-path']",
+    'print(json.dumps(home_path_findings))',
+].join('\n');
 
 function runInstaller(homeDirectory, extraArguments) {
     return execFileSync('node', [INSTALLER_PATH, ...extraArguments], {
@@ -45,9 +61,44 @@ function runInstaller(homeDirectory, extraArguments) {
             GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
             [CODEX_HOME_ENVIRONMENT_VARIABLE]: join(homeDirectory, DEFAULT_CODEX_DIRECTORY_NAME),
         },
+        timeout: INSTALLER_PROCESS_TIMEOUT_MS,
     });
 }
 
+function scanTextWithProductionPiiScanner(scannedText) {
+    const temporaryDirectory = mkdtempSync(join(tmpdir(), 'cdev-pii-scan-'));
+    try {
+        const detectedPythonCommand = detectPython();
+        if (!detectedPythonCommand) {
+            throw new Error('No usable Python interpreter found for the PII scanner test');
+        }
+        const { file, prefixArguments } = pythonFileAndPrefixArguments(
+            detectedPythonCommand,
+        );
+        const scannerJson = execFileSync(
+            file,
+            [...prefixArguments, '-c', PYTHON_PII_SCAN_SCRIPT],
+            {
+                cwd: PACKAGE_DIRECTORY,
+                encoding: 'utf8',
+                env: {
+                    ...process.env,
+                    PYTHONPATH: BLOCKING_HOOKS_DIRECTORY,
+                    CLAUDE_LOCAL_IDENTITY_PATH: join(
+                        temporaryDirectory,
+                        'missing-local-identity.json',
+                    ),
+                },
+                input: scannedText,
+                timeout: INSTALLER_PROCESS_TIMEOUT_MS,
+            },
+        );
+        return JSON.parse(scannerJson);
+    } finally {
+        rmSync(temporaryDirectory, { recursive: true, force: true });
+    }
+}
+
 test('CONTENT_DIRECTORIES omits codex-rules because that tree installs to the Codex home', () => {
     assert.equal(CONTENT_DIRECTORIES.includes(CODEX_RULES_PACKAGE_DIRECTORY_NAME), false);
 });
@@ -123,11 +174,15 @@ test('a full install copies shipped Codex rules and leaves a local default.rules
     }
 });
 
-test('a full install Codex rules file contains no personal home path', () => {
-    const shippedText = readFileSync(SHIPPED_RULES_SOURCE_PATH, 'utf8');
-    assert.equal(shippedText.includes('Users\\jon'), false);
-    assert.equal(shippedText.includes('Users/jon'), false);
-    assert.equal(shippedText.includes('JonEcho'), false);
+test('the shipped Codex rules file has no production-scanner home-path findings', () => {
+    const allHomePathFindings = scanTextWithProductionPiiScanner(
+        readFileSync(SHIPPED_RULES_SOURCE_PATH, 'utf8'),
+    );
+    assert.deepEqual(
+        allHomePathFindings,
+        [],
+        `home-path findings: ${JSON.stringify(allHomePathFindings, null, 2)}`,
+    );
 });
 
 test('--only journal skips Codex rules; --only core copies them', () => {

package/bin/install.mjs

@@ -27,6 +27,7 @@ import {
     CODEX_RULES_PACKAGE_DIRECTORY_NAME,
     CURSOR_SYNC_SCRIPT_FILE_NAME,
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
+    PYTHON_PROBE_TIMEOUT_MILLISECONDS,
 } from './install-constants.mjs';
 import {
     resolveInstallRoot,
@@ -163,7 +164,7 @@ export const CORE_INCLUDE_DIRECTORIES = [
 export const CORE_SKILLS = [
     'orchestrator', 'orchestrator-refresh', 'team-advisor',
     'grok-spawn',
-    'small-cl',
+    'pr-small-cl',
     'everything-search',
     'privacy-hygiene',
     'issue-tracker',
@@ -434,6 +435,42 @@ export function interpreterCommandFromPath(executablePath) {
     return forwardSlashedPath.includes(' ') ? `"${forwardSlashedPath}"` : forwardSlashedPath;
 }
 
+/**
+ * Formats a path as one shell argument for the selected platform.
+ *
+ * @param {string} path Path to format.
+ * @param {string} platform Platform whose shell will parse the argument.
+ * @returns {string} A quoted shell argument.
+ */
+export function commandArgumentFromPath(path, platform = process.platform) {
+    const forwardSlashedPath = path.replace(/\\/g, '/');
+    if (platform === 'win32') {
+        if (/^[A-Za-z0-9_./:@+=,-]+$/.test(forwardSlashedPath)) return forwardSlashedPath;
+        return forwardSlashedPath.split('%').map(segment => `"${segment}"`).join('^%');
+    }
+    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(forwardSlashedPath)) return forwardSlashedPath;
+    return `'${forwardSlashedPath.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Quotes standalone plugin-root hook paths while preserving inline commands.
+ *
+ * @param {string} commandString Source hook command.
+ * @param {string} pluginRootForward Forward-slash plugin root directory.
+ * @returns {string} Rewritten hook command.
+ */
+function quoteStandalonePluginRootHookPath(commandString, pluginRootForward) {
+    const standalonePathPattern = /(^|\s)(["']?)\$\{CLAUDE_PLUGIN_ROOT\}(\/hooks\/[^\s"']*?\.py)\2(?=$|[\s;&|])/g;
+    return commandString.replace(
+        standalonePathPattern,
+        (_match, argumentPrefix, _sourceQuote, relativeHookPath) => (
+            `${argumentPrefix}${commandArgumentFromPath(
+                `${pluginRootForward}${relativeHookPath}`,
+            )}`
+        ),
+    );
+}
+
 /**
  * Picks the interpreter command baked into every managed hook in settings.json.
  * On win32 the first working candidate is resolved to its absolute
@@ -444,14 +481,14 @@ export function interpreterCommandFromPath(executablePath) {
  *
  * @returns {string|null} The interpreter command, or null when none is usable.
  */
-function detectPython() {
+export function detectPython() {
     const candidates = pythonCandidatesForPlatform(process.platform);
     for (const { command, versionFlag } of candidates) {
         try {
-            const version = execSync(`${command} ${versionFlag}`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            const version = execSync(`${command} ${versionFlag}`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: PYTHON_PROBE_TIMEOUT_MILLISECONDS }).trim();
             if (!version.includes('Python 3.')) continue;
             if (process.platform !== 'win32') return command;
-            const executablePath = execSync(`${command} -c "import sys; print(sys.executable)"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            const executablePath = execSync(`${command} -c "import sys; print(sys.executable)"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: PYTHON_PROBE_TIMEOUT_MILLISECONDS }).trim();
             if (!executablePath || isWindowsStorePythonStub(executablePath)) continue;
             return interpreterCommandFromPath(executablePath);
         } catch { /* try next */ }
@@ -1266,11 +1303,13 @@ function commandTailEndsAtManagedHook(normalizedCommand, relativePath) {
  * @returns {boolean} True when the command is the inline validators runner.
  */
 export function commandIsInlineManagedValidatorRunner(normalizedCommand) {
-    const inlineValidatorRunnerMarker = /sys\.path\.insert\([^)]*\.claude\/hooks[^)]*\)[\s\S]*run_all_validators/;
-    return (
-        normalizedCommand.includes('/.claude/hooks') &&
-        inlineValidatorRunnerMarker.test(normalizedCommand)
-    );
+    if (!normalizedCommand.includes('sys.path.insert(')) return false;
+    if (!normalizedCommand.includes('from validators.run_all_validators import main')) return false;
+    const hasLiteralHooksPath = normalizedCommand.includes('/.claude/hooks');
+    const hasShippedBase64Path = normalizedCommand.includes('__claude_dev_env_managed_hooks__');
+    if (!hasLiteralHooksPath && !hasShippedBase64Path) return false;
+    const inlineValidatorRunnerMarker = /sys\.path\.insert\([\s\S]*from validators\.run_all_validators import main/;
+    return inlineValidatorRunnerMarker.test(normalizedCommand);
 }
 
 /**
@@ -1348,6 +1387,7 @@ function startEventFromHookGroupList(settings, eventType) {
 export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand) {
     const managedHookRelativePaths = managedHookScriptRelativePaths(hooksConfig);
     const pluginRootForward = pluginRootDir.replace(/\\/g, '/');
+    const encodedPluginHooksPath = Buffer.from(`${pluginRootForward}/hooks`, 'utf8').toString('base64');
     if (!settings.hooks || typeof settings.hooks !== 'object') settings.hooks = {};
     let groupCount = 0;
     for (const [eventType, matcherGroups] of Object.entries(hooksConfig.hooks)) {
@@ -1356,6 +1396,14 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
         for (const sourceGroup of matcherGroups) {
             const rewrittenHooks = sourceGroup.hooks.map(hook => {
                 let command = hook.command;
+                command = command.replace(
+                    /r(['"])\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\1/g,
+                    () => (
+                        `(__import__('base64').b64decode('${encodedPluginHooksPath}').decode(), `
+                        + "'__claude_dev_env_managed_hooks__')[0]"
+                    ),
+                );
+                command = quoteStandalonePluginRootHookPath(command, pluginRootForward);
                 command = command.replace(
                     /\$\{CLAUDE_PLUGIN_ROOT\}/g,
                     () => pluginRootForward,

package/bin/install.prune.test.mjs

@@ -13,10 +13,16 @@ import {
 import { tmpdir } from 'node:os';
 import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+    MANAGED_SKILLS_DIRECTORY_NAME,
+    PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+} from './install-constants.mjs';
+import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
 
 const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
 const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
 const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
+const INSTALLER_PROCESS_TIMEOUT_MS = 60_000;
 const EXCLUDED_PACKAGE_COPY_DIRECTORY = 'node_modules';
 
 const RETIRED_SKILL_DIRECTORIES = [
@@ -35,7 +41,7 @@ const STALE_SKILL_FILE_RELATIVE_SEGMENTS = ['scripts', 'retired_module.py'];
 const RUNTIME_ARTIFACT_RELATIVE_SEGMENTS = ['scripts', '__pycache__', 'helper.cpython-312.pyc'];
 const SCOPED_GROUP_SKILL_DIRECTORY = 'orchestrator';
 const CORE_REVIEW_GUIDE_SKILL_DIRECTORIES = [
-    'small-cl',
+    'pr-small-cl',
 ];
 const PRIOR_RUN_BACKUP_DIRECTORY_NAMES = [
     '2020-01-01T00-00-00-000Z',
@@ -102,8 +108,8 @@ function prunedSkillBackupContains(claudeDirectory, skillsRelativePath) {
  *
  * @returns {{homeDirectory: string, claudeDirectory: string, skillsDirectory: string, manifestPath: string}}
  */
-function createSandbox() {
-    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-prune-home-'));
+function createSandbox(homeDirectoryPrefix = 'cdev-prune-home-') {
+    const homeDirectory = mkdtempSync(join(tmpdir(), homeDirectoryPrefix));
     const claudeDirectory = join(homeDirectory, '.claude');
     const skillsDirectory = join(claudeDirectory, 'skills');
     mkdirSync(skillsDirectory, { recursive: true });
@@ -111,6 +117,61 @@ function createSandbox() {
     return { homeDirectory, claudeDirectory, skillsDirectory, manifestPath };
 }
 
+test('the retired-skill fallback covers every current shipped skill', () => {
+    const sourceSkillsDirectory = join(
+        PACKAGE_DIRECTORY,
+        PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+        MANAGED_SKILLS_DIRECTORY_NAME,
+    );
+    const allCurrentSkillNames = readdirSync(sourceSkillsDirectory, { withFileTypes: true })
+        .filter(eachEntry => eachEntry.isDirectory())
+        .filter(eachEntry => existsSync(join(sourceSkillsDirectory, eachEntry.name, 'SKILL.md')))
+        .map(eachEntry => eachEntry.name);
+    const allUncoveredSkillNames = allCurrentSkillNames.filter(
+        eachSkillName => !EVER_SHIPPED_SKILL_NAMES.has(eachSkillName),
+    );
+
+    assert.deepEqual(allUncoveredSkillNames, [], 'every current skill must enter the fallback set');
+});
+
+test('a core install runs the spaced-path Write dispatcher and captures its red denial', () => {
+    const sandbox = createSandbox('cdev prune & (home)-');
+    try {
+        runInstaller(sandbox.homeDirectory, ['--only', 'core']);
+        const settings = readSettings(sandbox.claudeDirectory);
+        const dispatcherHooks = settings.hooks.PreToolUse
+            .flatMap(eachGroup => eachGroup.hooks)
+            .filter(eachHook => /(?:^|[\\/])pre_tool_use_dispatcher\.py["']?(?:\s|$)/.test(eachHook.command));
+        assert.equal(dispatcherHooks.length, 1, 'the core install writes one PreToolUse dispatcher');
+
+        const protectedFilePath = join(sandbox.homeDirectory, 'protected file.txt');
+        writeFileSync(protectedFilePath, 'existing content\n');
+        const writePayload = JSON.stringify({
+            tool_name: 'Write',
+            tool_input: { file_path: protectedFilePath, content: 'replacement content\n' },
+        });
+        const { childEnvironment } = resolveInstallerInvocation(sandbox.homeDirectory);
+        const dispatcherRun = spawnSync(dispatcherHooks[0].command, {
+            cwd: dirname(INSTALLER_PATH),
+            encoding: 'utf8',
+            env: childEnvironment,
+            input: `${writePayload}\n`,
+            shell: true,
+            timeout: 30000,
+        });
+
+        assert.equal(dispatcherRun.status, 0, dispatcherRun.stderr);
+        const shownRedDecision = JSON.parse(dispatcherRun.stdout.trim());
+        assert.equal(shownRedDecision.hookSpecificOutput.permissionDecision, 'deny');
+        assert.match(
+            shownRedDecision.hookSpecificOutput.permissionDecisionReason,
+            /BLOCKED: Write on existing file/,
+        );
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+    }
+});
+
 /**
  * Plant a skill directory under the sandbox with a single marker file.
  *
@@ -142,6 +203,7 @@ function runInstaller(homeDirectory, extraArguments) {
         cwd: dirname(installerPath),
         encoding: 'utf8',
         env: childEnvironment,
+        timeout: INSTALLER_PROCESS_TIMEOUT_MS,
     });
 }