claude-dev-env 8.38.1 → 8.38.3

package/bin/install.mjs

@@ -1319,7 +1319,9 @@ function managedPackageSourceRoots() {
  * @param {Set<string>} managedHookRelativePaths Managed script paths under hooks/.
  * @returns {boolean} True when the command references a managed script.
  */
-export function commandReferencesManagedHook(commandString, managedHookRelativePaths) {
+export function commandReferencesManagedHook(
+    commandString, managedHookRelativePaths, sharedSettingsRealPath = null,
+) {
     if (typeof commandString !== 'string') return false;
     const normalizedCommand = commandString.replace(/\\/g, '/');
     if (commandIsInlineManagedValidatorRunner(normalizedCommand)) {
@@ -1329,6 +1331,51 @@ export function commandReferencesManagedHook(commandString, managedHookRelativeP
         if (commandTailEndsAtManagedHook(normalizedCommand, relativePath)) {
             return true;
         }
+        if (
+            sharedSettingsRealPath
+            && commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, sharedSettingsRealPath)
+        ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Report whether a command runs `<root>/hooks/<relative>` for a root whose
+ * settings.json resolves to the given settings file.
+ *
+ * Two install roots can share one settings.json through a symlink. Each install
+ * writes its own hooks directory into that one file, so the merge treats the
+ * hooks of every root that shares the file as managed and keeps one entry per
+ * script.
+ *
+ * @param {string} normalizedCommand Forward-slash-normalized hook command.
+ * @param {string} relativePath The managed script path under hooks/.
+ * @param {string} sharedSettingsRealPath The resolved path of the settings file being merged.
+ * @returns {boolean} True when the command runs that script under a sharing root.
+ */
+function commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, sharedSettingsRealPath) {
+    const commandArgumentBoundary = /[\s'";]/;
+    const hookPathTail = `/${MANAGED_HOOKS_DIRECTORY_NAME}/${relativePath}`;
+    const sharedSettingsKey = comparisonKeyForPath(sharedSettingsRealPath);
+    let tailStart = normalizedCommand.indexOf(hookPathTail);
+    while (tailStart !== -1) {
+        const characterAfterPath = normalizedCommand[tailStart + hookPathTail.length];
+        if (characterAfterPath === undefined || commandArgumentBoundary.test(characterAfterPath)) {
+            let rootStart = tailStart;
+            while (rootStart > 0 && !commandArgumentBoundary.test(normalizedCommand[rootStart - 1])) {
+                rootStart--;
+            }
+            const rootPath = normalizedCommand.slice(rootStart, tailStart);
+            const rootSettingsRealPath = rootPath
+                ? realPathOrNull(join(rootPath, SETTINGS_FILE_NAME))
+                : null;
+            if (rootSettingsRealPath && comparisonKeyForPath(rootSettingsRealPath) === sharedSettingsKey) {
+                return true;
+            }
+        }
+        tailStart = normalizedCommand.indexOf(hookPathTail, tailStart + 1);
     }
     return false;
 }
@@ -1399,14 +1446,17 @@ export function commandIsInlineManagedValidatorRunner(normalizedCommand) {
  * @param {object} settings The parsed settings.json object (mutated in place).
  * @param {string} eventType The lifecycle event whose groups are pruned.
  * @param {Set<string>} managedHookRelativePaths Managed script paths under hooks/.
+ * @param {string|null} sharedSettingsRealPath Resolved path of the settings file, or null.
  * @returns {void}
  */
-function pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths) {
+function pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths, sharedSettingsRealPath) {
     const existingGroups = settings.hooks[eventType];
     if (!Array.isArray(existingGroups)) return;
     settings.hooks[eventType] = retainedMatcherGroups(
         existingGroups,
-        commandString => commandReferencesManagedHook(commandString, managedHookRelativePaths),
+        commandString => commandReferencesManagedHook(
+            commandString, managedHookRelativePaths, sharedSettingsRealPath,
+        ),
     ).keptGroups;
 }
 
@@ -1457,9 +1507,14 @@ function startEventFromHookGroupList(settings, eventType) {
  * @param {string} pluginRootDir Directory ${CLAUDE_PLUGIN_ROOT} resolves to
  *   (the installer's `~/.claude` root; home is its parent directory).
  * @param {string} pythonCommand Interpreter command that replaces python3.
+ * @param {string|null} [sharedSettingsRealPath] Resolved path of the settings
+ *   file being merged. Hooks of every root whose settings.json resolves to it
+ *   count as managed, so roots sharing one file keep one entry per script.
  * @returns {number} Count of matcher groups merged.
  */
-export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand) {
+export function mergeHooksIntoSettings(
+    settings, hooksConfig, pluginRootDir, pythonCommand, sharedSettingsRealPath = null,
+) {
     const managedHookRelativePaths = managedHookScriptRelativePaths(hooksConfig);
     const pluginRootForward = pluginRootDir.replace(/\\/g, '/');
     const encodedPluginHooksPath = Buffer.from(`${pluginRootForward}/hooks`, 'utf8').toString('base64');
@@ -1467,7 +1522,7 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
     let groupCount = 0;
     for (const [eventType, matcherGroups] of Object.entries(hooksConfig.hooks)) {
         startEventFromHookGroupList(settings, eventType);
-        pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths);
+        pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths, sharedSettingsRealPath);
         for (const sourceGroup of matcherGroups) {
             const rewrittenHooks = sourceGroup.hooks.map(hook => {
                 let command = hook.command;
@@ -1492,7 +1547,9 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
             if (existingIndex >= 0) {
                 const existing = settings.hooks[eventType][existingIndex];
                 const userHooks = (groupHookEntries(existing) || []).filter(
-                    hook => !commandReferencesManagedHook(hook?.command, managedHookRelativePaths)
+                    hook => !commandReferencesManagedHook(
+                        hook?.command, managedHookRelativePaths, sharedSettingsRealPath,
+                    )
                 );
                 settings.hooks[eventType][existingIndex] = {
                     ...existing,
@@ -2079,7 +2136,9 @@ function mergeHooksAtPath(
         pruneManagedHooksFromSettings(settings, new Set());
     }
     const hooksConfig = selectHooksConfig(sourceHooksConfig);
-    const groupCount = mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand);
+    const groupCount = mergeHooksIntoSettings(
+        settings, hooksConfig, pluginRootDir, pythonCommand, realPathOrNull(settingsPath),
+    );
     writeFileSync(settingsPath, JSON.stringify(settings, null, indentation) + '\n');
     return groupCount;
 }

package/bin/install.shared-settings.test.mjs

@@ -0,0 +1,202 @@
+/**
+ * Two install roots that share one settings.json through a symlink keep one
+ * hook entry per managed script, whatever order the roots install in.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { join } from 'node:path';
+import {
+    mkdtempSync,
+    mkdirSync,
+    readFileSync,
+    rmSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { managedHookScriptRelativePaths, mergeHooksIntoSettings } from './install.mjs';
+
+const INSTALLER_PATH = fileURLToPath(new URL('./install.mjs', import.meta.url));
+const PACKAGE_HOOKS_JSON_PATH = fileURLToPath(new URL('../hooks/hooks.json', import.meta.url));
+
+function installEnvironment(homeDirectory) {
+    return {
+        ...process.env,
+        HOME: homeDirectory,
+        USERPROFILE: homeDirectory,
+        CLAUDE_CONFIG_DIR: '',
+        GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_USAGE_WRAPUP: '0',
+    };
+}
+
+function runCoreInstall(homeDirectory, extraArguments) {
+    const installRun = spawnSync(
+        process.execPath,
+        [INSTALLER_PATH, '--only', 'core', ...extraArguments],
+        { encoding: 'utf8', env: installEnvironment(homeDirectory) },
+    );
+    assert.equal(installRun.status, 0, installRun.stdout + installRun.stderr);
+}
+
+function allHookCommands(settingsPath) {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const allCommands = [];
+    for (const matcherGroups of Object.values(settings.hooks ?? {})) {
+        for (const group of matcherGroups) {
+            for (const hook of group.hooks ?? []) {
+                if (typeof hook.command === 'string') allCommands.push(hook.command.replace(/\\/g, '/'));
+            }
+        }
+    }
+    return allCommands;
+}
+
+function entryCountByScript(settingsPath) {
+    const hooksConfig = JSON.parse(readFileSync(PACKAGE_HOOKS_JSON_PATH, 'utf8'));
+    const allCommands = allHookCommands(settingsPath);
+    const countByScript = new Map();
+    for (const relativePath of managedHookScriptRelativePaths(hooksConfig)) {
+        const scriptPattern = new RegExp(`/hooks/${relativePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=$|[\\s'";])`, 'g');
+        const occurrences = allCommands.reduce(
+            (total, command) => total + (command.match(scriptPattern) ?? []).length,
+            0,
+        );
+        countByScript.set(relativePath, occurrences);
+    }
+    return countByScript;
+}
+
+function expectedCountByScript(hooksConfig) {
+    const countByScript = new Map();
+    for (const matcherGroups of Object.values(hooksConfig.hooks)) {
+        for (const group of matcherGroups) {
+            for (const hook of group.hooks) {
+                for (const match of hook.command.matchAll(/\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\/(\S+?\.(?:py|mjs))/g)) {
+                    countByScript.set(match[1], (countByScript.get(match[1]) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    return countByScript;
+}
+
+function assertOneEntryPerHookRegistration(settingsPath, stageName) {
+    const hooksConfig = JSON.parse(readFileSync(PACKAGE_HOOKS_JSON_PATH, 'utf8'));
+    const expectedCounts = expectedCountByScript(hooksConfig);
+    const actualCounts = entryCountByScript(settingsPath);
+    assert.ok(expectedCounts.size > 0, 'the package ships managed hook scripts');
+    for (const [relativePath, expectedCount] of expectedCounts) {
+        assert.equal(
+            actualCounts.get(relativePath),
+            expectedCount,
+            `${stageName}: ${relativePath} is registered once per hooks.json entry`,
+        );
+    }
+}
+
+function withSharedSettingsHome(runScenario) {
+    return t => {
+        const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-'));
+        try {
+            writeFileSync(join(homeDirectory, '.gitconfig'), '');
+            const mainRoot = join(homeDirectory, '.claude');
+            const profileRoot = join(homeDirectory, 'profiles', 'second');
+            mkdirSync(mainRoot, { recursive: true });
+            mkdirSync(profileRoot, { recursive: true });
+            const mainSettingsPath = join(mainRoot, 'settings.json');
+            writeFileSync(mainSettingsPath, '{}\n');
+            try {
+                symlinkSync(mainSettingsPath, join(profileRoot, 'settings.json'), 'file');
+            } catch (linkError) {
+                t.skip(`this host cannot create a file symlink (${linkError.code})`);
+                return;
+            }
+            runScenario({ homeDirectory, profileRoot, mainSettingsPath });
+        } finally {
+            rmSync(homeDirectory, { recursive: true, force: true });
+        }
+    };
+}
+
+test(
+    'main then profile then main keeps one entry per hook in the shared settings file',
+    withSharedSettingsHome(({ homeDirectory, profileRoot, mainSettingsPath }) => {
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main install');
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile install');
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main rerun');
+    }),
+);
+
+test(
+    'profile then main then profile keeps one entry per hook in the shared settings file',
+    withSharedSettingsHome(({ homeDirectory, profileRoot, mainSettingsPath }) => {
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile install');
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main install');
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile rerun');
+    }),
+);
+
+test('the merge prunes a hook of a root sharing the settings file and keeps one with its own file', t => {
+    const sandboxRoot = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-unit-'));
+    try {
+        const installRoot = join(sandboxRoot, 'install-root');
+        const sharingRoot = join(sandboxRoot, 'sharing-root');
+        const separateRoot = join(sandboxRoot, 'separate-root');
+        for (const eachRoot of [installRoot, sharingRoot, separateRoot]) mkdirSync(eachRoot, { recursive: true });
+        const settingsPath = join(installRoot, 'settings.json');
+        writeFileSync(settingsPath, '{}\n');
+        writeFileSync(join(separateRoot, 'settings.json'), '{}\n');
+        try {
+            symlinkSync(settingsPath, join(sharingRoot, 'settings.json'), 'file');
+        } catch (linkError) {
+            t.skip(`this host cannot create a file symlink (${linkError.code})`);
+            return;
+        }
+        const hooksConfig = {
+            hooks: {
+                SessionStart: [{
+                    matcher: '',
+                    hooks: [{ type: 'command', command: 'python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/start.py' }],
+                }],
+            },
+        };
+        const forwardSlashed = rootPath => rootPath.replace(/\\/g, '/');
+        const sharingCommand = `python3 "${forwardSlashed(sharingRoot)}/hooks/session/start.py"`;
+        const separateCommand = `python3 "${forwardSlashed(separateRoot)}/hooks/session/start.py"`;
+        const settings = {
+            hooks: {
+                SessionStart: [{
+                    matcher: '',
+                    hooks: [
+                        { type: 'command', command: sharingCommand },
+                        { type: 'command', command: separateCommand },
+                    ],
+                }],
+            },
+        };
+
+        mergeHooksIntoSettings(settings, hooksConfig, forwardSlashed(installRoot), 'python3', settingsPath);
+
+        const allCommands = settings.hooks.SessionStart.flatMap(group => group.hooks.map(hook => hook.command));
+        assert.ok(!allCommands.includes(sharingCommand), 'the sharing root entry is pruned');
+        assert.ok(allCommands.includes(separateCommand), 'the separate root entry stays');
+        assert.equal(
+            allCommands.filter(command => command.includes(`${forwardSlashed(installRoot)}/hooks/session/start.py`)).length,
+            1,
+            'the install root entry is written once',
+        );
+    } finally {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+    }
+});

package/hooks/session/skill_loaded_reminder.py

@@ -1,15 +1,18 @@
 #!/usr/bin/env python3
-"""Hook that keeps poteto-mode loaded in every session, subagent and workflow helper.
+"""Hook that restores poteto-mode after compaction and loads it for helpers.
 
 ::
 
     Agent or Codex spawn_agent, skill not named -> prompt opens with "invoke poteto-mode"
     Workflow script helper starts               -> "invoke poteto-mode now"
-    context compacted mid-run                    -> "invoke poteto-mode again"
-    user turn, skill not loaded since compacting -> "invoke poteto-mode now"
-    user turn, skill already loaded              -> nothing
-
-A session that loaded the skill hears nothing more until a compaction drops it.
+    compact SessionStart, skill invoked before   -> "invoke the skill again"
+    compact SessionStart, no prior invocation
+    or transcript unavailable                    -> nothing
+    user turn, skill invoked then compacted      -> "invoke poteto-mode now"
+    user turn, skill loaded, never invoked,
+    or transcript unavailable                    -> nothing
+
+A session that invoked the skill hears nothing more until a compaction drops it.
 The hook prints its output and stops.
 """
 
@@ -116,66 +119,92 @@ def _is_loaded_after(all_entry_fields: dict[str, object], was_loaded: bool) -> b
     return was_loaded or _invokes_poteto_mode(all_entry_fields)
 
 
-def is_poteto_mode_loaded(all_transcript_lines: Iterable[str]) -> bool:
-    """Return True when the transcript invoked the skill after its last compaction.
+def poteto_mode_status(all_transcript_lines: Iterable[str]) -> tuple[bool, bool]:
+    """Report whether the skill was invoked and whether it remains loaded.
 
     ::
 
-        Skill(poteto-mode) ... Read ... Edit               -> True
-        /poteto-mode typed as a command ... Read           -> True
-        Skill(poteto-mode) ... compact_boundary ... Read   -> False
-        Read ... Edit                                             -> False
+        Skill(poteto-mode) ... Read                   -> (True, True)
+        /poteto-mode ... compact_boundary             -> (True, False)
+        Skill(poteto-mode) ... compact_boundary ... Skill(poteto-mode)
+                                                      -> (True, True)
+        Read ... Edit                                 -> (False, False)
 
     Only lines naming the skill or a compaction are parsed, so a long transcript
     reads fast.
 
     Args:
         all_transcript_lines: The session transcript, one JSON entry per line.
+
+    Returns:
+        Whether the skill was invoked at any point and whether it is loaded now.
     """
+    was_invoked = False
     is_loaded = False
     for each_line in all_transcript_lines:
         all_entry_fields = _marker_entry(each_line)
         if all_entry_fields is not None:
             is_loaded = _is_loaded_after(all_entry_fields, is_loaded)
-    return is_loaded
+            was_invoked = was_invoked or is_loaded
+    return was_invoked, is_loaded
+
 
+def is_poteto_mode_loaded(all_transcript_lines: Iterable[str]) -> bool:
+    """Return whether the transcript invoked the skill after its last compaction.
+
+    Args:
+        all_transcript_lines: The session transcript, one JSON entry per line.
 
-def _is_loaded_in_transcript(transcript_path: object) -> bool:
+    Returns:
+        Whether the skill is loaded now.
+    """
+    return poteto_mode_status(all_transcript_lines)[1]
+
+
+def _status_in_transcript(transcript_path: object) -> tuple[bool, bool]:
     if not isinstance(transcript_path, str):
-        return False
+        return False, False
     try:
         with open(
             transcript_path, encoding=UTF8_ENCODING, errors=DECODE_ERRORS_POLICY
         ) as transcript:
-            return is_poteto_mode_loaded(transcript)
+            return poteto_mode_status(transcript)
     except OSError:
-        return False
+        return False, False
 
 
 def reminder_for(all_hook_fields: dict[str, object]) -> str | None:
-    """Return the reminder a session event carries, or None when the skill is in view.
+    """Return a reminder only for helpers or sessions that need the skill restored.
 
     ::
 
-        SessionStart, source compact                     -> COMPACTION_REMINDER
+        SessionStart, compact, skill invoked before      -> COMPACTION_REMINDER
+        SessionStart, compact, no prior invocation
+        or transcript unavailable                        -> None
         SubagentStart, workflow-subagent                 -> NOT_LOADED_REMINDER
-        UserPromptSubmit, transcript lacks the skill     -> NOT_LOADED_REMINDER
-        UserPromptSubmit, transcript loaded the skill    -> None
+        UserPromptSubmit, skill invoked then compacted   -> NOT_LOADED_REMINDER
+        UserPromptSubmit, skill loaded, never invoked,
+        or transcript unavailable                        -> None
 
     Args:
         all_hook_fields: The parsed hook input.
+
+    Returns:
+        The event's reminder, or None when no reminder is needed.
     """
     event_name = all_hook_fields.get("hook_event_name")
     if event_name == SESSION_START_EVENT_NAME:
-        return COMPACTION_REMINDER if all_hook_fields.get("source") == COMPACTION_SOURCE else None
+        if all_hook_fields.get("source") != COMPACTION_SOURCE:
+            return None
+        was_invoked, _ = _status_in_transcript(all_hook_fields.get("transcript_path"))
+        return COMPACTION_REMINDER if was_invoked else None
     if event_name == SUBAGENT_START_EVENT_NAME:
         is_workflow_helper = all_hook_fields.get("agent_type") == WORKFLOW_SUBAGENT_TYPE
         return NOT_LOADED_REMINDER if is_workflow_helper else None
     if event_name != USER_PROMPT_SUBMIT_EVENT_NAME:
         return None
-    if _is_loaded_in_transcript(all_hook_fields.get("transcript_path")):
-        return None
-    return NOT_LOADED_REMINDER
+    was_invoked, is_loaded = _status_in_transcript(all_hook_fields.get("transcript_path"))
+    return NOT_LOADED_REMINDER if was_invoked and not is_loaded else None
 
 
 def _is_subagent_spawn(all_hook_fields: dict[str, object]) -> bool:

package/hooks/session/test_skill_loaded_reminder.py

@@ -1,4 +1,4 @@
-"""Tests for skill_loaded_reminder. Checks every fresh context gets poteto-mode, and loaded ones hear nothing."""
+"""Tests for skill_loaded_reminder. Checks restoration after compaction and helper prompts."""
 
 import json
 import sys
@@ -167,14 +167,25 @@ class TestCodexSpawn:
 
     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")
-            )
+            _run_main(_agent_call({"message": "$poteto-mode\n\nFix it."}, tool_name="spawn_agent"))
             == ""
         )
 
 
 class TestIsPotetoModeLoaded:
+    def test_status_without_a_skill_call_reports_no_invocation_or_load(self) -> None:
+        assert reminder.poteto_mode_status(iter([READ_CALL_LINE])) == (False, False)
+
+    def test_status_keeps_invocation_history_after_compaction(self) -> None:
+        assert reminder.poteto_mode_status(
+            iter([SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, READ_CALL_LINE])
+        ) == (True, False)
+
+    def test_status_reports_the_skill_loaded_again_after_compaction(self) -> None:
+        assert reminder.poteto_mode_status(
+            iter([SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, SKILL_CALL_LINE])
+        ) == (True, True)
+
     def test_a_skill_call_loads_it(self) -> None:
         assert reminder.is_poteto_mode_loaded([READ_CALL_LINE, SKILL_CALL_LINE, READ_CALL_LINE])
 
@@ -210,35 +221,106 @@ class TestIsPotetoModeLoaded:
 
 
 class TestReminderFor:
-    def test_a_user_turn_in_a_session_that_never_loaded_the_skill_gets_the_reminder(
+    def test_a_user_turn_in_a_session_that_never_loaded_the_skill_prints_nothing(
         self, tmp_path: Path
     ) -> None:
         transcript_path = _write_transcript(tmp_path, [READ_CALL_LINE])
+        assert _run_main(_user_turn(transcript_path)) == ""
+
+    def test_a_user_turn_after_the_skill_and_compaction_gets_the_reminder(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(
+            tmp_path, [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, READ_CALL_LINE]
+        )
         emitted = json.loads(_run_main(_user_turn(transcript_path)))
         hook_output = emitted["hookSpecificOutput"]
         assert hook_output["hookEventName"] == "UserPromptSubmit"
         assert hook_output["additionalContext"] == NOT_LOADED_REMINDER
         assert "poteto-mode" in NOT_LOADED_REMINDER
 
+    def test_a_user_turn_after_the_skill_is_reloaded_prints_nothing(self, tmp_path: Path) -> None:
+        transcript_path = _write_transcript(
+            tmp_path, [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE, SKILL_CALL_LINE]
+        )
+        assert _run_main(_user_turn(transcript_path)) == ""
+
     def test_a_user_turn_in_a_session_that_loaded_the_skill_prints_nothing(
         self, tmp_path: Path
     ) -> None:
         transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, READ_CALL_LINE])
         assert _run_main(_user_turn(transcript_path)) == ""
 
-    def test_a_user_turn_with_no_transcript_yet_gets_the_reminder(self, tmp_path: Path) -> None:
-        assert (
-            reminder.reminder_for(_user_turn(tmp_path / "not-written-yet.jsonl"))
-            == NOT_LOADED_REMINDER
-        )
+    def test_a_user_turn_with_no_transcript_yet_prints_nothing(self, tmp_path: Path) -> None:
+        assert _run_main(_user_turn(tmp_path / "not-written-yet.jsonl")) == ""
 
-    def test_session_start_after_compaction_tells_the_session_to_invoke_it_again(self) -> None:
-        emitted = json.loads(_run_main({"hook_event_name": "SessionStart", "source": "compact"}))
+    def test_session_start_after_compaction_tells_a_prior_user_to_invoke_it_again(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, READ_CALL_LINE])
+        emitted = json.loads(
+            _run_main(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(transcript_path),
+                }
+            )
+        )
         hook_output = emitted["hookSpecificOutput"]
         assert hook_output["hookEventName"] == "SessionStart"
         assert hook_output["additionalContext"] == COMPACTION_REMINDER
         assert "poteto-mode" in COMPACTION_REMINDER
 
+    def test_session_start_after_a_written_boundary_reminds_a_prior_user(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [SKILL_CALL_LINE, COMPACT_BOUNDARY_LINE])
+        assert (
+            reminder.reminder_for(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(transcript_path),
+                }
+            )
+            == COMPACTION_REMINDER
+        )
+
+    def test_session_start_after_compaction_without_a_prior_skill_call_prints_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        transcript_path = _write_transcript(tmp_path, [READ_CALL_LINE])
+        assert (
+            _run_main(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(transcript_path),
+                }
+            )
+            == ""
+        )
+
+    def test_session_start_after_compaction_without_a_transcript_path_prints_nothing(
+        self,
+    ) -> None:
+        assert _run_main({"hook_event_name": "SessionStart", "source": "compact"}) == ""
+
+    def test_session_start_after_compaction_with_an_unreadable_transcript_prints_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        assert (
+            _run_main(
+                {
+                    "hook_event_name": "SessionStart",
+                    "source": "compact",
+                    "transcript_path": str(tmp_path / "not-written-yet.jsonl"),
+                }
+            )
+            == ""
+        )
+
     def test_a_resumed_session_keeps_its_context_and_prints_nothing(self) -> None:
         assert _run_main({"hook_event_name": "SessionStart", "source": "resume"}) == ""
 

package/package.json

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