claude-dev-env 8.85.0 → 8.85.1

package/bin/codex-skill-load-block.mjs

@@ -3,9 +3,6 @@ import { dirname, join, resolve } from 'node:path';
 
 export const SKILL_LOAD_BLOCK_START = '<!-- claude-dev-env skill load: start -->';
 export const SKILL_LOAD_BLOCK_END = '<!-- claude-dev-env skill load: end -->';
-export const SKILL_LOAD_INSTRUCTION = 'Load the pstack:poteto-mode skill before your first tool call or reply: '
-    + 'open its SKILL.md from your skills list and follow it. This binds every Codex agent, '
-    + 'including a helper started with spawn_agent, whatever its task message says.';
 export const PACKAGE_GUIDANCE_BLOCK_START = '<!-- claude-dev-env package guidance: start -->';
 export const PACKAGE_GUIDANCE_BLOCK_END = '<!-- claude-dev-env package guidance: end -->';
 export const QUESTION_PRESENTATION_BLOCK_START = '<!-- claude-dev-env question presentation: start -->';
@@ -39,17 +36,24 @@ function withBlockReplaced(guidanceText, blockStart, blockEnd, block) {
 }
 
 /**
- * Return the Codex guidance text with the package's skill-load block in it.
+ * Return guidance text with every complete skill-load block removed.
  *
- * Codex starts a spawn_agent helper without running any hook, so the global
- * AGENTS.md is the one channel that reaches every helper. A block already in
- * the text is replaced where it stands; otherwise the block goes first.
+ * When a block is the start of the remaining text, one following blank line is
+ * removed with it. A start marker with no end marker stays.
  */
