claude-dev-env 8.106.0 → 8.106.2

package/bin/install-constants.mjs

@@ -174,11 +174,6 @@ export const WINDOWS_PYTHON_LAUNCHER_COMMAND = 'py -3';
 export const PYTHON_PROBE_TIMEOUT_MILLISECONDS = 10_000;
 export const ADDITIONAL_SETTINGS_BLOB_PREFIX = 'settings-';
 export const CODEX_NATIVE_ROUTING_MATCHER = 'multi_agent_v1__spawn_agent';
-export const CODEX_SUBAGENT_PROMPT_MATCHER = 'Agent|Task';
-export const ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS = new Set([
-    CODEX_NATIVE_ROUTING_MATCHER,
-    CODEX_SUBAGENT_PROMPT_MATCHER,
-]);
 export const ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES = new Set([
     'open_tasks_stop_gate.py',
     'owned_pr_merge_stop_gate.py',

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

@@ -130,11 +130,10 @@ test('seeds one editable policy and one native Codex routing hook', () => {
         assert.match(firstRoutingGroups[0].hooks[0].command, /subagent_model_routing\.mjs/);
         assert.match(firstRoutingGroups[0].hooks[1].command, /spawn_readiness_hook\.py/);
         assert.match(firstRoutingGroups[0].hooks[2].command, /spawn_oversight_hook\.py/);
-        const firstSpawnPromptGroups = firstCodexHooks.hooks.PreToolUse.filter(
-            group => group.matcher === 'Agent|Task',
+        assert.deepEqual(
+            firstCodexHooks.hooks.PreToolUse.map(group => group.matcher),
+            ['multi_agent_v1__spawn_agent'],
         );
-        assert.equal(firstSpawnPromptGroups.length, 1);
-        assert.match(firstSpawnPromptGroups[0].hooks[0].command, /skill_loaded_reminder\.py/);
         assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse', 'UserPromptSubmit', 'PostToolUse', 'Stop', 'SessionStart']);
         const allCodexPostToolUseCommands = firstCodexHooks.hooks.PostToolUse.flatMap(
             group => group.hooks.map(hook => hook.command),
@@ -276,6 +275,7 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
         const allLegacyRegistrations = [
             ['PreToolUse', 'Edit', '.claude', 'blocking/pre_tool_use_dispatcher.py'],
             ['PreToolUse', 'Bash', '.agents', 'blocking/bash_pre_tool_use_dispatcher.py'],
+            ['PreToolUse', 'Agent|Task', 'custom-codex', 'session/skill_loaded_reminder.py'],
             ['SessionStart', '*', 'custom-codex', 'session/issue_tracker_session_starter.py'],
             ['Stop', '*', '.claude', 'session/skill_loaded_reminder.py'],
             ['SessionEnd', '*', 'custom-codex', 'lifecycle/session_end_cleanup.py'],
@@ -311,8 +311,13 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
 
         const migratedHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
         const allSpawnGroups = migratedHooks.hooks.PreToolUse.filter(eachGroup =>
-            ['Agent|Task', 'multi_agent_v1__spawn_agent'].includes(eachGroup.matcher));
-        assert.equal(allSpawnGroups.length, 2);
+            eachGroup.matcher === 'multi_agent_v1__spawn_agent');
+        assert.equal(allSpawnGroups.length, 1);
+        assert.equal(
+            migratedHooks.hooks.PreToolUse.flatMap(eachGroup => eachGroup.hooks)
+                .some(eachHook => String(eachHook.command).includes('skill_loaded_reminder.py')),
+            false,
+        );
         migratedHooks.hooks.PreToolUse = migratedHooks.hooks.PreToolUse.filter(eachGroup => !allSpawnGroups.includes(eachGroup));
         const allPackagePromptCommands = (migratedHooks.hooks.UserPromptSubmit ?? [])
             .flatMap(eachGroup => eachGroup.hooks)

package/bin/install.mjs

@@ -50,7 +50,7 @@ import {
     SUBAGENT_MODEL_POLICY_FILE_NAME,
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
-    ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS,
+    CODEX_NATIVE_ROUTING_MATCHER,
     ALL_CODEX_NATIVE_SESSION_START_HOOK_SCRIPT_NAMES,
     ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES,
     ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES,
@@ -1064,6 +1064,7 @@ export function pruneStaleInstalledFiles(
         currentInstalledFiles.map(currentFile => comparisonKeyForPath(currentFile, options)),
     );
     const resolvedRoot = resolve(destinationRoot);
+    const resolvedRootTarget = realPathOrNull(resolvedRoot);
     let prunedCount = 0;
     const failedPaths = [];
     for (const priorFile of priorInstalledFiles) {
@@ -1072,6 +1073,17 @@ export function pruneStaleInstalledFiles(
         if (currentFileKeys.has(comparisonKeyForPath(stalePath, options))) continue;
         if (isRetainedUnmanagedPath(stalePath, managedHomeDirectory)) continue;
         if (!isMovableStaleFile(stalePath)) continue;
+        const staleTarget = realPathOrNull(stalePath);
+        if (!staleTarget || !resolvedRootTarget) {
+            failedPaths.push(stalePath);
+            continue;
+        }
+        if (!isInsideDirectory(staleTarget, resolvedRootTarget)) {
+            console.warn(
+                `  Warning: leaving ${relative(managedHomeDirectory, stalePath)} in place — a link on its path leads outside ${resolvedRoot}`,
+            );
+            continue;
+        }
         const backupRelativePath = relative(resolvedRoot, stalePath);
         const didMove = moveIntoRunBackup(
             stalePath, backupRoot, backupRelativePath, STALE_FILE_REASON_LABEL, managedHomeDirectory,
@@ -1303,6 +1315,7 @@ export const RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS = new Set([
     'blocking/session_title_stop_gate.py',
     'session/issue_tracker_session_starter.py',
     'session/deepen_first_prompt.py',
+    'workflow/investigation_tracker_reset.py',
 ]);
 
 export const MOVED_HOOK_RELATIVE_PATHS = new Set([
@@ -2271,7 +2284,7 @@ function selectCodexNativeHooksConfig(hooksConfig) {
         ...hooksConfig,
         hooks: {
             PreToolUse: Array.isArray(preToolUseGroups)
-                ? preToolUseGroups.filter(group => ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS.has(group?.matcher))
+                ? preToolUseGroups.filter(group => group?.matcher === CODEX_NATIVE_ROUTING_MATCHER)
                 : [],
             UserPromptSubmit: Array.isArray(userPromptSubmitGroups) ? userPromptSubmitGroups : [],
             PostToolUse: selectCodexNativeGroupsByScriptName(
@@ -3013,6 +3026,10 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             if (allowedSkills && !allowedSkills.has(skillDir.name)) continue;
             const skillSourceDirectory = join(skillsSource, skillDir.name);
             const skillDestinationDirectory = join(CLAUDE_HOME, MANAGED_SKILLS_DIRECTORY_NAME, skillDir.name);
+            if (lstatSync(skillDestinationDirectory, { throwIfNoEntry: false })?.isSymbolicLink()) {
+                console.log(`  = ${join(MANAGED_SKILLS_DIRECTORY_NAME, skillDir.name)} (linked skill left in place)`);
+                continue;
+            }
             const stats = copyTree(skillSourceDirectory, skillDestinationDirectory);
             skillsCreated += stats.created;
             skillsUpdated += stats.updated;

package/bin/install.prune.test.mjs

@@ -9,6 +9,8 @@ import {
     readFileSync,
     readdirSync,
     rmSync,
+    symlinkSync,
+    lstatSync,
 } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname, basename } from 'node:path';
@@ -828,6 +830,49 @@ test('a fresh scoped core install includes efficient-review', () => {
     }
 });
 
+test('a full reinstall leaves a skill folder linked into another repository untouched', () => {
+    const sandbox = createSandbox();
+    const linkedRepositoryDirectory = mkdtempSync(join(tmpdir(), 'cdev-linked-skill-repo-'));
+    try {
+        runInstaller(sandbox.homeDirectory, []);
+        const linkedSkillName = 'efficient-review';
+        const repositorySkillDirectory = join(linkedRepositoryDirectory, 'skills', linkedSkillName);
+        const repositorySkillText = 'name: efficient-review\nthe repository copy\n';
+        writeFileWithParents(join(repositorySkillDirectory, 'SKILL.md'), repositorySkillText);
+        const skillLinkPath = join(sandbox.skillsDirectory, linkedSkillName);
+        rmSync(skillLinkPath, { recursive: true, force: true });
+        symlinkSync(repositorySkillDirectory, skillLinkPath, 'junction');
+
+        const installerOutput = runInstallerReadingBothStreams(sandbox.homeDirectory, []);
+
+        assert.equal(lstatSync(skillLinkPath).isSymbolicLink(), true, 'the skill link stays a link');
+        assert.equal(
+            readFileSync(join(repositorySkillDirectory, 'SKILL.md'), 'utf8'),
+            repositorySkillText,
+            'the repository SKILL.md keeps its own text',
+        );
+        assert.deepEqual(
+            readdirSync(repositorySkillDirectory),
+            ['SKILL.md'],
+            'the install writes no package file into the linked repository',
+        );
+        assert.equal(
+            prunedSkillBackupContains(sandbox.claudeDirectory, join(linkedSkillName, 'SKILL.md')),
+            false,
+            'the stale prune moves no file out of the linked repository',
+        );
+        assert.match(installerOutput, /skills[\\/]efficient-review \(linked skill left in place\)/);
+        assert.equal(
+            readManifest(sandbox.manifestPath).files.some(recordedPath => recordedPath.includes(linkedSkillName)),
+            false,
+            'the manifest records no file under the linked skill',
+        );
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+        rmSync(linkedRepositoryDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a fresh scoped core install ships active skills and omits retired skills', () => {
     const sandbox = createSandbox();
     try {

package/bin/install.test.mjs

@@ -1245,6 +1245,7 @@ test('retired hook registrations stay managed so reinstall removes them', () =>
         'blocking/session_title_stop_gate.py',
         'session/issue_tracker_session_starter.py',
         'session/deepen_first_prompt.py',
+        'workflow/investigation_tracker_reset.py',
     ]);
     const shippedHooks = JSON.parse(
         readFileSync(new URL('../hooks/hooks.json', import.meta.url), 'utf8')

package/docs/codex-compatibility.md

@@ -26,8 +26,8 @@ Run `codex-compat bridge --surface <name> --payload '<json-object>'`. The bridge
 
 The package installer seeds `subagent-model-policy.json` in the agents-home
 `rules/` directory when the file is absent. It registers one `PreToolUse` group
-for `multi_agent_v1__spawn_agent` and one for `Agent|Task` in `$CODEX_HOME/hooks.json`.
-Before adding these groups, the installer removes obsolete package-owned hook
+for `multi_agent_v1__spawn_agent` in `$CODEX_HOME/hooks.json`.
+Before adding this group, the installer removes obsolete package-owned hook
 registrations from every event. Custom hook entries and Codex's enabled or
 disabled hook settings stay unchanged. Claude-only hook groups do not enter the
 Codex file.

package/hooks/features/README.md

@@ -28,6 +28,6 @@ Each family page starts with a title and an agent-facing behavior summary. Its f
 - [Conduct gates](./conduct-gates.md) covers chat replies, edit markers, step notes, checked claims, and the pull request lifecycle skill.
 - [Session context](./session-context.md) covers skill reminders, startup guidance, and the auto mode denial quick fix.
 - [Spawn routing](./spawn-routing.md) covers spawn readiness, pacing, and model selection.
-- [Observability](./observability.md) covers instruction loads, edited files, and investigation resets.
+- [Observability](./observability.md) covers instruction loads and edited files.
 - [Read gates](./read-gates.md) covers the image size cap on Read.
 - [Lifecycle cleanup](./lifecycle-cleanup.md) covers nested checkouts, worktree setup, and session cleanup.

package/hooks/features/observability.md

@@ -1,18 +1,16 @@
 # Observability
 
-This family records instruction loads and file edits for later checks. Delegation also clears the lead session's investigation timer so the agent can continue its investigation.
+This family records instruction loads and file edits for later checks.
 
 ## Checks
 
 - `observability/instructions_loaded_logger.py` writes selected instruction-load fields to a JSONL log.
 - `observability/session_file_edit_tracker.py` records edited file paths in a per-session tracker for the stage gate.
-- `workflow/investigation_tracker_reset.py` clears the investigation tracker after delegation.
 
 ## When it fires
 
 - `observability/instructions_loaded_logger.py` runs on `InstructionsLoaded`, matcher `session_start|nested_traversal|path_glob_match|include|compact`, timeout `10` seconds in `hooks.json`.
 - `observability/session_file_edit_tracker.py` runs on `PostToolUse`, matcher `Write|Edit|MultiEdit|apply_patch`, timeout `30` seconds in `hooks.json`.
-- `workflow/investigation_tracker_reset.py` runs on `PostToolUse`, matcher `Agent|Task|TeamCreate`, timeout `30` seconds in `hooks.json`.
 
 ## Proving it
 
@@ -22,10 +20,8 @@ Preconditions:
 
 - **Instruction log.** Input is an `InstructionsLoaded` payload with a file path and load reason. Run `python -m pytest packages/claude-dev-env/hooks/observability/test_instructions_loaded_logger.py -q`. The adjacent test observes one JSONL record with the selected fields.
 - **Edit tracker.** Input is a Write payload with a file path and session ID. Run `python -m pytest packages/claude-dev-env/hooks/observability/test_session_file_edit_tracker.py -q`. The adjacent test observes the resolved path in that session's tracker.
-- **Investigation reset.** Input is a completed Agent, Task, or TeamCreate call. Run `python -m pytest packages/claude-dev-env/hooks/workflow/test_investigation_tracker_reset.py -q`. The adjacent test observes removal of the tracker file.
 
 ## Gotchas
 
 - The instruction logger keeps only selected payload fields. It exits zero if logging fails.
 - The edit tracker never blocks a tool call. Its per-session file is read later by the stage gate.
-- The investigation reset applies to delegation tools. Its companion investigation gate lives outside this Claude hook registration map.

package/hooks/features/session-context.md

@@ -1,6 +1,6 @@
 # Session context
 
-This family injects reminders and task guidance when an agent starts, resumes, submits a prompt, spawns a helper, starts an artifact page, or hits an auto mode denial. The startup scripts leave the session quiet when their opt-in conditions fail.
+This family injects reminders and task guidance when an agent starts, resumes, submits a prompt, starts a workflow helper, starts an artifact page, or hits an auto mode denial. The startup scripts leave the session quiet when their opt-in conditions fail.
 
 ## Checks
 
@@ -17,7 +17,7 @@ This family injects reminders and task guidance when an agent starts, resumes, s
 
 ## When it fires
 
-- `session/skill_loaded_reminder.py` runs on `PreToolUse` matcher `Agent|Task` at `10` seconds, `UserPromptSubmit` matcher empty at `10` seconds, `SessionStart` matcher `compact` at `10` seconds, and `SubagentStart` matcher `workflow-subagent` at `10` seconds in `hooks.json`.
+- `session/skill_loaded_reminder.py` runs on `UserPromptSubmit` matcher empty at `10` seconds, `SessionStart` matcher `compact` at `10` seconds, and `SubagentStart` matcher `workflow-subagent` at `10` seconds in `hooks.json`.
 - `session/compaction_recall_prompt.py` runs on `SessionStart` matcher `compact` at `10` seconds in `hooks.json`. The installer also writes it to the Codex `hooks.json`, the only `SessionStart` hook Codex gets.
 - `session/task_tool_prompt.py`, `session/working_style_prompt.py`, `session/advisor_rules_prompt.py`, and `session/orchestrator_auto_starter.py` run on `SessionStart`, matcher empty, timeout `10` seconds each in `hooks.json`.
 - `session/plugin_session_baseline_writer.py` runs on `SessionStart`, matcher empty, at `10` seconds, so it sees every source. `session/plugin_change_warning.py` runs on `UserPromptSubmit`, matcher empty, at `10` seconds in `hooks.json`.
@@ -30,7 +30,7 @@ Preconditions:
 
 - Run each command from the repository root with Python and pytest available. Enable opt-in flags only inside the tests.
 
-- **Skill reminder.** Input is a helper spawn whose prompt lacks poteto-mode. Run `python -m pytest packages/claude-dev-env/hooks/session/test_skill_loaded_reminder.py -q`. The adjacent test observes the reminder and leaves an already prepared prompt unchanged.
+- **Skill reminder.** Input is a compaction, a user turn, or a workflow helper start. Run `python -m pytest packages/claude-dev-env/hooks/session/test_skill_loaded_reminder.py -q`. The adjacent test observes the reminder, silence on a spawn payload, and no `PreToolUse` registration in `hooks.json`.
 - **Compaction recall.** Input is a Claude Code transcript or a Codex rollout with typed, meta, sidechain, peer, and harness entries across a compaction. Run `python -m pytest packages/claude-dev-env/hooks/session/test_compaction_user_messages.py packages/claude-dev-env/hooks/session/test_compaction_trim.py packages/claude-dev-env/hooks/session/test_compaction_recall_prompt.py packages/claude-dev-env/hooks/session/test_compaction_trim_eval.py -q`. The tests observe only typed messages, a stable result across a second compaction, the trim rules, the recall budget, and the trimmed lines in the hook's `additionalContext`. `python packages/claude-dev-env/hooks/session/compaction_trim_eval.py` trims each fixture transcript with planted facts, prints the share of facts that survive, the reversals marked, and the compression ratio, and exits 1 on any loss.
 - **Task tracking.** Input is a SessionStart event. Run `python -m pytest packages/claude-dev-env/hooks/session/test_task_tool_prompt.py -q`. The adjacent test observes a `SessionStart` context directive that names the task tool.
 - **Working style.** Input is a SessionStart event. Run `python -m pytest packages/claude-dev-env/hooks/session/test_working_style_prompt.py -q`. The adjacent test observes the fixed context text.
@@ -44,7 +44,7 @@ Preconditions:
 
 - The recall keeps the first message and the newest that fit in 6,000 characters, under the 2,500 token preview limit Codex applies to hook context. A message over 1,500 characters is cut, and the line says how much was left out.
 - The overruled mark comes from cue phrases such as `instead` or `change of plan` and shared words. A reversal with no cue phrase gets no mark, and the later line still overrides by its place. A cue in a message that agrees with an earlier one, such as `dont use haiku` after `use Python trim instead of Haiku`, marks that earlier line too, so the context tells the agent to follow the later message where the two differ.
-- `session/skill_loaded_reminder.py` has four registration points. Its tests cover helper prompt rewriting and repeated prompt suppression.
+- `session/skill_loaded_reminder.py` has three registration points. An `Agent` or `Task` helper gets no poteto-mode line from it; a brief that needs the skill names it, or spawns `pstack:poteto-agent`. Its tests cover the compaction restore, the workflow helper reminder, silence on a user turn while the skill stays loaded, silence on a spawn payload, and no `PreToolUse` registration in `hooks.json`.
 - The advisor prompt depends on settings and an environment disable flag. The two starter scripts each use separate opt-in checks.
 - The issue tracker starter requires the checkout to appear in the project path registry.
 - `advisory/auto_mode_denial_quick_fix.py` lives under `advisory/` but belongs here because its only output is agent context and a one-line user message.

package/hooks/hooks.json

@@ -5,11 +5,6 @@
       {
         "matcher": "Agent|Task",
         "hooks": [
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/skill_loaded_reminder.py",
-            "timeout": 10
-          },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/haiku_spawn_slim_gate.py",
@@ -526,16 +521,6 @@
           }
         ]
       },
-      {
-        "matcher": "Agent|Task|TeamCreate",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/workflow/investigation_tracker_reset.py",
-            "timeout": 30
-          }
-        ]
-      },
       {
         "matcher": "Bash|PowerShell",
         "hooks": [

package/hooks/hooks_constants/skill_loaded_reminder_constants.py

@@ -3,52 +3,29 @@
 from __future__ import annotations
 
 __all__ = [
-    "ALL_SELF_LOADING_SUBAGENT_TYPES",
     "COMPACTION_REMINDER",
     "COMPACTION_SOURCE",
     "NOT_LOADED_REMINDER",
     "ALL_POTETO_MODE_SKILL_NAMES",
-    "PRE_TOOL_USE_EVENT_NAME",
-    "PROMPT_SEPARATOR",
     "SESSION_START_EVENT_NAME",
     "ALL_SLASH_COMMAND_MARKERS",
     "SUBAGENT_START_EVENT_NAME",
-    "CLAUDE_SUBAGENT_PROMPT_PREFIX",
-    "CODEX_SUBAGENT_PROMPT_PREFIX",
-    "ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME",
     "USER_PROMPT_SUBMIT_EVENT_NAME",
     "WORKFLOW_SUBAGENT_TYPE",
 ]
 
-PRE_TOOL_USE_EVENT_NAME = "PreToolUse"
 SESSION_START_EVENT_NAME = "SessionStart"
 USER_PROMPT_SUBMIT_EVENT_NAME = "UserPromptSubmit"
 COMPACTION_SOURCE = "compact"
 SUBAGENT_START_EVENT_NAME = "SubagentStart"
 WORKFLOW_SUBAGENT_TYPE = "workflow-subagent"
 
-ALL_SELF_LOADING_SUBAGENT_TYPES = frozenset({"pstack:poteto-agent", "poteto-agent"})
-
 ALL_POTETO_MODE_SKILL_NAMES = ("poteto-mode", "pstack:poteto-mode")
 SKILL_TOOL_NAME = "Skill"
 ALL_SLASH_COMMAND_MARKERS = (
     "<command-name>/poteto-mode</command-name>",
     "<command-name>/pstack:poteto-mode</command-name>",
 )
-PROMPT_SEPARATOR = "\n\n"
-
-CLAUDE_SUBAGENT_PROMPT_PREFIX = (
-    "Before any other work, invoke the poteto-mode skill with the Skill tool. "
-    "Every prompt you write for a subagent opens with the same instruction."
-)
-
-CODEX_SUBAGENT_PROMPT_PREFIX = "$poteto-mode"
-
-ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME = {
-    "Agent": ("prompt", CLAUDE_SUBAGENT_PROMPT_PREFIX),
-    "Task": ("prompt", CLAUDE_SUBAGENT_PROMPT_PREFIX),
-    "spawn_agent": ("message", CODEX_SUBAGENT_PROMPT_PREFIX),
-}
 
 NOT_LOADED_REMINDER = (
     "The poteto-mode skill is not loaded in this context. "

package/hooks/session/skill_loaded_reminder.py

@@ -1,9 +1,8 @@
 #!/usr/bin/env python3
-"""Hook that restores poteto-mode after compaction and loads it for helpers.
+"""Hook that restores poteto-mode after compaction and loads it for workflow helpers.
 
 ::
 
-    Agent or Codex spawn_agent, skill not named -> prompt opens with "invoke poteto-mode"
     Workflow script helper starts               -> "invoke poteto-mode now"
     compact SessionStart, skill invoked before   -> "invoke the skill again"
     compact SessionStart, no prior invocation
@@ -28,55 +27,21 @@ if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
 from hooks_constants.skill_loaded_reminder_constants import (
-    ALL_SELF_LOADING_SUBAGENT_TYPES,
     COMPACTION_REMINDER,
     COMPACTION_SOURCE,
     NOT_LOADED_REMINDER,
     ALL_POTETO_MODE_SKILL_NAMES,
-    PRE_TOOL_USE_EVENT_NAME,
-    PROMPT_SEPARATOR,
     SESSION_START_EVENT_NAME,
     ALL_SLASH_COMMAND_MARKERS,
     SUBAGENT_START_EVENT_NAME,
-    ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME,
     USER_PROMPT_SUBMIT_EVENT_NAME,
     WORKFLOW_SUBAGENT_TYPE,
 )
-from hooks_constants.pre_tool_use_allow_output import write_pre_tool_use_allow_to_stdout
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
 from hooks_constants.setup_project_paths_constants import DECODE_ERRORS_POLICY, UTF8_ENCODING
 from transcript_skill_scan import skill_invocation_status
 
 
-def subagent_input_with_poteto_mode(
-    tool_name: str,
-    all_tool_input_fields: dict[str, object],
-) -> dict[str, object] | None:
-    """Return the spawn input with the poteto-mode invocation first, or None to leave it.
-
-    ::
-
-        Agent        {"prompt": "Reply leaf."}   -> {"prompt": "Before any ...\\n\\nReply leaf."}
-        spawn_agent  {"message": "Fix it."}      -> {"message": "$poteto-mode\\n\\nFix it."}
-        Agent        {"prompt": "Invoke poteto-mode, then ..."}  -> None
-        Agent        {"subagent_type": "poteto-agent", ...}      -> None, it loads the skill
-
-    Claude Code spawns through Agent or Task and Codex through spawn_agent, so
-    each tool name carries its own prompt field and invocation text.
-
-    Args:
-        tool_name: The spawn tool the session called.
-        all_tool_input_fields: The spawn input the session is about to send.
-    """
-    field_name, invocation_prefix = ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME[tool_name]
-    prompt = all_tool_input_fields.get(field_name)
-    if not isinstance(prompt, str) or ALL_POTETO_MODE_SKILL_NAMES[0] in prompt:
-        return None
-    if all_tool_input_fields.get("subagent_type") in ALL_SELF_LOADING_SUBAGENT_TYPES:
-        return None
-    return {**all_tool_input_fields, field_name: invocation_prefix + PROMPT_SEPARATOR + prompt}
-
-
 def poteto_mode_status(all_transcript_lines: Iterable[str]) -> tuple[bool, bool]:
     """Report whether the skill was invoked and whether it remains loaded.
 
@@ -160,26 +125,11 @@ def reminder_for(all_hook_fields: dict[str, object]) -> str | None:
     return NOT_LOADED_REMINDER if was_invoked and not is_loaded else None
 
 
-def _is_subagent_spawn(all_hook_fields: dict[str, object]) -> bool:
-    return (
-        all_hook_fields.get("hook_event_name") == PRE_TOOL_USE_EVENT_NAME
-        and all_hook_fields.get("tool_name") in ALL_SPAWN_PROMPT_FIELDS_AND_PREFIXES_BY_TOOL_NAME
-        and isinstance(all_hook_fields.get("tool_input"), dict)
-    )
-
-
 def main() -> None:
-    """Rewrite a subagent prompt, or print the reminder its event needs, or stay quiet."""
+    """Print the reminder its event needs, or stay quiet."""
     hook_payload = read_hook_input_dictionary_from_stdin()
     if hook_payload is None:
         return
-    if _is_subagent_spawn(hook_payload):
-        rewritten_input = subagent_input_with_poteto_mode(
-            hook_payload["tool_name"], hook_payload["tool_input"]
-        )
-        if rewritten_input is not None:
-            write_pre_tool_use_allow_to_stdout(rewritten_input)
-        return
     reminder = reminder_for(hook_payload)
     if reminder is None:
         return

package/hooks/session/test_skill_loaded_reminder.py

@@ -1,4 +1,4 @@
-"""Tests for skill_loaded_reminder. Checks restoration after compaction and helper prompts."""
+"""Tests for skill_loaded_reminder. Checks restoration after compaction and spawn pass-through."""
 
 import json
 import sys
@@ -76,10 +76,6 @@ def _run_main(hook_payload: object) -> str:
     return captured_stdout.getvalue()
 
 
-def _agent_call(tool_input: dict[str, object], tool_name: str = "Agent") -> dict[str, object]:
-    return {"hook_event_name": "PreToolUse", "tool_name": tool_name, "tool_input": tool_input}
-
-
 def _user_turn(transcript_path: Path) -> dict[str, object]:
     return {"hook_event_name": "UserPromptSubmit", "transcript_path": str(transcript_path)}
 
@@ -90,85 +86,28 @@ def _write_transcript(tmp_path: Path, all_lines: list[str]) -> Path:
     return transcript_path
 
 
-class TestSubagentSpawn:
-    def test_a_plain_subagent_prompt_opens_with_the_poteto_mode_invocation(self) -> None:
-        emitted = json.loads(
-            _run_main(
-                _agent_call(
-                    {
-                        "description": "Find callers",
-                        "subagent_type": "Explore",
-                        "prompt": "List every caller of main.",
-                    }
-                )
-            )
-        )
-        hook_output = emitted["hookSpecificOutput"]
-        rewritten_input = hook_output["updatedInput"]
-        assert hook_output["permissionDecision"] == "allow"
-        assert rewritten_input["prompt"].startswith(
-            "Before any other work, invoke the poteto-mode skill with the Skill tool."
-        )
-        assert rewritten_input["prompt"].endswith("\n\nList every caller of main.")
-        assert rewritten_input["subagent_type"] == "Explore"
-        assert rewritten_input["description"] == "Find callers"
-
-    def test_the_legacy_task_tool_name_is_rewritten_too(self) -> None:
-        emitted = json.loads(_run_main(_agent_call({"prompt": "Go."}, tool_name="Task")))
-        assert "poteto-mode" in emitted["hookSpecificOutput"]["updatedInput"]["prompt"]
-
-    def test_a_prompt_that_already_names_the_skill_is_left_alone(self) -> None:
-        assert _run_main(_agent_call({"prompt": "Invoke poteto-mode first. Then go."})) == ""
+class TestRegistration:
+    def test_a_spawn_payload_from_a_stale_registration_prints_nothing(self) -> None:
+        stale_spawn_payload = {
+            "hook_event_name": "PreToolUse",
+            "tool_name": "Agent",
+            "tool_input": {"prompt": "Reply leaf."},
+        }
+        assert _run_main(stale_spawn_payload) == ""
 
-    def test_a_poteto_agent_is_left_alone_because_it_loads_the_skill_itself(self) -> None:
-        assert (
-            _run_main(_agent_call({"subagent_type": "pstack:poteto-agent", "prompt": "Go."})) == ""
+    def test_no_pre_tool_use_group_runs_the_reminder(self) -> None:
+        shipped_hooks = json.loads(
+            (Path(__file__).resolve().parents[1] / "hooks.json").read_text(encoding="utf-8")
         )
-
-    def test_another_tool_is_left_alone(self) -> None:
-        assert _run_main(_agent_call({"prompt": "Go."}, tool_name="Bash")) == ""
-
-
-class TestSubagentInputWithPotetoMode:
-    def test_every_other_input_field_is_kept(self) -> None:
-        rewritten_input = reminder.subagent_input_with_poteto_mode(
-            "Agent", {"prompt": "Go.", "model": "sonnet", "run_in_background": True}
-        )
-        assert rewritten_input is not None
-        assert rewritten_input["model"] == "sonnet"
-        assert rewritten_input["run_in_background"] is True
-
-    def test_an_input_with_no_prompt_is_left_alone(self) -> None:
-        assert reminder.subagent_input_with_poteto_mode("Agent", {"description": "Go"}) is None
-
-    def test_a_codex_spawn_input_with_only_items_is_left_alone(self) -> None:
-        assert (
-            reminder.subagent_input_with_poteto_mode(
-                "spawn_agent", {"items": [{"type": "text", "text": "Go."}]}
-            )
-            is None
-        )
-
-
-class TestCodexSpawn:
-    def test_a_codex_spawn_message_opens_with_the_skill_mention(self) -> None:
-        emitted = json.loads(
-            _run_main(
-                _agent_call(
-                    {"message": "Fix the failing test.", "model": "gpt-6-luna"},
-                    tool_name="spawn_agent",
-                )
-            )
-        )
-        rewritten_input = emitted["hookSpecificOutput"]["updatedInput"]
-        assert rewritten_input["message"] == "$poteto-mode\n\nFix the failing test."
-        assert rewritten_input["model"] == "gpt-6-luna"
-        assert "prompt" not in rewritten_input
-
-    def test_a_codex_spawn_message_that_already_mentions_the_skill_is_left_alone(self) -> None:
-        assert (
-            _run_main(_agent_call({"message": "$poteto-mode\n\nFix it."}, tool_name="spawn_agent"))
-            == ""
+        all_pre_tool_use_commands = [
+            each_hook.get("command", "")
+            for each_group in shipped_hooks["hooks"]["PreToolUse"]
+            for each_hook in each_group["hooks"]
+        ]
+        assert all_pre_tool_use_commands
+        assert not any(
+            "skill_loaded_reminder.py" in each_command
+            for each_command in all_pre_tool_use_commands
         )
 
 
@@ -353,9 +292,7 @@ class TestReminderFor:
         assert hook_output["hookEventName"] == "SubagentStart"
         assert hook_output["additionalContext"] == NOT_LOADED_REMINDER
 
-    def test_an_agent_tool_helper_starting_prints_nothing_since_its_prompt_carries_the_line(
-        self,
-    ) -> None:
+    def test_an_agent_tool_helper_starting_prints_nothing(self) -> None:
         assert (
             _run_main({"hook_event_name": "SubagentStart", "agent_type": "general-purpose"}) == ""
         )

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.106.0",
+    "version": "8.106.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/hooks/workflow/investigation_tracker_reset.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse hook — resets the serial investigation tracker when delegation occurs.
-
-Clears the investigation timestamp tracker when the lead session delegates work
-via Agent, Task, or TeamCreate tools. This allows the lead to resume limited
-diagnostic calls after properly delegating.
-
-Companion: blocking/serial-investigation-blocker.py (PreToolUse on Read|Bash|Grep)
-"""
-
-import json
-import os
-import sys
-
-TRACKER_STATE_PATH = os.path.join(
-    os.path.expanduser("~"), ".claude", "runtime", "investigation-tracker.json"
-)
-
-DELEGATION_TOOLS = frozenset({"Agent", "Task", "TeamCreate"})
-
-
-def clear_investigation_tracker() -> None:
-    try:
-        os.remove(TRACKER_STATE_PATH)
-    except FileNotFoundError:
-        pass
-    except OSError:
-        pass
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-    if not isinstance(hook_input, dict):
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    if tool_name not in DELEGATION_TOOLS:
-        sys.exit(0)
-
-    clear_investigation_tracker()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/workflow/test_investigation_tracker_reset.py

@@ -1,90 +0,0 @@
-"""Behavior tests for investigation tracker reset."""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-
-HOOK_DIRECTORY = Path(__file__).parent
-HOOK_SPEC = importlib.util.spec_from_file_location(
-    "investigation_tracker_reset",
-    HOOK_DIRECTORY / "investigation_tracker_reset.py",
-)
-assert HOOK_SPEC is not None
-assert HOOK_SPEC.loader is not None
-HOOK_MODULE = importlib.util.module_from_spec(HOOK_SPEC)
-HOOK_SPEC.loader.exec_module(HOOK_MODULE)
-
-
-def _run_main(input_text: str) -> int | None:
-    with mock.patch("sys.stdin", io.StringIO(input_text)):
-        try:
-            HOOK_MODULE.main()
-        except SystemExit as system_exit:
-            if system_exit.code not in (None, 0):
-                raise
-            return system_exit.code if isinstance(system_exit.code, int) else None
-    return None
-
-
-@pytest.mark.parametrize("delegation_tool", ["Agent", "Task", "TeamCreate"])
-def test_main_removes_tracker_after_delegation(
-    tmp_path: Path,
-    delegation_tool: str,
-) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    exit_status = _run_main(json.dumps({"tool_name": delegation_tool}))
-
-    assert exit_status in (None, 0)
-    assert not tracker_path.exists()
-
-
-@pytest.mark.parametrize("unrelated_tool", ["Read", "Bash", "Grep"])
-def test_main_keeps_tracker_for_unrelated_tool(
-    tmp_path: Path,
-    unrelated_tool: str,
-) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    exit_status = _run_main(json.dumps({"tool_name": unrelated_tool}))
-
-    assert exit_status in (None, 0)
-    assert tracker_path.exists()
-
-
-@pytest.mark.parametrize("invalid_input", ["not json", json.dumps([])])
-def test_main_ignores_invalid_input(
-    tmp_path: Path,
-    invalid_input: str,
-) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    exit_status = _run_main(invalid_input)
-
-    assert exit_status in (None, 0)
-    assert tracker_path.exists()
-
-
-def test_main_keeps_running_when_tracker_removal_fails(tmp_path: Path) -> None:
-    tracker_path = tmp_path / "investigation-tracker.json"
-    tracker_path.write_text("{}", encoding="utf-8")
-    HOOK_MODULE.__dict__["TRACKER_STATE_PATH"] = str(tracker_path)
-
-    with mock.patch.object(HOOK_MODULE.os, "remove", side_effect=OSError("locked")):
-        exit_status = _run_main(json.dumps({"tool_name": "Agent"}))
-
-    assert exit_status in (None, 0)
-    assert tracker_path.exists()