claude-dev-env 2.18.0 → 2.20.0

package/_shared/pr-loop/scripts/tests/test_code_rules_gate.py

@@ -300,6 +300,45 @@ def test_main_staged_mode_blocks_when_staged_lines_introduce_violations(
     assert exit_code == 1
 
 
+def test_main_immediate_mode_blocks_staged_rule_violations(
+    temporary_git_repository: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    write_file(temporary_git_repository / "module.py", "first_count = 1\n")
+    commit_all_files(temporary_git_repository, "initial")
+    write_file(
+        temporary_git_repository / "module.py",
+        "first_count = 1\n"
+        "def compute_total(operand):\n"
+        "    result = operand + 1\n"
+        "    return result\n",
+    )
+    stage_file(temporary_git_repository, "module.py")
+
+    monkeypatch.chdir(temporary_git_repository)
+    exit_code = gate_module.main(["--immediate"])
+
+    assert exit_code == 1
+
+
+def test_main_immediate_mode_skips_staged_test_execution(
+    temporary_git_repository: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    write_file(temporary_git_repository / "module.py", "first_count = 1\n")
+    commit_all_files(temporary_git_repository, "initial")
+    write_file(
+        temporary_git_repository / "test_staged_failure.py",
+        "def test_intentionally_fails() -> None:\n    assert False\n",
+    )
+    stage_file(temporary_git_repository, "test_staged_failure.py")
+
+    monkeypatch.chdir(temporary_git_repository)
+    exit_code = gate_module.main(["--immediate"])
+
+    assert exit_code == 0
+
+
 def test_main_staged_mode_passes_when_no_staged_violations(
     temporary_git_repository: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -2336,10 +2375,18 @@ def test_parse_arguments_reads_staged_base_and_prefix_flags() -> None:
     assert parsed_arguments.paths == [Path("explicit_file.py")]
 
 
+def test_parse_arguments_reads_immediate_scope_flag() -> None:
+    parsed_arguments = gate_module.parse_arguments(["--immediate"])
+
+    assert parsed_arguments.immediate is True
+    assert parsed_arguments.staged is False
+
+
 def test_parse_arguments_applies_documented_defaults() -> None:
     parsed_arguments = gate_module.parse_arguments([])
 
     assert parsed_arguments.staged is False
+    assert parsed_arguments.immediate is False
     assert parsed_arguments.base == "origin/main"
     assert parsed_arguments.repo_root is None
     assert parsed_arguments.only_under == []

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