-export function withSkillLoadBlock(guidanceText) {
-    const block = managedBlock(SKILL_LOAD_BLOCK_START, SKILL_LOAD_INSTRUCTION, SKILL_LOAD_BLOCK_END);
-    const replacedText = withBlockReplaced(guidanceText, SKILL_LOAD_BLOCK_START, SKILL_LOAD_BLOCK_END, block);
-    if (replacedText !== null) return replacedText;
-    return guidanceText ? `${block}\n${guidanceText}` : block;
+export function withoutSkillLoadBlock(guidanceText) {
+    let remainingText = guidanceText;
+    let removedBlockCount = 0;
+    while (remainingText.includes(SKILL_LOAD_BLOCK_START)) {
+        const blockStartsAtTop = remainingText.startsWith(SKILL_LOAD_BLOCK_START);
+        const replacedText = withBlockReplaced(remainingText, SKILL_LOAD_BLOCK_START, SKILL_LOAD_BLOCK_END, '');
+        if (replacedText === null || replacedText === remainingText) break;
+        removedBlockCount += 1;
+        remainingText = blockStartsAtTop && replacedText.startsWith('\n')
+            ? replacedText.slice(1)
+            : replacedText;
+    }
+    return removedBlockCount === 0 ? guidanceText : remainingText;
 }
 
 function withPackageGuidanceBlock(guidanceText, packageGuidanceText) {
@@ -84,7 +88,7 @@ function writeCodexGuidanceFile(codexHome, allPackageGuidancePaths, transformGui
     const isPackageGuidanceLink = agentsEntry?.isSymbolicLink() ?? false;
     if (isPackageGuidanceLink && !linksToPackageGuidance(agentsPath, allPackageGuidancePaths)) return null;
     const currentText = agentsEntry && !isPackageGuidanceLink ? readFileSync(agentsPath, 'utf8') : '';
-    const updatedText = transformGuidance(currentText);
+    const updatedText = transformGuidance(withoutSkillLoadBlock(currentText));
     if (!isPackageGuidanceLink && updatedText === currentText) return null;
     mkdirSync(codexHome, { recursive: true });
     if (isPackageGuidanceLink) unlinkSync(agentsPath);
@@ -93,29 +97,24 @@ function writeCodexGuidanceFile(codexHome, allPackageGuidancePaths, transformGui
 }
 
 /**
- * Keep CODEX_HOME/AGENTS.md carrying the skill-load block and the package guidance.
- *
- * The skill-load block goes first, and the package-guidance block holds the
- * current guidance text. A symbolic link that points at the package guidance
- * (the shared agents-home copy, or the retired copy under the Claude home) is
- * replaced by a regular file holding both blocks, so Codex keeps both after
- * the package moves its guidance. A link to any other file is left alone.
+ * Remove a skill-load block and write package guidance into CODEX_HOME/AGENTS.md.
  *
- * Returns the file path when the file changed, and null otherwise.
+ * Link handling matches writeCodexPackageGuidance. Returns the file path when
+ * the file changed, and null otherwise.
  */
 export function writeCodexAgentsGuidance(codexHome, packageGuidanceText, allPackageGuidancePaths) {
-    return writeCodexGuidanceFile(
-        codexHome,
-        allPackageGuidancePaths,
-        currentText => withPackageGuidanceBlock(withSkillLoadBlock(currentText), packageGuidanceText),
-    );
+    return writeCodexPackageGuidance(codexHome, packageGuidanceText, allPackageGuidancePaths);
 }
 
 /**
  * Keep CODEX_HOME/AGENTS.md carrying the package guidance, with no skill-load block.
  *
- * Links follow the same rule as writeCodexAgentsGuidance. Returns the file
- * path when the file changed, and null otherwise.
+ * An existing skill-load block is removed. A symbolic link that points at the
+ * package guidance, the shared agents-home copy or the retired copy under the
+ * Claude home, is replaced by a regular file. A link to any other file is left
+ * alone.
+ *
+ * Returns the file path when the file changed, and null otherwise.
  */
 export function writeCodexPackageGuidance(codexHome, packageGuidanceText, allPackageGuidancePaths) {
     return writeCodexGuidanceFile(

package/bin/codex-skill-load-block.test.mjs

@@ -10,11 +10,10 @@ import {
     QUESTION_PRESENTATION_BLOCK_START,
     SKILL_LOAD_BLOCK_END,
     SKILL_LOAD_BLOCK_START,
-    SKILL_LOAD_INSTRUCTION,
     removeCodexDeepenGuidance,
     removeCodexPackageGuidance,
     removeCodexQuestionGuidance,
-    withSkillLoadBlock,
+    withoutSkillLoadBlock,
     DEEPEN_GUIDANCE_BLOCK_END,
     DEEPEN_GUIDANCE_BLOCK_START,
     DEEPEN_GUIDANCE_TEXT,
@@ -24,7 +23,10 @@ import {
     writeCodexQuestionGuidance,
 } from './codex-skill-load-block.mjs';
 
-const EXPECTED_BLOCK = `${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n${SKILL_LOAD_BLOCK_END}\n`;
+const STALE_SKILL_LOAD_SENTENCE = 'Load the pstack:poteto-mode skill before your first tool call or reply: '
+    + 'open its SKILL.md from your skills list and follow it. This binds every Codex agent, '
+    + 'including a helper started with spawn_agent, whatever its task message says.';
+const STALE_SKILL_LOAD_BLOCK = `${SKILL_LOAD_BLOCK_START}\n${STALE_SKILL_LOAD_SENTENCE}\n${SKILL_LOAD_BLOCK_END}\n`;
 const PACKAGE_GUIDANCE = 'Status\n\nChanged / proof / blocked.\n';
 const QUESTION_POLICY = '# Present questions clearly\n\nAsk one question.\n';
 
@@ -52,34 +54,44 @@ function writeGuidance(homes) {
     return writeCodexAgentsGuidance(homes.codexHome, PACKAGE_GUIDANCE, homes.allPackageGuidancePaths);
 }
 
-test('the instruction names the skill and binds spawned helpers', () => {
-    assert.match(SKILL_LOAD_INSTRUCTION, /pstack:poteto-mode/);
-    assert.match(SKILL_LOAD_INSTRUCTION, /spawn_agent/);
+test('a complete skill-load block is removed and the lines around it stay', () => {
+    assert.equal(withoutSkillLoadBlock(`Intro\n${STALE_SKILL_LOAD_BLOCK}Outro\n`), 'Intro\nOutro\n');
+    assert.equal(withoutSkillLoadBlock(`${STALE_SKILL_LOAD_BLOCK}\nNotes\n`), 'Notes\n');
+    assert.equal(
+        withoutSkillLoadBlock(`${STALE_SKILL_LOAD_BLOCK}\n${STALE_SKILL_LOAD_BLOCK}\nNotes\n`),
+        'Notes\n',
+    );
+    assert.equal(
+        withoutSkillLoadBlock(`${SKILL_LOAD_BLOCK_START}\nHalf a block\n`),
+        `${SKILL_LOAD_BLOCK_START}\nHalf a block\n`,
+    );
 });
 
-test('a missing Codex guidance file is created holding the skill-load block and the package guidance', (context) => {
+test('a missing Codex guidance file is created holding the package guidance', (context) => {
     const homes = makeHomes(context);
 
     const writtenPath = writeGuidance(homes);
 
     assert.equal(writtenPath, homes.agentsPath);
-    assert.equal(
-        readFileSync(homes.agentsPath, 'utf8'),
-        `${EXPECTED_BLOCK}\n${guidanceBlock(PACKAGE_GUIDANCE)}`,
-    );
+    const rendered = readFileSync(homes.agentsPath, 'utf8');
+    assert.equal(rendered, guidanceBlock(PACKAGE_GUIDANCE));
+    assert.equal(rendered.includes('pstack:poteto-mode'), false);
+    assert.equal(rendered.includes(SKILL_LOAD_BLOCK_START), false);
 });
 
-test('existing guidance keeps every line between the skill-load block and the package guidance', (context) => {
+test('existing guidance keeps its lines and gains the package guidance', (context) => {
     const homes = makeHomes(context);
     mkdirSync(homes.codexHome);
     writeFileSync(homes.agentsPath, '# pstack model configuration\n\nbug-fix: gpt-6-astra\n');
 
     writeGuidance(homes);
 
+    const rendered = readFileSync(homes.agentsPath, 'utf8');
     assert.equal(
-        readFileSync(homes.agentsPath, 'utf8'),
-        `${EXPECTED_BLOCK}\n# pstack model configuration\n\nbug-fix: gpt-6-astra\n\n${guidanceBlock(PACKAGE_GUIDANCE)}`,
+        rendered,
+        `# pstack model configuration\n\nbug-fix: gpt-6-astra\n\n${guidanceBlock(PACKAGE_GUIDANCE)}`,
     );
+    assert.equal(rendered.includes('pstack:poteto-mode'), false);
 });
 
 test('a repeat install leaves the file unchanged and reports no write', (context) => {
@@ -93,20 +105,43 @@ test('a repeat install leaves the file unchanged and reports no write', (context
     assert.equal(readFileSync(homes.agentsPath, 'utf8'), afterFirstInstall);
 });
 
-test('an outdated block is replaced in place and the text around it is kept', () => {
-    const outdated = `Intro\n${SKILL_LOAD_BLOCK_START}\nOld wording\n${SKILL_LOAD_BLOCK_END}\nOutro\n`;
+test('a stale skill-load sentence is removed and question and deepen blocks stay', (context) => {
+    const homes = makeHomes(context);
+    mkdirSync(homes.codexHome);
+    const questionBlock = `${QUESTION_PRESENTATION_BLOCK_START}\n${QUESTION_POLICY}${QUESTION_PRESENTATION_BLOCK_END}\n`;
+    const deepenBlock = `${DEEPEN_GUIDANCE_BLOCK_START}\n${DEEPEN_GUIDANCE_TEXT}\n${DEEPEN_GUIDANCE_BLOCK_END}\n`;
+    writeFileSync(
+        homes.agentsPath,
+        `${STALE_SKILL_LOAD_BLOCK}\n${guidanceBlock('Old guidance\n')}${questionBlock}${deepenBlock}`,
+    );
 
-    assert.equal(withSkillLoadBlock(outdated), `Intro\n${EXPECTED_BLOCK}Outro\n`);
+    writeGuidance(homes);
+
+    const rendered = readFileSync(homes.agentsPath, 'utf8');
+    assert.equal(rendered.includes(STALE_SKILL_LOAD_SENTENCE), false);
+    assert.equal(rendered.includes('pstack:poteto-mode'), false);
+    assert.equal(rendered.includes(SKILL_LOAD_BLOCK_START), false);
+    assert.ok(rendered.includes(guidanceBlock(PACKAGE_GUIDANCE)));
+    assert.ok(rendered.includes(questionBlock));
+    assert.ok(rendered.includes(deepenBlock));
 });
 
-test('a start marker with no end marker gets a fresh block and keeps the stray text', () => {
+test('a start marker with no end marker stays and no skill name is added', (context) => {
+    const homes = makeHomes(context);
     const broken = `${SKILL_LOAD_BLOCK_START}\nHalf a block\n`;
+    mkdirSync(homes.codexHome);
+    writeFileSync(homes.agentsPath, broken);
+
+    writeGuidance(homes);
 
-    assert.equal(withSkillLoadBlock(broken), `${EXPECTED_BLOCK}\n${broken}`);
+    const rendered = readFileSync(homes.agentsPath, 'utf8');
+    assert.ok(rendered.startsWith(broken));
+    assert.equal(rendered.includes('pstack:poteto-mode'), false);
+    assert.ok(rendered.includes(PACKAGE_GUIDANCE_BLOCK_START));
 });
 
 for (const linkName of ['retiredGuidancePath', 'sharedGuidancePath']) {
-    test(`a link to package guidance at ${linkName} becomes a file with both blocks`, (context) => {
+    test(`a link to package guidance at ${linkName} becomes a file with the package block`, (context) => {
         const homes = makeHomes(context);
         mkdirSync(homes.codexHome);
         symlinkSync(homes[linkName], homes.agentsPath);
@@ -115,24 +150,21 @@ for (const linkName of ['retiredGuidancePath', 'sharedGuidancePath']) {
 
         assert.equal(writtenPath, homes.agentsPath);
         assert.equal(lstatSync(homes.agentsPath).isSymbolicLink(), false);
-        assert.equal(
-            readFileSync(homes.agentsPath, 'utf8'),
-            `${EXPECTED_BLOCK}\n${guidanceBlock(PACKAGE_GUIDANCE)}`,
-        );
+        assert.equal(readFileSync(homes.agentsPath, 'utf8'), guidanceBlock(PACKAGE_GUIDANCE));
+        assert.equal(readFileSync(homes.agentsPath, 'utf8').includes('pstack:poteto-mode'), false);
     });
 }
 
-test('a converted file takes the new package guidance on the next install', (context) => {
+test('a converted file takes the new package guidance and drops a stale skill-load block', (context) => {
     const homes = makeHomes(context);
     mkdirSync(homes.codexHome);
-    writeFileSync(homes.agentsPath, `${EXPECTED_BLOCK}\n${guidanceBlock('Old guidance\n')}`);
+    writeFileSync(homes.agentsPath, `${STALE_SKILL_LOAD_BLOCK}\n${guidanceBlock('Old guidance\n')}`);
 
     writeGuidance(homes);
 
-    assert.equal(
-        readFileSync(homes.agentsPath, 'utf8'),
-        `${EXPECTED_BLOCK}\n${guidanceBlock(PACKAGE_GUIDANCE)}`,
-    );
+    const rendered = readFileSync(homes.agentsPath, 'utf8');
+    assert.equal(rendered, guidanceBlock(PACKAGE_GUIDANCE));
+    assert.equal(rendered.includes('pstack:poteto-mode'), false);
 });
 
 test('a link to a file the package does not own is left alone', (context) => {

package/bin/install.mjs

@@ -2927,13 +2927,13 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
                     allUserOwnedPreferencePaths.add(eachPath);
                 }
             }
-            const skillLoadGuidancePath = writeCodexAgentsGuidance(
+            const codexGuidancePath = writeCodexAgentsGuidance(
                 INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
                 packageGuidanceText,
                 allPackageGuidancePaths,
             );
-            if (skillLoadGuidancePath) {
-                console.log(`  \u2713 ${skillLoadGuidancePath} (Codex skill-load line)`);
+            if (codexGuidancePath) {
+                console.log(`  \u2713 ${codexGuidancePath} (Codex package guidance)`);
             }
         }
         printPluginHostOutcomes([PSTACK_PLUGIN_SPEC], pstackPlugin);

package/bin/install.question-presentation.test.mjs

@@ -171,7 +171,7 @@ test('a selected Claude profile receives the source rule and its Codex guidance'
     assert.ok(readFileSync(join(profileDirectory, '.codex', 'AGENTS.md'), 'utf8').includes(readFileSync(policyPath, 'utf8')));
 });
 
-test('a successful pstack install retains its skill block and gains the question block', (context) => {
+test('a successful pstack install omits the retired skill block and gains the question block', (context) => {
     const homeDirectory = makeScratchHome(context);
     const commandPath = join(homeDirectory, process.platform === 'win32' ? 'codex.cmd' : 'codex');
     writeFileSync(
@@ -191,7 +191,7 @@ test('a successful pstack install retains its skill block and gains the question
 
     assert.equal(installation.status, 0, installation.stdout + installation.stderr);
     const guidanceText = readFileSync(join(homeDirectory, '.codex', 'AGENTS.md'), 'utf8');
-    assert.match(guidanceText, /<!-- claude-dev-env skill load: start -->/);
+    assert.doesNotMatch(guidanceText, /<!-- claude-dev-env skill load: start -->/);
     assert.match(guidanceText, /<!-- claude-dev-env question presentation: start -->/);
     assert.ok(guidanceText.includes(readFileSync(policyPath, 'utf8')));
 });
@@ -221,7 +221,7 @@ test('enabling pstack after a pstack-off install preserves question guidance', (
     assert.equal(secondInstallation.status, 0, secondInstallation.stdout + secondInstallation.stderr);
     const updatedGuidance = readFileSync(codexGuidancePath, 'utf8');
     assert.ok(updatedGuidance.includes(firstGuidance));
-    assert.match(updatedGuidance, /<!-- claude-dev-env skill load: start -->/);
+    assert.doesNotMatch(updatedGuidance, /<!-- claude-dev-env skill load: start -->/);
     assert.match(updatedGuidance, /^feature, refactoring: gpt-6-sol$/m);
     assert.match(readFileSync(join(homeDirectory, '.codex', 'pstack-models.md'), 'utf8'), /^session hook: on$/m);
 });

package/bin/install.test.mjs

@@ -57,12 +57,12 @@ import {
 } from './install.mjs';
 import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
 import {
+    DEEPEN_GUIDANCE_BLOCK_START,
     PACKAGE_GUIDANCE_BLOCK_END,
     PACKAGE_GUIDANCE_BLOCK_START,
-    SKILL_LOAD_BLOCK_START,
-    SKILL_LOAD_INSTRUCTION,
     QUESTION_PRESENTATION_BLOCK_START,
-    withSkillLoadBlock,
+    SKILL_LOAD_BLOCK_END,
+    SKILL_LOAD_BLOCK_START,
 } from './codex-skill-load-block.mjs';
 
 
@@ -3124,6 +3124,17 @@ function pstackPluginSandbox(t) {
     };
 }
 
+const STALE_SKILL_LOAD_SENTENCE = 'Load the pstack:poteto-mode skill before your first tool call or reply: '
+    + 'open its SKILL.md from your skills list and follow it. This binds every Codex agent, '
+    + 'including a helper started with spawn_agent, whatever its task message says.';
+
+function assertOmitsSkillLoadSentence(codexGuidance) {
+    assert.equal(codexGuidance.includes(SKILL_LOAD_BLOCK_START), false);
+    assert.equal(codexGuidance.includes(SKILL_LOAD_BLOCK_END), false);
+    assert.equal(codexGuidance.includes('pstack:poteto-mode'), false);
+    assert.equal(codexGuidance.includes(STALE_SKILL_LOAD_SENTENCE), false);
+}
+
 test('a full install adds the pstack marketplace and plugin on both hosts', t => {
     const sandbox = pstackPluginSandbox(t);
 
@@ -3145,9 +3156,10 @@ test('a full install adds the pstack marketplace and plugin on both hosts', t =>
     const sheet = readFileSync(join(codexHome, 'pstack-models.md'), 'utf8');
     const agents = readFileSync(join(codexHome, 'AGENTS.md'), 'utf8');
     assert.match(sheet, /^session hook: on$/m);
+    assert.match(agents, /^# pstack model configuration\n/);
     assert.match(agents, /^feature, refactoring: gpt-6-sol$/m);
     assert.doesNotMatch(agents, /^session hook:/m);
-    assert.ok(agents.startsWith(`${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n`));
+    assertOmitsSkillLoadSentence(agents);
     assert.equal(existsSync(join(sandbox.homeDirectory, '.claude', 'pstack-models.md')), false);
     const manifestPath = join(sandbox.homeDirectory, '.claude', '.claude-dev-env-manifest.json');
     const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
@@ -3159,14 +3171,19 @@ test('a repeat install preserves Codex pstack configuration', t => {
     const sandbox = pstackPluginSandbox(t);
     const codexHome = join(sandbox.homeDirectory, '.codex');
     runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
-    writeFileSync(join(codexHome, 'AGENTS.md'), 'Custom Codex guidance\n');
+    writeFileSync(
+        join(codexHome, 'AGENTS.md'),
+        `${SKILL_LOAD_BLOCK_START}\n${STALE_SKILL_LOAD_SENTENCE}\n${SKILL_LOAD_BLOCK_END}\nCustom Codex guidance\n`,
+    );
     writeFileSync(join(codexHome, 'pstack-models.md'), 'session hook: off\n');
 
     runPstackInstaller(sandbox.homeDirectory, [], sandbox.environment);
 
     const codexGuidance = readFileSync(join(codexHome, 'AGENTS.md'), 'utf8');
-    assert.ok(codexGuidance.startsWith(withSkillLoadBlock('Custom Codex guidance\n')));
+    assert.ok(codexGuidance.startsWith('Custom Codex guidance\n'));
+    assertOmitsSkillLoadSentence(codexGuidance);
     assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+    assert.ok(codexGuidance.includes(DEEPEN_GUIDANCE_BLOCK_START));
     assert.equal(readFileSync(join(codexHome, 'pstack-models.md'), 'utf8'), 'session hook: off\n');
 });
 
@@ -3185,7 +3202,7 @@ test('a Codex guidance link to the retired Claude copy becomes a file Codex can
     );
     assert.equal(lstatSync(codexAgentsPath).isSymbolicLink(), false);
     const codexGuidance = readFileSync(codexAgentsPath, 'utf8');
-    assert.ok(codexGuidance.startsWith(`${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n`));
+    assertOmitsSkillLoadSentence(codexGuidance);
     assert.ok(codexGuidance.includes(packageGuidance));
 });
 
@@ -3248,8 +3265,9 @@ test('a fresh full install writes the package guidance into Codex AGENTS.md', t
 
     const codexGuidance = readFileSync(join(sandbox.homeDirectory, '.codex', 'AGENTS.md'), 'utf8');
     assertHoldsPackageGuidance(codexGuidance);
-    assert.ok(codexGuidance.startsWith(`${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n`));
+    assertOmitsSkillLoadSentence(codexGuidance);
     assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+    assert.ok(codexGuidance.includes(DEEPEN_GUIDANCE_BLOCK_START));
 });
 
 test('--no-pstack writes package and question guidance without the skill-load block', t => {
@@ -3329,9 +3347,10 @@ test('a pstack install after a --no-pstack install seeds the Codex model sheet',
     assert.match(readFileSync(join(codexHome, 'pstack-models.md'), 'utf8'), /^session hook: on$/m);
     const codexGuidance = readFileSync(join(codexHome, 'AGENTS.md'), 'utf8');
     assert.match(codexGuidance, /^feature, refactoring: gpt-6-sol$/m);
-    assert.ok(codexGuidance.startsWith(`${SKILL_LOAD_BLOCK_START}\n${SKILL_LOAD_INSTRUCTION}\n`));
+    assertOmitsSkillLoadSentence(codexGuidance);
     assertHoldsPackageGuidance(codexGuidance);
     assert.ok(codexGuidance.includes(QUESTION_PRESENTATION_BLOCK_START));
+    assert.ok(codexGuidance.includes(DEEPEN_GUIDANCE_BLOCK_START));
 });
 
 const USAGE_WRAPUP_CLAUDE_COMMANDS = Object.freeze([

package/package.json

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