context-mode 1.0.118 → 1.0.120

package/skills/improve-codebase-architecture/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: improve-codebase-architecture
+description: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
+---
+
+# Improve Codebase Architecture
+
+Surface architectural friction and propose **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.
+
+## Glossary
+
+Use these terms exactly in every suggestion. Consistent language is the point — don't drift into "component," "service," "API," or "boundary." Full definitions in [LANGUAGE.md](LANGUAGE.md).
+
+- **Module** — anything with an interface and an implementation (function, class, package, slice).
+- **Interface** — everything a caller must know to use the module: types, invariants, error modes, ordering, config. Not just the type signature.
+- **Implementation** — the code inside.
+- **Depth** — leverage at the interface: a lot of behaviour behind a small interface. **Deep** = high leverage. **Shallow** = interface nearly as complex as the implementation.
+- **Seam** — where an interface lives; a place behaviour can be altered without editing in place. (Use this, not "boundary.")
+- **Adapter** — a concrete thing satisfying an interface at a seam.
+- **Leverage** — what callers get from depth.
+- **Locality** — what maintainers get from depth: change, bugs, knowledge concentrated in one place.
+
+Key principles (see [LANGUAGE.md](LANGUAGE.md) for the full list):
+
+- **Deletion test**: imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep.
+- **The interface is the test surface.**
+- **One adapter = hypothetical seam. Two adapters = real seam.**
+
+This skill is _informed_ by the project's domain model. The domain language gives names to good seams; ADRs record decisions the skill should not re-litigate.
+
+## Process
+
+### 1. Explore
+
+Read the project's domain glossary and any ADRs in the area you're touching first.
+
+Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
+
+- Where does understanding one concept require bouncing between many small modules?
+- Where are modules **shallow** — interface nearly as complex as the implementation?
+- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)?
+- Where do tightly-coupled modules leak across their seams?
+- Which parts of the codebase are untested, or hard to test through their current interface?
+
+Apply the **deletion test** to anything you suspect is shallow: would deleting it concentrate complexity, or just move it? A "yes, concentrates" is the signal you want.
+
+### 2. Present candidates
+
+Present a numbered list of deepening opportunities. For each candidate:
+
+- **Files** — which files/modules are involved
+- **Problem** — why the current architecture is causing friction
+- **Solution** — plain English description of what would change
+- **Benefits** — explained in terms of locality and leverage, and also in how tests would improve
+
+**Use CONTEXT.md vocabulary for the domain, and [LANGUAGE.md](LANGUAGE.md) vocabulary for the architecture.** If `CONTEXT.md` defines "Order," talk about "the Order intake module" — not "the FooBarHandler," and not "the Order service."
+
+**ADR conflicts**: if a candidate contradicts an existing ADR, only surface it when the friction is real enough to warrant revisiting the ADR. Mark it clearly (e.g. _"contradicts ADR-0007 — but worth reopening because…"_). Don't list every theoretical refactor an ADR forbids.
+
+Do NOT propose interfaces yet. Ask the user: "Which of these would you like to explore?"
+
+### 3. Grilling loop
+
+Once the user picks a candidate, drop into a grilling conversation. Walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
+
+Side effects happen inline as decisions crystallize:
+
+- **Naming a deepened module after a concept not in `CONTEXT.md`?** Add the term to `CONTEXT.md` — same discipline as `/grill-with-docs` (see [CONTEXT-FORMAT.md](../grill-with-docs/CONTEXT-FORMAT.md)). Create the file lazily if it doesn't exist.
+- **Sharpening a fuzzy term during the conversation?** Update `CONTEXT.md` right there.
+- **User rejects the candidate with a load-bearing reason?** Offer an ADR, framed as: _"Want me to record this as an ADR so future architecture reviews don't re-suggest it?"_ Only offer when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral reasons ("not worth it right now") and self-evident ones. See [ADR-FORMAT.md](../grill-with-docs/ADR-FORMAT.md).
+- **Want to explore alternative interfaces for the deepened module?** See [INTERFACE-DESIGN.md](INTERFACE-DESIGN.md).
+
+
+---
+
+_Vendored from [mattpocock/skills](https://github.com/mattpocock/skills) @ `b843cb5` — MIT License. See [skills/UPSTREAM-CREDITS.md](../UPSTREAM-CREDITS.md) for refresh instructions._

package/skills/tdd/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: tdd
+description: Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.
+---
+
+# Test-Driven Development
+
+## Philosophy
+
+**Core principle**: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't.
+
+**Good tests** are integration-style: they exercise real code paths through public APIs. They describe _what_ the system does, not _how_ it does it. A good test reads like a specification - "user can checkout with valid cart" tells you exactly what capability exists. These tests survive refactors because they don't care about internal structure.
+
+**Bad tests** are coupled to implementation. They mock internal collaborators, test private methods, or verify through external means (like querying a database directly instead of using the interface). The warning sign: your test breaks when you refactor, but behavior hasn't changed. If you rename an internal function and tests fail, those tests were testing implementation, not behavior.
+
+See [tests.md](tests.md) for examples and [mocking.md](mocking.md) for mocking guidelines.
+
+## Anti-Pattern: Horizontal Slices
+
+**DO NOT write all tests first, then all implementation.** This is "horizontal slicing" - treating RED as "write all tests" and GREEN as "write all code."
+
+This produces **crap tests**:
+
+- Tests written in bulk test _imagined_ behavior, not _actual_ behavior
+- You end up testing the _shape_ of things (data structures, function signatures) rather than user-facing behavior
+- Tests become insensitive to real changes - they pass when behavior breaks, fail when behavior is fine
+- You outrun your headlights, committing to test structure before understanding the implementation
+
+**Correct approach**: Vertical slices via tracer bullets. One test → one implementation → repeat. Each test responds to what you learned from the previous cycle. Because you just wrote the code, you know exactly what behavior matters and how to verify it.
+
+```
+WRONG (horizontal):
+  RED:   test1, test2, test3, test4, test5
+  GREEN: impl1, impl2, impl3, impl4, impl5
+
+RIGHT (vertical):
+  RED→GREEN: test1→impl1
+  RED→GREEN: test2→impl2
+  RED→GREEN: test3→impl3
+  ...
+```
+
+## Workflow
+
+### 1. Planning
+
+When exploring the codebase, use the project's domain glossary so that test names and interface vocabulary match the project's language, and respect ADRs in the area you're touching.
+
+Before writing any code:
+
+- [ ] Confirm with user what interface changes are needed
+- [ ] Confirm with user which behaviors to test (prioritize)
+- [ ] Identify opportunities for [deep modules](deep-modules.md) (small interface, deep implementation)
+- [ ] Design interfaces for [testability](interface-design.md)
+- [ ] List the behaviors to test (not implementation steps)
+- [ ] Get user approval on the plan
+
+Ask: "What should the public interface look like? Which behaviors are most important to test?"
+
+**You can't test everything.** Confirm with the user exactly which behaviors matter most. Focus testing effort on critical paths and complex logic, not every possible edge case.
+
+### 2. Tracer Bullet
+
+Write ONE test that confirms ONE thing about the system:
+
+```
+RED:   Write test for first behavior → test fails
+GREEN: Write minimal code to pass → test passes
+```
+
+This is your tracer bullet - proves the path works end-to-end.
+
+### 3. Incremental Loop
+
+For each remaining behavior:
+
+```
+RED:   Write next test → fails
+GREEN: Minimal code to pass → passes
+```
+
+Rules:
+
+- One test at a time
+- Only enough code to pass current test
+- Don't anticipate future tests
+- Keep tests focused on observable behavior
+
+### 4. Refactor
+
+After all tests pass, look for [refactor candidates](refactoring.md):
+
+- [ ] Extract duplication
+- [ ] Deepen modules (move complexity behind simple interfaces)
+- [ ] Apply SOLID principles where natural
+- [ ] Consider what new code reveals about existing code
+- [ ] Run tests after each refactor step
+
+**Never refactor while RED.** Get to GREEN first.
+
+## Checklist Per Cycle
+
+```
+[ ] Test describes behavior, not implementation
+[ ] Test uses public interface only
+[ ] Test would survive internal refactor
+[ ] Code is minimal for this test
+[ ] No speculative features added
+```
+
+
+---
+
+_Vendored from [mattpocock/skills](https://github.com/mattpocock/skills) @ `b843cb5` — MIT License. See [skills/UPSTREAM-CREDITS.md](../UPSTREAM-CREDITS.md) for refresh instructions._

package/skills/tdd/deep-modules.md

@@ -0,0 +1,33 @@
+# Deep Modules
+
+From "A Philosophy of Software Design":
+
+**Deep module** = small interface + lots of implementation
+
+```
+┌─────────────────────┐
+│   Small Interface   │  ← Few methods, simple params
+├─────────────────────┤
+│                     │
+│                     │
+│  Deep Implementation│  ← Complex logic hidden
+│                     │
+│                     │
+└─────────────────────┘
+```
+
+**Shallow module** = large interface + little implementation (avoid)
+
+```
+┌─────────────────────────────────┐
+│       Large Interface           │  ← Many methods, complex params
+├─────────────────────────────────┤
+│  Thin Implementation            │  ← Just passes through
+└─────────────────────────────────┘
+```
+
+When designing interfaces, ask:
+
+- Can I reduce the number of methods?
+- Can I simplify the parameters?
+- Can I hide more complexity inside?

package/skills/tdd/interface-design.md

@@ -0,0 +1,31 @@
+# Interface Design for Testability
+
+Good interfaces make testing natural:
+
+1. **Accept dependencies, don't create them**
+
+   ```typescript
+   // Testable
+   function processOrder(order, paymentGateway) {}
+
+   // Hard to test
+   function processOrder(order) {
+     const gateway = new StripeGateway();
+   }
+   ```
+
+2. **Return results, don't produce side effects**
+
+   ```typescript
+   // Testable
+   function calculateDiscount(cart): Discount {}
+
+   // Hard to test
+   function applyDiscount(cart): void {
+     cart.total -= discount;
+   }
+   ```
+
+3. **Small surface area**
+   - Fewer methods = fewer tests needed
+   - Fewer params = simpler test setup

package/skills/tdd/mocking.md

@@ -0,0 +1,59 @@
+# When to Mock
+
+Mock at **system boundaries** only:
+
+- External APIs (payment, email, etc.)
+- Databases (sometimes - prefer test DB)
+- Time/randomness
+- File system (sometimes)
+
+Don't mock:
+
+- Your own classes/modules
+- Internal collaborators
+- Anything you control
+
+## Designing for Mockability
+
+At system boundaries, design interfaces that are easy to mock:
+
+**1. Use dependency injection**
+
+Pass external dependencies in rather than creating them internally:
+
+```typescript
+// Easy to mock
+function processPayment(order, paymentClient) {
+  return paymentClient.charge(order.total);
+}
+
+// Hard to mock
+function processPayment(order) {
+  const client = new StripeClient(process.env.STRIPE_KEY);
+  return client.charge(order.total);
+}
+```
+
+**2. Prefer SDK-style interfaces over generic fetchers**
+
+Create specific functions for each external operation instead of one generic function with conditional logic:
+
+```typescript
+// GOOD: Each function is independently mockable
+const api = {
+  getUser: (id) => fetch(`/users/${id}`),
+  getOrders: (userId) => fetch(`/users/${userId}/orders`),
+  createOrder: (data) => fetch('/orders', { method: 'POST', body: data }),
+};
+
+// BAD: Mocking requires conditional logic inside the mock
+const api = {
+  fetch: (endpoint, options) => fetch(endpoint, options),
+};
+```
+
+The SDK approach means:
+- Each mock returns one specific shape
+- No conditional logic in test setup
+- Easier to see which endpoints a test exercises
+- Type safety per endpoint

package/skills/tdd/refactoring.md

@@ -0,0 +1,10 @@
+# Refactor Candidates
+
+After TDD cycle, look for:
+
+- **Duplication** → Extract function/class
+- **Long methods** → Break into private helpers (keep tests on public interface)
+- **Shallow modules** → Combine or deepen
+- **Feature envy** → Move logic to where data lives
+- **Primitive obsession** → Introduce value objects
+- **Existing code** the new code reveals as problematic

package/skills/tdd/tests.md

@@ -0,0 +1,61 @@
+# Good and Bad Tests
+
+## Good Tests
+
+**Integration-style**: Test through real interfaces, not mocks of internal parts.
+
+```typescript
+// GOOD: Tests observable behavior
+test("user can checkout with valid cart", async () => {
+  const cart = createCart();
+  cart.add(product);
+  const result = await checkout(cart, paymentMethod);
+  expect(result.status).toBe("confirmed");
+});
+```
+
+Characteristics:
+
+- Tests behavior users/callers care about
+- Uses public API only
+- Survives internal refactors
+- Describes WHAT, not HOW
+- One logical assertion per test
+
+## Bad Tests
+
+**Implementation-detail tests**: Coupled to internal structure.
+
+```typescript
+// BAD: Tests implementation details
+test("checkout calls paymentService.process", async () => {
+  const mockPayment = jest.mock(paymentService);
+  await checkout(cart, payment);
+  expect(mockPayment.process).toHaveBeenCalledWith(cart.total);
+});
+```
+
+Red flags:
+
+- Mocking internal collaborators
+- Testing private methods
+- Asserting on call counts/order
+- Test breaks when refactoring without behavior change
+- Test name describes HOW not WHAT
+- Verifying through external means instead of interface
+
+```typescript
+// BAD: Bypasses interface to verify
+test("createUser saves to database", async () => {
+  await createUser({ name: "Alice" });
+  const row = await db.query("SELECT * FROM users WHERE name = ?", ["Alice"]);
+  expect(row).toBeDefined();
+});
+
+// GOOD: Verifies through interface
+test("createUser makes user retrievable", async () => {
+  const user = await createUser({ name: "Alice" });
+  const retrieved = await getUser(user.id);
+  expect(retrieved.name).toBe("Alice");
+});
+```

package/start.mjs

@@ -122,7 +122,7 @@ if (cacheMatch) {
 // truth) so users who fix themselves via `npm install -g context-mode`
 // follow the exact same code path. Best-effort, never blocks MCP boot.
 try {
-  const { healInstalledPlugins, healSettingsEnabledPlugins } =
+  const { healInstalledPlugins, healSettingsEnabledPlugins, healPluginJsonMcpServers } =
     await import("./scripts/heal-installed-plugins.mjs");
   const pluginKey = "context-mode@context-mode";
   const registryPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
@@ -135,6 +135,30 @@ try {
   // disable state is repaired before next /reload-plugins.
   try { healSettingsEnabledPlugins({ settingsPath, pluginKey }); }
   catch { /* best effort */ }
+  // v1.0.119 — Layer 5b (Issue #523): heal .claude-plugin/plugin.json's
+  // mcpServers["context-mode"].args[0] when /ctx-upgrade left a tmpdir-prefixed
+  // path baked in. Iterates EVERY installed cache entry's installPath so
+  // multi-version installs all self-recover. Each call is independently wrapped
+  // because one poisoned entry must not block heals on the others. Best effort.
+  try {
+    if (existsSync(registryPath)) {
+      const ip = JSON.parse(readFileSync(registryPath, "utf-8"));
+      const entries = (ip && ip.plugins && ip.plugins[pluginKey]) || [];
+      if (Array.isArray(entries)) {
+        for (const entry of entries) {
+          const installPath = entry && entry.installPath;
+          if (typeof installPath !== "string" || !installPath) continue;
+          try {
+            healPluginJsonMcpServers({
+              pluginRoot: installPath,
+              pluginCacheRoot,
+              pluginKey,
+            });
+          } catch { /* best effort — per-entry */ }
+        }
+      }
+    }
+  } catch { /* best effort */ }
 } catch { /* best effort — never block MCP boot */ }
 
 // ── Self-heal Layer 4: Deploy global SessionStart hook + register in settings.json ──

package/build/cache-heal.d.ts

@@ -1,48 +0,0 @@
-/**
- * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
- *
- * Claude Code's plugin auto-update can leave installed_plugins.json pointing
- * to a non-existent directory (anthropics/claude-code#46915). This module
- * detects and repairs the mismatch by creating symlinks.
- *
- * 4-layer defense:
- *   1. start.mjs startup — reverse heal (registry → symlink to us)
- *   2. server.ts first tool call — mid-session heal
- *   3. postinstall.mjs — backward symlink on new install
- *   4. global hook auto-deploy — survives total plugin cache breakage
- */
-export interface HealResult {
-    healed: boolean;
-    action?: "symlink" | "global-hook" | "none";
-    from?: string;
-    to?: string;
-}
-/**
- * Core heal: if installed_plugins.json points to a non-existent directory,
- * create a symlink from that path to our actual directory.
- *
- * @param currentDir - The directory we're actually running from
- * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
- */
-export declare function healRegistryMismatch(currentDir: string, installedPluginsPath?: string): HealResult;
-/**
- * Deploy a global SessionStart hook that heals plugin cache mismatches.
- * This hook lives outside the plugin directory, so it survives cache breakage.
- *
- * Written to ~/.claude/hooks/context-mode-cache-heal.sh
- */
-export declare function deployGlobalHealHook(): HealResult;
-/**
- * Backward symlink: during postinstall, if the registry points to a
- * non-existent OLD path, create a symlink from old → new (our directory).
- * Same as healRegistryMismatch but called from postinstall context.
- */
-export { healRegistryMismatch as healBackwardCompat };
-/**
- * Mid-session heal — call on first MCP tool invocation.
- * Checks if registry path differs from our running directory.
- * Creates symlink if needed. Runs only once per process.
- */
-export declare function healMidSession(currentDir: string): HealResult;
-/** Reset mid-session flag (for testing only) */
-export declare function _resetMidSession(): void;

package/build/cache-heal.js

@@ -1,150 +0,0 @@
-/**
- * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
- *
- * Claude Code's plugin auto-update can leave installed_plugins.json pointing
- * to a non-existent directory (anthropics/claude-code#46915). This module
- * detects and repairs the mismatch by creating symlinks.
- *
- * 4-layer defense:
- *   1. start.mjs startup — reverse heal (registry → symlink to us)
- *   2. server.ts first tool call — mid-session heal
- *   3. postinstall.mjs — backward symlink on new install
- *   4. global hook auto-deploy — survives total plugin cache breakage
- */
-import { existsSync, readFileSync, symlinkSync, mkdirSync, writeFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { homedir } from "node:os";
-/**
- * Core heal: if installed_plugins.json points to a non-existent directory,
- * create a symlink from that path to our actual directory.
- *
- * @param currentDir - The directory we're actually running from
- * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
- */
-export function healRegistryMismatch(currentDir, installedPluginsPath) {
-    const ipPath = installedPluginsPath ?? resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
-    if (!existsSync(ipPath))
-        return { healed: false, action: "none" };
-    if (!existsSync(currentDir))
-        return { healed: false, action: "none" };
-    let ip;
-    try {
-        ip = JSON.parse(readFileSync(ipPath, "utf-8"));
-    }
-    catch {
-        return { healed: false, action: "none" };
-    }
-    for (const [key, entries] of Object.entries(ip.plugins ?? {})) {
-        if (!key.toLowerCase().includes("context-mode"))
-            continue;
-        for (const entry of entries) {
-            const registryPath = entry.installPath;
-            if (!registryPath)
-                continue;
-            // Registry path exists — no healing needed
-            if (existsSync(registryPath))
-                continue;
-            // Registry path doesn't exist — create symlink to our directory
-            try {
-                const parent = dirname(registryPath);
-                if (!existsSync(parent))
-                    mkdirSync(parent, { recursive: true });
-                if (process.platform === "win32") {
-                    // Windows: use junction (no admin required)
-                    symlinkSync(currentDir, registryPath, "junction");
-                }
-                else {
-                    symlinkSync(currentDir, registryPath);
-                }
-                return { healed: true, action: "symlink", from: registryPath, to: currentDir };
-            }
-            catch {
-                return { healed: false, action: "none" };
-            }
-        }
-    }
-    return { healed: false, action: "none" };
-}
-/**
- * Deploy a global SessionStart hook that heals plugin cache mismatches.
- * This hook lives outside the plugin directory, so it survives cache breakage.
- *
- * Written to ~/.claude/hooks/context-mode-cache-heal.sh
- */
-export function deployGlobalHealHook() {
-    const hooksDir = resolve(homedir(), ".claude", "hooks");
-    const hookPath = resolve(hooksDir, "context-mode-cache-heal.sh");
-    // Already deployed
-    if (existsSync(hookPath))
-        return { healed: false, action: "none" };
-    try {
-        if (!existsSync(hooksDir))
-            mkdirSync(hooksDir, { recursive: true });
-        const script = `#!/usr/bin/env bash
-# context-mode plugin cache self-heal — auto-deployed by context-mode MCP server
-# Fixes anthropics/claude-code#46915: auto-update breaks CLAUDE_PLUGIN_ROOT
-# This hook runs at SessionStart (global, not plugin-level) so it works even
-# when the plugin cache is broken.
-
-set -euo pipefail
-
-PLUGINS_FILE="$HOME/.claude/plugins/installed_plugins.json"
-[[ -f "$PLUGINS_FILE" ]] || exit 0
-
-# Find context-mode entries and heal missing directories
-node -e '
-const fs = require("fs");
-const path = require("path");
-try {
-  const ip = JSON.parse(fs.readFileSync(process.argv[1], "utf-8"));
-  for (const [key, entries] of Object.entries(ip.plugins || {})) {
-    if (!key.toLowerCase().includes("context-mode")) continue;
-    for (const entry of entries) {
-      const p = entry.installPath;
-      if (!p || fs.existsSync(p)) continue;
-      const parent = path.dirname(p);
-      if (!fs.existsSync(parent)) continue;
-      const dirs = fs.readdirSync(parent).filter(d => /^\\d+\\.\\d+/.test(d) && fs.statSync(path.join(parent, d)).isDirectory());
-      if (dirs.length === 0) continue;
-      dirs.sort((a, b) => {
-        const pa = a.split(".").map(Number), pb = b.split(".").map(Number);
-        for (let i = 0; i < 3; i++) { if ((pa[i]||0) !== (pb[i]||0)) return (pa[i]||0) - (pb[i]||0); }
-        return 0;
-      });
-      const target = path.join(parent, dirs[dirs.length - 1]);
-      try { fs.symlinkSync(target, p); } catch {}
-    }
-  }
-} catch {}
-' "$PLUGINS_FILE" 2>/dev/null || true
-`;
-        writeFileSync(hookPath, script, { mode: 0o755 });
-        return { healed: true, action: "global-hook", from: hookPath };
-    }
-    catch {
-        return { healed: false, action: "none" };
-    }
-}
-/**
- * Backward symlink: during postinstall, if the registry points to a
- * non-existent OLD path, create a symlink from old → new (our directory).
- * Same as healRegistryMismatch but called from postinstall context.
- */
-export { healRegistryMismatch as healBackwardCompat };
-/** One-shot flag for mid-session heal in server.ts */
-let _midSessionHealed = false;
-/**
- * Mid-session heal — call on first MCP tool invocation.
- * Checks if registry path differs from our running directory.
- * Creates symlink if needed. Runs only once per process.
- */
-export function healMidSession(currentDir) {
-    if (_midSessionHealed)
-        return { healed: false, action: "none" };
-    _midSessionHealed = true;
-    return healRegistryMismatch(currentDir);
-}
-/** Reset mid-session flag (for testing only) */
-export function _resetMidSession() {
-    _midSessionHealed = false;
-}

package/build/routing-block.d.ts

@@ -1,8 +0,0 @@
-import type { ToolNamer } from "./tool-naming.js";
-export interface RoutingBlockOptions {
-    includeCommands?: boolean;
-}
-export declare function createRoutingBlock(t: ToolNamer, options?: RoutingBlockOptions): string;
-export declare function createReadGuidance(t: ToolNamer): string;
-export declare function createGrepGuidance(t: ToolNamer): string;
-export declare function createBashGuidance(t: ToolNamer): string;