@codename_inc/spectre 3.7.0

package/plugins/spectre/skills/spectre-tdd/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: spectre-tdd
+description: "Load this skill when executing TDD (Test-Driven Development) methodology. Use when implementing features via strict RED-GREEN-REFACTOR cycles, or when a prompt instructs execution via TDD."
+---
+
+# TDD: Test-Driven Development Methodology
+
+Execute tasks using strict TDD (RED → GREEN → REFACTOR). Outcome: Tasks completed with Happy/Failure tests passing, minimal code shipped.
+
+## Iron Law
+
+```
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+Wrote code before the test? **Delete it. Start over.** Don't keep it as "reference." Don't "adapt" it. Delete means delete. Implement fresh from tests.
+
+## Rules
+
+- **2 tests per Test Opportunity (TO)**: 1 Happy path, 1 Failure path — then stop
+- **Scoped execution**: Never run repo-wide tests; use `--testPathPattern`, `--findRelatedTests`, or per-file lint
+- **YAGNI**: No abstractions unless test forces it or ≥2 call sites exist
+- **Anti-flake**: Use fake timers, stubs, seeded RNG
+
+---
+
+## Step 1 - Generate TDD TODO List
+
+- **Action** — ParseTaskList: Extract tasks from ARGUMENTS or thread context
+  - **If** no clear tasks → stop and ask for guidance
+- **Action** — IdentifyTestOpportunities: Derive TOs (smallest behavior unit: function, route, bug fix, acceptance criterion)
+- **Action** — TransformToTDD: Convert each TO to cycle using TodoWrite:
+  - `RED: Happy — {test}` → `RED: Failure — {test}` → `GREEN: Minimal impl` → `REFACTOR: Tidy` → `COMMIT`
+- **Action** — VerifyScope: Confirm TODO contains ONLY assigned tasks
+
+## Step 2 - RED Phase: Write Failing Tests
+
+- **Action** — WriteHappyTest: Write first failing test (happy path)
+  - Execute only this test/file, not entire suite
+- **Action** — WriteFailureTest: Write second failing test (primary failure mode)
+- **Action** — VerifyRed: **MANDATORY** — Confirm each test:
+  - Fails (not errors)
+  - Fails for expected reason (feature missing, not typo)
+  - **If** passes → you're testing existing behavior; fix test
+
+## Step 3 - GREEN Phase: Minimal Implementation
+
+- **Action** — ImplementMinimal: Write least code to pass tests
+  - No extra branches, params, or dependencies unless test forces them
+- **Action** — VerifyGreen: **MANDATORY** — Run tests (narrowest scope)
+  - **If** fail → fix code, not test
+  - Remove any speculative code not forced by tests
+
+## Step 4 - REFACTOR Phase: Clean Code
+
+- **Action** — RefactorSafely: Improve only if duplication ≥3 OR readability materially improves
+  - Keep tests green; **If** tests fail → revert
+- **Action** — HandleLintFailures: Apply in order until clear:
+  1. Guard clauses, split compound expressions
+  2. Extract tiny private helpers (same file)
+  3. Hoist literals to file constants
+  4. Split into orchestrator + helpers
+  5. Only if still failing: same-directory helper module
+
+## Step 5 - Loop or Complete
+
+- **If** more TOs → return to Step 2
+- **Else** → proceed to Step 6
+
+## Step 6 - Commit & Report
+
+- **Action** — CommitCode: Conventional format (`feat({task}): description`)
+- **Action** — GenerateReport:
+  - **Summary**: Tasks completed, test status (✅ Happy ✅ Failure), files modified
+  - **Artifacts**: Test helpers, mocks, fixtures created
+  - **API Surface**: New/modified exports with signatures
+  - **Patterns**: Code/testing patterns to follow
+  - **Deferred**: Coverage gaps for follow-up
+
+---
+
+## Red Flags — STOP and Restart
+
+If any of these occur, delete code and start over with TDD:
+
+| Red Flag | Why It's Wrong |
+|----------|----------------|
+| Code written before test | Violates Iron Law |
+| Test passes immediately | Testing existing behavior, not new |
+| Can't explain why test failed | Don't understand what you're testing |
+| "Just this once" thinking | Rationalization — TDD has no exceptions |
+| Keeping code "as reference" | You'll adapt it; that's tests-after |
+
+## When Stuck
+
+| Problem | Solution |
+|---------|----------|
+| Don't know how to test | Write wished-for API first, then assert on it |
+| Test too complicated | Design too complicated — simplify interface |
+| Must mock everything | Code too coupled — use dependency injection |
+| Test setup huge | Extract helpers; still complex? Simplify design |
+
+## Pre-Completion Checklist
+
+Before marking complete, verify:
+- [ ] Every new function has a test
+- [ ] Watched each test fail before implementing
+- [ ] Each failure was for expected reason
+- [ ] Wrote minimal code to pass
+- [ ] All tests pass, output clean
+- [ ] Mocks used only when unavoidable

package/src/config.test.js

@@ -0,0 +1,134 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+function makeProject() {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'spectre-codex-test-'));
+  execFileSync('git', ['init', '-b', 'main'], { cwd: tmp, stdio: 'ignore' });
+  fs.mkdirSync(path.join(tmp, 'docs', 'tasks', 'main', 'session_logs'), { recursive: true });
+  fs.mkdirSync(path.join(tmp, '.agents', 'skills', 'feature-auth'), { recursive: true });
+  fs.mkdirSync(path.join(tmp, '.agents', 'skills', 'spectre-recall', 'references'), { recursive: true });
+  fs.writeFileSync(
+    path.join(tmp, 'docs', 'tasks', 'main', 'session_logs', '2026-03-09-100000_handoff.json'),
+    JSON.stringify({
+      version: '1.1',
+      timestamp: '2026-03-09-100000',
+      branch_name: 'main',
+      task_name: 'codex-port-migration',
+      progress_update: {
+        goal: 'Ship official SessionStart migration',
+        summary: 'Switched Codex continuity to a managed AGENTS.override.md block with a SessionStart status line.',
+        accomplished: ['Updated hook generation', 'Cleaned up legacy bridge files'],
+        now: 'Wiring tests for the new SessionStart payload',
+        next_steps: ['Update docs', 'Run the full test suite'],
+        confidence: 'high',
+        constraints: ['Hook output must stay JSON'],
+        decisions: ['Use a managed AGENTS.override.md block as the continuity channel'],
+        blockers: [],
+        open_questions: ['Whether to show systemMessage in the UI'],
+        risks: ['Codex hook schema is still experimental']
+      },
+      working_set: {
+        key_files: ['src/lib/install.js', 'src/lib/project.js'],
+        active_ids: ['bd-123'],
+        recent_commands: ['npm test']
+      },
+      context: {
+        wip_state: 'uncommitted',
+        last_commit: 'abc1234'
+      }
+    }, null, 2)
+  );
+  fs.writeFileSync(
+    path.join(tmp, '.agents', 'skills', 'feature-auth', 'SKILL.md'),
+    [
+      '---',
+      'name: feature-auth',
+      'description: Use when modifying auth flows.',
+      '---',
+      '',
+      '# Auth Knowledge',
+      '',
+      'The auth system uses token rotation.'
+    ].join('\n')
+  );
+  fs.writeFileSync(
+    path.join(tmp, '.agents', 'skills', 'spectre-recall', 'references', 'registry.toon'),
+    [
+      '# SPECTRE Knowledge Registry',
+      '# Format: skill-name|category|triggers|description',
+      '',
+      'feature-auth|feature|auth, login|Use when modifying auth flows'
+    ].join('\n')
+  );
+  return tmp;
+}
+
+test('buildSessionStartOutput returns official SessionStart payload from the latest handoff', async () => {
+  const tmp = makeProject();
+  const { buildSessionStartOutput } = await import('./lib/project.js');
+  const output = buildSessionStartOutput(tmp, { source: 'resume' });
+  const overridePath = path.join(tmp, 'AGENTS.override.md');
+
+  assert.ok(output);
+  assert.equal(output.hookSpecificOutput.hookEventName, 'SessionStart');
+  assert.equal(output.systemMessage, '🟢 👻 SPECTRE active | injected docs/tasks/main/session_logs/2026-03-09-100000_handoff.json | 👻 spectre: 1 knowledge skills available');
+  assert.deepEqual(output.hookSpecificOutput, { hookEventName: 'SessionStart' });
+
+  assert.ok(fs.existsSync(overridePath));
+  const overrideContent = fs.readFileSync(overridePath, 'utf8');
+  assert.match(overrideContent, /<!-- spectre-session:start -->/);
+  assert.match(overrideContent, /## SPECTRE Session Context/);
+  assert.match(overrideContent, /official SessionStart migration/);
+  assert.match(overrideContent, /Wiring tests for the new SessionStart payload/);
+  assert.match(overrideContent, /### Spectre Notes/);
+  assert.match(overrideContent, /\*\*SessionStart Source\*\*: resume/);
+  assert.match(overrideContent, /docs\/tasks\/main\/session_logs\/2026-03-09-100000_handoff\.json/);
+  assert.match(overrideContent, /<!-- spectre-session:end -->/);
+  assert.match(overrideContent, /<!-- spectre-knowledge:start -->/);
+  assert.match(overrideContent, /## SPECTRE Knowledge Context/);
+  assert.match(overrideContent, /If ANY entry's triggers or description match your current task, you MUST load the skill FIRST/);
+  assert.match(overrideContent, /feature-auth\|feature\|auth, login\|Use when modifying auth flows/);
+  assert.match(overrideContent, /<!-- spectre-knowledge:end -->/);
+  assert.ok(fs.existsSync(path.join(tmp, '.agents', 'skills', 'spectre-recall', 'SKILL.md')));
+});
+
+test('buildSessionStartOutput keeps knowledge active when no handoff exists and removes only the session block', async () => {
+  const tmp = makeProject();
+  fs.rmSync(path.join(tmp, '.agents'), { recursive: true, force: true });
+  fs.writeFileSync(
+    path.join(tmp, 'AGENTS.override.md'),
+    [
+      'User content before.',
+      '',
+      '<!-- spectre-session:start -->',
+      'old spectre content',
+      '<!-- spectre-session:end -->',
+      '',
+      '<!-- spectre-knowledge:start -->',
+      'old knowledge content',
+      '<!-- spectre-knowledge:end -->',
+      '',
+      'User content after.'
+    ].join('\n')
+  );
+  const activePath = path.join(tmp, 'docs', 'tasks', 'main', 'session_logs', '2026-03-09-100000_handoff.json');
+  const archiveDir = path.join(tmp, 'docs', 'tasks', 'main', 'session_logs', 'archive');
+  fs.mkdirSync(archiveDir, { recursive: true });
+  fs.renameSync(activePath, path.join(archiveDir, '2026-03-09-100000_handoff.json'));
+
+  const { buildSessionStartOutput } = await import('./lib/project.js');
+  const output = buildSessionStartOutput(tmp, { source: 'clear' });
+  assert.ok(output);
+  assert.equal(output.systemMessage, '🟢 👻 SPECTRE active | 👻 spectre: ready — capture knowledge with spectre-learn');
+  const overrideContent = fs.readFileSync(path.join(tmp, 'AGENTS.override.md'), 'utf8');
+  assert.match(overrideContent, /User content before\./);
+  assert.match(overrideContent, /User content after\./);
+  assert.doesNotMatch(overrideContent, /spectre-session:start/);
+  assert.match(overrideContent, /spectre-knowledge:start/);
+  assert.match(overrideContent, /No knowledge has been captured for this project yet/);
+  assert.match(overrideContent, /use `spectre-learn` after completing significant work/);
+});

package/src/install.test.js

@@ -0,0 +1,273 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+function makeProject() {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'spectre-codex-install-'));
+  execFileSync('git', ['init', '-b', 'main'], { cwd: tmp, stdio: 'ignore' });
+  fs.mkdirSync(path.join(tmp, 'docs', 'tasks', 'main', 'session_logs'), { recursive: true });
+  fs.writeFileSync(
+    path.join(tmp, 'docs', 'tasks', 'main', 'session_logs', '2026-03-09-100000_handoff.json'),
+    JSON.stringify({
+      branch_name: 'main',
+      progress_update: {
+        goal: 'Port Spectre to Codex',
+        summary: 'Subagents and workflow skills wired.',
+        now: 'Verifying installer',
+        next_steps: ['Run tests'],
+        constraints: ['Hooks hidden injection remains unverified']
+      },
+      working_set: {
+        key_files: ['src/lib/install.js']
+      }
+    }, null, 2)
+  );
+  return tmp;
+}
+
+test('project install writes workflow skills, agent config, and official SessionStart continuity', { concurrency: false }, async () => {
+  const projectDir = makeProject();
+  const previousCodexHome = process.env.CODEX_HOME;
+  delete process.env.CODEX_HOME;
+
+  try {
+    const { main } = await import('./main.js');
+    await main(['install', 'codex', '--scope', 'project', '--project-dir', projectDir]);
+
+    const codeHome = path.join(projectDir, '.codex');
+    const scopeSkillPath = path.join(codeHome, 'skills', 'spectre-scope', 'SKILL.md');
+    assert.ok(fs.existsSync(scopeSkillPath));
+    assert.match(fs.readFileSync(scopeSkillPath, 'utf8'), /Treat the current user request as the input arguments for this workflow/);
+    assert.match(fs.readFileSync(scopeSkillPath, 'utf8'), /This is the Codex skill replacement for the deprecated custom prompt \/spectre:scope/);
+
+    const applySkillPath = path.join(codeHome, 'skills', 'spectre-apply', 'SKILL.md');
+    assert.ok(fs.existsSync(applySkillPath));
+    assert.match(fs.readFileSync(applySkillPath, 'utf8'), /If ANY entry's triggers or description match your current task, you MUST load the skill FIRST/);
+
+    const learnSkillPath = path.join(codeHome, 'skills', 'spectre-learn', 'SKILL.md');
+    assert.ok(fs.existsSync(learnSkillPath));
+    assert.match(fs.readFileSync(learnSkillPath, 'utf8'), /### 13\. Register the Learning/);
+    assert.match(fs.readFileSync(learnSkillPath, 'utf8'), /\.agents\/skills\/spectre-recall\/references\/registry\.toon/);
+
+    const agentPath = path.join(codeHome, 'spectre', 'agents', 'dev.toml');
+    assert.ok(fs.existsSync(agentPath));
+    const agentConfig = fs.readFileSync(agentPath, 'utf8');
+    assert.match(agentConfig, /name = "dev"/);
+    assert.match(agentConfig, /description = /);
+    assert.match(agentConfig, /developer_instructions = \"\"\"/);
+    assert.doesNotMatch(agentConfig, /base_instructions = /);
+
+    const config = fs.readFileSync(path.join(codeHome, 'config.toml'), 'utf8');
+    assert.match(config, /suppress_unstable_features_warning = true/);
+    assert.match(config, /\[agents\.spectre_dev\]/);
+    assert.match(config, /codex_hooks = true/);
+    assert.match(config, /multi_agent = true/);
+    assert.doesNotMatch(config, /session_start = /);
+    assert.doesNotMatch(config, /pre_session_start/);
+    assert.match(config, /\[\[skills\.config\]\]/);
+    assert.match(config, /path = ".*\.agents\/skills\/spectre-recall\/SKILL\.md"/);
+
+    const hooksConfig = JSON.parse(fs.readFileSync(path.join(codeHome, 'hooks.json'), 'utf8'));
+    assert.ok(Array.isArray(hooksConfig.hooks.SessionStart));
+    assert.equal(hooksConfig.hooks.SessionStart.length, 1);
+    assert.deepEqual(hooksConfig.hooks.SessionStart[0].hooks, [
+      {
+        type: 'command',
+        command: `node '${path.join(codeHome, 'spectre', 'hooks', 'session-start.mjs')}'`,
+        statusMessage: 'Spectre: loading session context'
+      }
+    ]);
+    assert.ok(fs.existsSync(path.join(codeHome, 'spectre', 'tools', 'sync-session-override.mjs')));
+    assert.ok(fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-recall', 'SKILL.md')));
+    assert.ok(fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-recall', 'references', 'registry.toon')));
+
+    const manifest = JSON.parse(fs.readFileSync(path.join(projectDir, '.spectre', 'manifest.json'), 'utf8'));
+    assert.equal(manifest.codexIntegration.hiddenContextInjection, 'agents_override_managed_block');
+    assert.equal(manifest.codexIntegration.fallback, 'none');
+
+    assert.ok(!fs.existsSync(path.join(projectDir, 'AGENTS.md')));
+    assert.ok(!fs.existsSync(path.join(projectDir, 'AGENTS.override.md')));
+    assert.ok(!fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-session')));
+    assert.ok(!fs.existsSync(path.join(projectDir, '.spectre', 'bin', 'codex')));
+    assert.ok(!fs.existsSync(path.join(codeHome, 'prompts', 'spectre:scope.md')));
+    execFileSync('codex', ['--version'], {
+      env: {
+        ...process.env,
+        CODEX_HOME: codeHome
+      },
+      stdio: 'ignore'
+    });
+  } finally {
+    if (previousCodexHome == null) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+  }
+});
+
+test('project install removes legacy bridge artifacts while preserving non-managed AGENTS content', { concurrency: false }, async () => {
+  const projectDir = makeProject();
+  fs.writeFileSync(
+    path.join(projectDir, 'AGENTS.md'),
+    [
+      'Project-specific instructions.',
+      '',
+      '<!-- spectre-codex:start -->',
+      'Read `AGENTS.override.md` before doing work in this repository.',
+      '<!-- spectre-codex:end -->'
+    ].join('\n')
+  );
+  fs.writeFileSync(
+    path.join(projectDir, 'AGENTS.override.md'),
+    [
+      'User-owned override content.',
+      '',
+      '<!-- spectre-session:start -->',
+      'legacy session context',
+      '<!-- spectre-session:end -->',
+      '',
+      '<!-- spectre-knowledge:start -->',
+      'legacy knowledge context',
+      '<!-- spectre-knowledge:end -->'
+    ].join('\n')
+  );
+  fs.mkdirSync(path.join(projectDir, '.agents', 'skills', 'spectre-session'), { recursive: true });
+  fs.writeFileSync(path.join(projectDir, '.agents', 'skills', 'spectre-session', 'SKILL.md'), 'legacy session skill\n');
+  fs.mkdirSync(path.join(projectDir, '.spectre', 'bin'), { recursive: true });
+  fs.writeFileSync(path.join(projectDir, '.spectre', 'bin', 'codex'), '#!/bin/sh\n');
+
+  const previousCodexHome = process.env.CODEX_HOME;
+  delete process.env.CODEX_HOME;
+
+  try {
+    const { main } = await import('./main.js');
+    await main(['install', 'codex', '--scope', 'project', '--project-dir', projectDir]);
+
+    const agentsContent = fs.readFileSync(path.join(projectDir, 'AGENTS.md'), 'utf8');
+    assert.match(agentsContent, /Project-specific instructions\./);
+    assert.doesNotMatch(agentsContent, /spectre-codex:start/);
+    const overrideContent = fs.readFileSync(path.join(projectDir, 'AGENTS.override.md'), 'utf8');
+    assert.match(overrideContent, /User-owned override content\./);
+    assert.doesNotMatch(overrideContent, /spectre-session:start/);
+    assert.doesNotMatch(overrideContent, /spectre-knowledge:start/);
+    assert.ok(!fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-session')));
+    assert.ok(!fs.existsSync(path.join(projectDir, '.spectre', 'bin', 'codex')));
+  } finally {
+    if (previousCodexHome == null) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+  }
+});
+
+test('project install preserves unrelated hooks.json handlers while adding Spectre SessionStart', { concurrency: false }, async () => {
+  const projectDir = makeProject();
+  const codeHome = path.join(projectDir, '.codex');
+  fs.mkdirSync(codeHome, { recursive: true });
+  fs.writeFileSync(
+    path.join(codeHome, 'hooks.json'),
+    JSON.stringify({
+      hooks: {
+        Stop: [
+          {
+            matcher: '*',
+            hooks: [
+              {
+                type: 'command',
+                command: 'echo existing-stop-hook'
+              }
+            ]
+          }
+        ]
+      }
+    }, null, 2)
+  );
+
+  const previousCodexHome = process.env.CODEX_HOME;
+  delete process.env.CODEX_HOME;
+
+  try {
+    const { main } = await import('./main.js');
+    await main(['install', 'codex', '--scope', 'project', '--project-dir', projectDir]);
+
+    const hooksConfig = JSON.parse(fs.readFileSync(path.join(codeHome, 'hooks.json'), 'utf8'));
+    assert.deepEqual(hooksConfig.hooks.Stop, [
+      {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command: 'echo existing-stop-hook'
+          }
+        ]
+      }
+    ]);
+    assert.ok(Array.isArray(hooksConfig.hooks.SessionStart));
+    assert.ok(hooksConfig.hooks.SessionStart.some(group =>
+      Array.isArray(group.hooks) && group.hooks.some(hook => hook.command.includes('spectre/hooks/session-start.mjs'))
+    ));
+  } finally {
+    if (previousCodexHome == null) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+  }
+});
+
+test('project uninstall removes managed workflow skills, agent config, and project skill registrations', { concurrency: false }, async () => {
+  const projectDir = makeProject();
+  fs.writeFileSync(
+    path.join(projectDir, 'AGENTS.override.md'),
+    [
+      'User-owned override content.',
+      '',
+      '<!-- spectre-session:start -->',
+      'legacy session context',
+      '<!-- spectre-session:end -->',
+      '',
+      '<!-- spectre-knowledge:start -->',
+      'legacy knowledge context',
+      '<!-- spectre-knowledge:end -->'
+    ].join('\n')
+  );
+  const previousCodexHome = process.env.CODEX_HOME;
+  delete process.env.CODEX_HOME;
+
+  try {
+    const { main } = await import('./main.js');
+    await main(['install', 'codex', '--scope', 'project', '--project-dir', projectDir]);
+    await main(['uninstall', 'codex', '--scope', 'project', '--project-dir', projectDir]);
+
+    const codeHome = path.join(projectDir, '.codex');
+
+    assert.ok(!fs.existsSync(path.join(codeHome, 'skills', 'spectre-scope')));
+    assert.ok(!fs.existsSync(path.join(codeHome, 'spectre')));
+
+    const config = fs.readFileSync(path.join(codeHome, 'config.toml'), 'utf8');
+    assert.doesNotMatch(config, /\[agents\.spectre_dev\]/);
+    assert.doesNotMatch(config, /\[\[skills\.config\]\][\s\S]*spectre-recall/);
+    assert.doesNotMatch(config, /pre_session_start/);
+    assert.doesNotMatch(config, /session_start = /);
+
+    assert.ok(!fs.existsSync(path.join(projectDir, '.spectre', 'manifest.json')));
+    const overrideContent = fs.readFileSync(path.join(projectDir, 'AGENTS.override.md'), 'utf8');
+    assert.match(overrideContent, /User-owned override content\./);
+    assert.doesNotMatch(overrideContent, /spectre-session:start/);
+    assert.doesNotMatch(overrideContent, /spectre-knowledge:start/);
+    assert.ok(!fs.existsSync(path.join(projectDir, '.spectre', 'bin', 'codex')));
+    assert.ok(!fs.existsSync(path.join(codeHome, 'hooks.json')));
+    assert.ok(fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-recall', 'SKILL.md')));
+  } finally {
+    if (previousCodexHome == null) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+  }
+});