aiwcli 0.15.5 → 0.15.7

package/dist/templates/{_shared → core}/lib-ts/CLAUDE.md

@@ -1,15 +1,15 @@
 # Shared TypeScript Library
 
-**Location:** `_shared/lib-ts/` — cross-method infrastructure used by ALL templates.
+**Location:** `core/lib-ts/` — cross-method infrastructure used by ALL templates.
 
 **One import gets you started:**
 ```typescript
-import { loadHookInput, runHook, logInfo, emitContext } from "../lib-ts/base/hook-utils.js";
+import { loadHookInput, runHook, logInfo, emitContext } from "../lib-ts/hooks/hook-utils.js";
 ```
 
 `hook-utils.ts` re-exports the most-used functions from `logger.ts`, `constants.ts`, and `context-store.ts`. Start here. Only import from deeper modules when you need specific capabilities.
 
-**Import direction:** Hooks --> method lib --> `_shared/lib-ts/`. Never the reverse.
+**Import direction:** Hooks --> method lib --> `core/lib-ts/`. Never the reverse.
 
 ---
 
@@ -21,7 +21,7 @@ These cause silent failures or UI noise when violated:
 - **stdout is sacred:** Only hook JSON output goes to stdout. Use logger functions for diagnostics, never `console.log()` or `print()`
 - **stderr is opt-in:** `logDebug/logInfo/logWarn/logError` write to file only. Use `logBlocking()` when you NEED stderr visibility
 - **Catch non-critical errors locally:** Uncaught errors bubble to `runHook` which writes to stderr, showing "hook error" in the UI even on exit 0
-- **No reverse imports:** Never import from method lib (e.g., `_cc-native/lib/`) into shared lib
+- **No reverse imports:** Never import from method-specific libraries into shared lib
 
 ---
 
@@ -31,7 +31,7 @@ Copy this for new hooks:
 
 ```typescript
 #!/usr/bin/env bun
-import { loadHookInput, runHook, logDebug, logInfo, emitContext } from "../lib-ts/base/hook-utils.js";
+import { loadHookInput, runHook, logDebug, logInfo, emitContext } from "../lib-ts/hooks/hook-utils.js";
 
 function main(): void {
   const payload = loadHookInput();
@@ -51,7 +51,7 @@ runHook(main, "my_hook_name");
 For async hooks (AI inference, network calls):
 
 ```typescript
-import { runHookAsync } from "../lib-ts/base/hook-utils.js";
+import { runHookAsync } from "../lib-ts/hooks/hook-utils.js";
 
 async function asyncMain(): Promise<void> {
   // await something...
@@ -74,7 +74,7 @@ All logging goes to `_output/hook-log.jsonl`. stderr visibility is opt-in.
 | Terminal | `eprint()` | Yes (raw stderr) | Usage help, progress indicators — not logged to JSONL |
 
 ```typescript
-import { logDebug, logInfo, logWarn, logBlocking } from "../lib-ts/base/hook-utils.js";
+import { logDebug, logInfo, logWarn, logBlocking } from "../lib-ts/hooks/hook-utils.js";
 
 logInfo("my_hook", "Session started");           // file only
 logWarn("my_hook", `Fallback used: ${reason}`);   // file only
@@ -89,7 +89,7 @@ Hooks have multiple channels back to the session. Pick the right one:
 
 | Want to... | Function | Who sees it |
 |------------|----------|-------------|
-| **Block (any event)** | `emitBlock(reason, context?)` | Claude + user — auto-dispatches to correct mechanism |
+| **Block (event-aware)** | `emitBlock(reason, context?)` | Claude + user — auto-dispatches to correct mechanism |
 | Block tool (PreToolUse only) | `emitContextAndBlock(context, reason)` | Claude + user (denial reason prominent) |
 | Return message, don't block | `emitContext(context)` | Claude + user (in transcript) |
 | Log only (diagnostics) | `logInfo()` / `logWarn()` / etc. | Nobody in session — file only |
@@ -157,7 +157,7 @@ emitPermissionDecision("deny", { message: "Why denied" });
 emitPermissionDecision("allow", { updatedInput: { /* modified input */ } });
 ```
 
-### Channel 6: Non-blocking Context (any hook event)
+### Channel 6: Non-blocking Context (supported hook events)
 
 ```typescript
 emitContext("Information added to Claude's context");
@@ -238,7 +238,7 @@ Claude Code validates `hookSpecificOutput` using a Zod discriminated union keyed
 | **0** + deny JSON | Yes | Yes (PreToolUse only) | `additionalContext` + denial reason | Yes |
 | **0** + context JSON | Yes | No | `additionalContext` in transcript | Yes |
 | **1** | No | No | stderr in verbose mode only | Yes |
-| **2** | No | Yes (any event) | stderr fed as system-reminder | Yes |
+| **2** | No | Yes (event-dependent) | stderr fed as system-reminder | Yes |
 
 **Key insight:** Exit 0 + `permissionDecision: "deny"` is the correct way to block a tool. Exit 2 is a blunt instrument — it ignores your JSON and feeds raw stderr to Claude. Use exit 0 + deny for clean blocking with structured feedback.
 
@@ -255,7 +255,7 @@ Early testing suggested ExitPlanMode was "immune" to PreToolUse deny. **This was
 - Exit 2 also appeared to "not work" for PreToolUse (JSON was ignored as expected, but the blocking was via stderr, not deny)
 - PostToolUse with exit 2 appeared to work because it used stderr (not JSON), bypassing the Zod issue
 
-**Lesson:** When a hook output seems to be "silently ignored," check the JSON schema first. The Zod validator rejects malformed output without any error message.
+**Lesson:** When a hook output seems to be "silently ignored," check the JSON schema first. The Zod validator rejects malformed output without an explicit error message.
 
 ### Debugging Checklist
 
@@ -297,11 +297,19 @@ Transitions: `idle`/`has_staged_work` --> `active` (via `maybeActivate`). `activ
 
 Use this table to find the right file. Read the source for full API details.
 
-### `base/` — Core Infrastructure
+### `hooks/` — Hook Lifecycle
 
 | File | Purpose | Key Exports |
 |------|---------|-------------|
 | `hook-utils.ts` | Hook lifecycle, stdin parsing, output emit, re-exports | `runHook`, `runHookAsync`, `loadHookInput`, `emitContext`, `emitContextAndBlock`, `emitBlock`, `emitBlockPrompt`, `emitBlockViaExit`, `emitBlockTopLevel`, `emitPermissionDecision`, `logDebug`...`logBlocking` |
+| `context-monitor-logic.ts` | Context monitor extracted logic | Context window tracking helpers |
+| `prompt-binding-logic.ts` | Prompt binding extracted logic | Prompt-to-context binding helpers |
+| `session-end-logic.ts` | Session end extracted logic | Session end state management helpers |
+
+### `runtime/` — Core Infrastructure
+
+| File | Purpose | Key Exports |
+|------|---------|-------------|
 | `logger.ts` | JSONL logging engine | `hookLog`, `logDebug`, `logInfo`, `logWarn`, `logError`, `logBlocking`, `logHookError`, `logDiagnostic` |
 | `constants.ts` | Path resolution, limits | `getProjectRoot()`, `getContextDir()`, `MAX_FILE_SIZE` |
 | `atomic-write.ts` | Crash-safe file writes | `atomicWriteFileSync()` |
@@ -311,7 +319,7 @@ Use this table to find the right file. Read the source for full API details.
 | `git-state.ts` | Git snapshot | `captureGitState()` |
 | `subprocess-utils.ts` | Recursive call guard | `isInternalCall()` |
 | `stop-words.ts` | Word list for ID generation | Used by `utils.ts` internally |
-| `lint-dispatch.ts` | Post-edit lint dispatching | `dispatchLint()` |
+| `lint-dispatch.ts` | Post-edit lint dispatching | `getLinterForFile()`, `runLinter()`, `formatLintErrors()` |
 
 ### `context/` — Context State Management
 
@@ -338,7 +346,7 @@ Use this table to find the right file. Read the source for full API details.
 
 ---
 
-## Shared Hooks (`_shared/hooks-ts/`)
+## Shared Hooks (`core/hooks-ts/`)
 
 These run for ALL templates. Method-specific hooks live in `_{method}/hooks/`.
 
@@ -353,6 +361,8 @@ These run for ALL templates. Method-specific hooks live in `_{method}/hooks/`.
 | `task_create_capture.ts` | PostToolUse:TaskCreate | Persists task creation to context state |
 | `task_update_capture.ts` | PostToolUse:TaskUpdate | Persists task updates to context state |
 | `file-suggestion.ts` | PostToolUse:Write | Suggests file organization improvements |
+| `codex_explorer.ts` | UserPromptSubmit | Codex Spark codebase exploration (plan mode, once per session) |
+| `lint_after_edit.ts` | PostToolUse:Write | Post-edit lint dispatching |
 
 ---
 
@@ -380,7 +390,7 @@ the code, and it belongs at this scope (project-wide rule → root CLAUDE.md; WH
 how an agent acts here, remove it. If a convention here conflicts with the codebase,
 the codebase wins — update this file, do not work around it. Prune aggressively.
 
-**Staleness anchor:** This file assumes `base/hook-utils.ts` exists. If it doesn't, this file
+**Staleness anchor:** This file assumes `hooks/hook-utils.ts` exists. If it doesn't, this file
 is stale — update or regenerate before relying on it.
 
 **Trigger Audit or Generate:**
@@ -389,4 +399,5 @@ is stale — update or regenerate before relying on it.
 - 30+ days without touching this file → Audit
 - Agent mistake caused by this file → fix immediately, then Audit
 
-<!-- context-layer: generated=2026-02-14 | last-audited=2026-02-21 | version=2 | dir-commits-at-audit=29 -->
+<!-- context-layer: generated=2026-02-14 | last-audited=2026-03-05 | version=3 | dir-commits-at-audit=29 -->
+

package/dist/templates/{_shared → core}/lib-ts/agent-exec/backends/headless.ts

@@ -6,7 +6,7 @@
 
 import * as fs from "node:fs";
 
-import { execFileAsync } from "../../base/subprocess-utils.js";
+import { execFileAsync } from "../../runtime/subprocess-utils.js";
 import type { ExecutionBackend, ExecutionRequest, ExecutionResult } from "../execution-backend.js";
 
 export class HeadlessBackend implements ExecutionBackend {
@@ -21,7 +21,7 @@ export class HeadlessBackend implements ExecutionBackend {
 
     // If outputFilePath specified and exists, read from file instead of stdout
     if (request.outputFilePath && fs.existsSync(request.outputFilePath)) {
-      const fileContent = fs.readFileSync(request.outputFilePath, "utf-8");
+      const fileContent = fs.readFileSync(request.outputFilePath, "utf8");
       return {
         ...result,
         stdout: fileContent,
@@ -31,3 +31,4 @@ export class HeadlessBackend implements ExecutionBackend {
     return result;
   }
 }
+

package/dist/templates/{_shared → core}/lib-ts/agent-exec/backends/tmux.ts

@@ -2,15 +2,13 @@
  * Tmux execution backend — runs CLI agents in visible tmux panes
  * with sentinel-file-based output capture.
  *
- * Delegates pane management to tmux-driver.ts primitives. Does NOT use
- * launchDriverInTmuxOrFallback() because fallback is the caller's concern,
- * not the backend's.
+ * Self-contained tmux interaction — does not depend on tmux-driver.ts
+ * or the pane launcher stack (those are consolidated into the `aiw` CLI).
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { execFileAsync } from "../../base/subprocess-utils.js";
 import {
   buildShellCaptureScript,
   cleanupSentinelIpc,
@@ -18,8 +16,9 @@ import {
   readSentinelExitCode,
   readTextIfExists,
   waitForSentinelFile,
-} from "../../base/sentinel-ipc.js";
-import { getTmuxAvailability, quoteForSh, normalizeSplitFlag } from "../../base/tmux-driver.js";
+} from "../../runtime/sentinel-ipc.js";
+import { execFileAsync, findExecutable } from "../../runtime/subprocess-utils.js";
+import { findPsmux } from "../../runtime/tmux-preflight.js";
 import type { ExecutionBackend, ExecutionRequest, ExecutionResult } from "../execution-backend.js";
 
 export interface TmuxBackendOptions {
@@ -27,6 +26,14 @@ export interface TmuxBackendOptions {
   splitTarget?: string;
 }
 
+function quoteForSh(input: string): string {
+  return `'${input.replaceAll("'", "'\"'\"'")}'`;
+}
+
+function normalizeSplitFlag(value: string | undefined): "-h" | "-v" {
+  return value?.trim() === "-v" ? "-v" : "-h";
+}
+
 export class TmuxBackend implements ExecutionBackend {
   private options: TmuxBackendOptions;
 
@@ -35,11 +42,25 @@ export class TmuxBackend implements ExecutionBackend {
   }
 
   async execute(request: ExecutionRequest): Promise<ExecutionResult> {
-    const tmux = getTmuxAvailability({ requireSessionEnv: true });
-    if (!tmux.available || !tmux.tmuxPath) {
+    // On Windows, use psmux (native ConPTY multiplexer) instead of tmux
+    const isWindows = process.platform === "win32";
+    const muxBinary = isWindows ? "psmux" : "tmux";
+
+    if (!isWindows && !process.env.TMUX) {
+      return {
+        stdout: "",
+        stderr: "tmux pane launch failed: TMUX is not set",
+        exitCode: 1,
+        killed: false,
+        signal: null,
+      };
+    }
+
+    const tmuxPath = isWindows ? findPsmux() : findExecutable("tmux");
+    if (!tmuxPath) {
       return {
         stdout: "",
-        stderr: `tmux pane launch failed: ${tmux.reason ?? "tmux unavailable"}`,
+        stderr: `${muxBinary} pane launch failed: ${muxBinary} not found on PATH`,
         exitCode: 1,
         killed: false,
         signal: null,
@@ -50,7 +71,7 @@ export class TmuxBackend implements ExecutionBackend {
     const ipc = createSentinelIpcPaths(`aiwcli-agent-${agentName}`);
 
     try {
-      fs.writeFileSync(ipc.inputPath, request.input, "utf-8");
+      fs.writeFileSync(ipc.inputPath, request.input, "utf8");
 
       const envEntries = Object.entries(request.env).filter(
         ([, value]) => value !== undefined,
@@ -68,9 +89,15 @@ export class TmuxBackend implements ExecutionBackend {
       if (this.options.splitTarget) {
         tmuxArgs.push("-t", this.options.splitTarget);
       }
-      tmuxArgs.push(`bash -lc ${quoteForSh(script)}`);
+      // On Windows (psmux), run directly — no bash wrapper needed.
+      // On Unix (tmux), wrap in bash login shell.
+      if (isWindows) {
+        tmuxArgs.push(script);
+      } else {
+        tmuxArgs.push(`bash -lc ${quoteForSh(script)}`);
+      }
 
-      const split = await execFileAsync(tmux.tmuxPath, tmuxArgs, { timeout: 5000 });
+      const split = await execFileAsync(tmuxPath, tmuxArgs, { timeout: 5000 });
       if (split.exitCode !== 0) {
         return {
           stdout: "",
@@ -86,7 +113,7 @@ export class TmuxBackend implements ExecutionBackend {
 
       if (!finished) {
         if (paneId) {
-          await execFileAsync(tmux.tmuxPath, ["kill-pane", "-t", paneId], { timeout: 3000 });
+          await execFileAsync(tmuxPath, ["kill-pane", "-t", paneId], { timeout: 3000 });
         }
         return {
           stdout: "",
@@ -103,7 +130,7 @@ export class TmuxBackend implements ExecutionBackend {
 
       if (request.outputFilePath && fs.existsSync(request.outputFilePath)) {
         return {
-          stdout: fs.readFileSync(request.outputFilePath, "utf-8"),
+          stdout: fs.readFileSync(request.outputFilePath, "utf8"),
           stderr,
           exitCode,
           killed: false,
@@ -117,3 +144,5 @@ export class TmuxBackend implements ExecutionBackend {
     }
   }
 }
+
+

package/dist/templates/{_shared → core}/lib-ts/agent-exec/base-agent.ts

@@ -1,20 +1,20 @@
 /**
  * Abstract base class for CLI-based agent subprocess invocations.
- * Lives in _shared so all templates can use it. Provider-specific
+ * Lives in core so all templates can use it. Provider-specific
  * implementations (Claude, Codex, Gemini) extend this class.
  *
  * Execution strategy is injected via ExecutionBackend (default: HeadlessBackend).
  * Debug logging is injectable via AgentDebugLogger (default: no-op).
  */
 
-import { logDebug, logInfo, logWarn, logError } from "../base/logger.js";
-import { getInternalSubprocessEnv, findExecutable, normalizePathForCli } from "../base/subprocess-utils.js";
+import { logDebug, logInfo, logWarn, logError } from "../runtime/logger.js";
+import { getInternalSubprocessEnv, findExecutable, normalizePathForCli } from "../runtime/subprocess-utils.js";
 import { HeadlessBackend } from "./backends/headless.js";
 import type { ExecutionBackend, ExecutionResult, AgentDebugLogger } from "./execution-backend.js";
 import type { AgentConfig } from "../types.js";
 
 // Re-export for consumers
-export type { ExecutionResult, AgentDebugLogger };
+
 
 /** Configuration object for BaseCliAgent construction. */
 export interface AgentExecutionConfig {
@@ -227,3 +227,5 @@ export abstract class BaseCliAgent<T> {
     return coerced;
   }
 }
+
+export {type AgentDebugLogger, type ExecutionResult} from "./execution-backend.js";

package/dist/templates/{_shared → core}/lib-ts/agent-exec/execution-backend.ts

@@ -43,7 +43,7 @@ export interface ExecutionBackend {
 // Debug Logger
 // ---------------------------------------------------------------------------
 
-/** Injectable debug logger for agents running in _shared context. */
+/** Injectable debug logger for agents running in core context. */
 export interface AgentDebugLogger {
   log(contextPath: string, sessionName: string, component: string, message: string, data?: unknown): void;
   raw(contextPath: string, sessionName: string, component: string, label: string, raw: string): void;

package/dist/templates/{_shared → core}/lib-ts/agent-exec/index.ts

@@ -1,6 +1,6 @@
-export { BaseCliAgent, type AgentExecutionConfig } from "./base-agent.js";
-export type { ExecutionBackend, ExecutionRequest, ExecutionResult, AgentDebugLogger } from "./execution-backend.js";
 export { HeadlessBackend } from "./backends/headless.js";
 export { TmuxBackend } from "./backends/tmux.js";
+export { type AgentExecutionConfig, BaseCliAgent } from "./base-agent.js";
+export type { AgentDebugLogger, ExecutionBackend, ExecutionRequest, ExecutionResult } from "./execution-backend.js";
 export { parseJsonObjectMaybe, parseStructuredOutput } from "./structured-output.js";
 export type { StructuredOutputParseOptions } from "./structured-output.js";

package/dist/templates/{_shared → core}/lib-ts/agent-exec/structured-output.ts

@@ -3,7 +3,7 @@
  * Supports Claude/Codex-style envelopes and heuristic JSON extraction.
  */
 
-import { logDebug, logError, logWarn } from "../base/logger.js";
+import { logDebug, logError, logWarn } from "../runtime/logger.js";
 
 export interface StructuredOutputParseOptions {
   requireFields?: string[];
@@ -84,10 +84,10 @@ function parseAssistantEnvelope(
   options?: StructuredOutputParseOptions,
 ): Record<string, unknown> | null {
   const tag = getTag(options);
-  const message = envelope.message;
+  const {message} = envelope;
   if (!message || typeof message !== "object") return null;
 
-  const content = (message as Record<string, unknown>).content;
+  const {content} = (message as Record<string, unknown>);
   if (!Array.isArray(content)) return null;
 
   for (const item of content) {
@@ -142,8 +142,7 @@ export function parseStructuredOutput(
         return null;
       }
     } else if (Array.isArray(parsed)) {
-      for (let i = 0; i < parsed.length; i++) {
-        const event = parsed[i];
+      for (const [i, event] of parsed.entries()) {
         if (!event || typeof event !== "object") continue;
         const eventObj = event as Record<string, unknown>;
         const assistantResult = parseAssistantEnvelope(eventObj, options);

package/dist/templates/{_shared → core}/lib-ts/context/CLAUDE.md

@@ -82,13 +82,14 @@ Formats context state for injection into Claude's context window.
 
 ### `context-selector.ts`
 
-Finds contexts by various criteria.
+Routes prompts to contexts. Single entry point: `determineContext()`.
 
-| Function | Purpose |
+| Function / Class | Purpose |
 |----------|---------|
-| `selectActiveContext(root?)` | Find the single active context (errors if multiple) |
-| `findContextByMode(mode, root?)` | Find contexts in a given mode |
-| `findStagedWorkContext(root?)` | Find context with `has_staged_work` mode |
+| `determineContext(prompt, sessionId, projectRoot)` | Main entry — session match, caret commands, plan/handoff fallback, or create new |
+| `resolveContextByPrefix(prefix, root?)` | Resolve context by ID prefix |
+| `parseChainedCaret(prompt)` | Parse `^` caret commands from prompt |
+| `BlockRequest` (class) | Thrown when request should be blocked with a message |
 
 ### `plan-manager.ts`
 
@@ -123,7 +124,6 @@ Tracks task progress (ISC criteria) within a context.
 | `session_end.ts` | `getContextBySessionId()`, `updateMode()`, `saveState()` |
 | `user_prompt_submit.ts` | `getAllContexts()`, `maybeActivate()`, `determineArtifactType()` |
 | `archive_plan.ts` | `getContextBySessionId()`, `archivePlan()` |
-| `save_handoff.ts` | `getContextBySessionId()`, `updateContext()` |
 | `cc-native-plan-review.ts` | `getContextBySessionId()`, `getAllContexts()` |
 
 ## Design Decisions
@@ -132,3 +132,6 @@ Tracks task progress (ISC criteria) within a context.
 - **No moves out of lib-ts:** Context is pure library code imported by ~8 shared hooks. Moving it would require updating all those import paths for no structural gain. The subfolder is already co-located; it just needed documentation.
 - **`maybeActivate()` is idempotent:** Can be called from any hook without checking current mode — safe to call repeatedly.
 - **`determineArtifactType()` drives session restore:** Returns `"plan"` or `"handoff"` to dispatch the correct restoration path in `session_start.ts`.
+
+<!-- context-layer: last-audited=2026-03-05 | version=2 -->
+

package/dist/templates/{_shared → core}/lib-ts/context/context-formatter.ts

@@ -8,10 +8,10 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { getContextDir } from "../base/constants.js";
-import { displayPath, parseIsoTimestamp } from "../base/utils.js";
+import { getContextDir } from "../runtime/constants.js";
+import { displayPath, parseIsoTimestamp } from "../runtime/utils.js";
 import type { ContextState, Task } from "../types.js";
 
 const MAX_PLAN_INLINE_CHARS = 30_000;
@@ -79,9 +79,10 @@ export function formatRelativeTime(isoTimestamp: string | null): string {
 // Internal helpers
 // ---------------------------------------------------------------------------
 
-function taskAttr(task: Task | Record<string, any>, key: string, defaultVal = ""): string {
+function taskAttr(task: Task | Record<string, unknown>, key: string, defaultVal = ""): string {
   if (typeof task === "object" && task !== null) {
-    return (task as any)[key] ?? defaultVal;
+    const value = (task as Record<string, unknown>)[key];
+    return typeof value === "string" ? value : defaultVal;
   }
   return defaultVal;
 }
@@ -89,7 +90,7 @@ function taskAttr(task: Task | Record<string, any>, key: string, defaultVal = ""
 function readPlanContent(planPath: string): [string | null, boolean, number] {
   try {
     if (!fs.existsSync(planPath)) return [null, false, 0];
-    const content = fs.readFileSync(planPath, "utf-8");
+    const content = fs.readFileSync(planPath, "utf8");
     const total = content.length;
     if (total > MAX_PLAN_INLINE_CHARS) {
       return [content.slice(0, MAX_PLAN_INLINE_CHARS), true, total];
@@ -220,11 +221,11 @@ export function formatHandoffContinuation(ctx: ContextState, projectRoot?: strin
 
   try {
     if (handoffPath && fs.existsSync(handoffPath)) {
-      lines.push("### Previous Session Handoff", "", fs.readFileSync(handoffPath, "utf-8"), "");
+      lines.push("### Previous Session Handoff", "", fs.readFileSync(handoffPath, "utf8"), "");
     } else {
       lines.push(`*Handoff document not found at \`${displayPath(handoffPath)}\`*`, "");
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     lines.push(`*Handoff document at \`${displayPath(handoffPath)}\` could not be read: ${error}*`, "");
   }
 
@@ -492,19 +493,10 @@ function collectStatePointers(contextId: string, contextDir: string, state: Cont
   return "**Key artifacts:**\n" + pointers.join("\n");
 }
 
-function countFilesRecursive(dirPath: string): number {
-  let count = 0;
+function countFiles(dirPath: string): number {
   try {
-    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        count++;
-      } else if (entry.isDirectory()) {
-        count += countFilesRecursive(path.join(dirPath, entry.name));
-      }
-    }
-  } catch { /* permission errors, etc. */ }
-  return count;
+    return fs.readdirSync(dirPath).length;
+  } catch { return 0; }
 }
 
 function collectFolderInventory(contextId: string, contextDir: string, _state: ContextState): string | null {
@@ -521,7 +513,7 @@ function collectFolderInventory(contextId: string, contextDir: string, _state: C
   for (const dir of dirs) {
     const dirPath = path.join(contextDir, dir.name);
     const desc = KNOWN_FOLDERS[dir.name] ?? "Project-specific artifacts";
-    const fileCount = countFilesRecursive(dirPath);
+    const fileCount = countFiles(dirPath);
     lines.push(`- \`${dir.name}/\` — ${desc} (${fileCount} file${fileCount !== 1 ? "s" : ""})`);
   }
   return lines.join("\n");
@@ -586,3 +578,6 @@ export function buildContextInventory(
   if (sections.length === 0) return null;
   return "### Context Resources\n\n" + sections.join("\n\n");
 }
+
+
+

package/dist/templates/{_shared → core}/lib-ts/context/context-selector.ts

@@ -35,8 +35,8 @@ import {
   determineArtifactType,
 } from "./context-store.js";
 import { normalizePlanContent } from "./plan-manager.js";
-import { logDebug, logInfo, logError } from "../base/logger.js";
-import { isInternalCall } from "../base/subprocess-utils.js";
+import { logDebug, logInfo, logError } from "../runtime/logger.js";
+import { isInternalCall } from "../runtime/subprocess-utils.js";
 import type { ContextState, CaretCommand } from "../types.js";
 
 /** Minimum characters required for new context description. */
@@ -256,7 +256,7 @@ function matchPlanContent(prompt: string, hasPlanContexts: ContextState[]): Cont
 
   // Tier 2: Normalized hash match
   const normalized = normalizePlanContent(prompt);
-  const normHash = crypto.createHash("sha256").update(normalized, "utf-8").digest("hex").slice(0, 12);
+  const normHash = crypto.createHash("sha256").update(normalized, "utf8").digest("hex").slice(0, 12);
   for (const ctx of hasPlanContexts) {
     if (ctx.plan_hash && ctx.plan_hash === normHash) {
       logDebug("context_selector", `Tier 2 normalized hash match: ${ctx.id} (hash: ${normHash})`);
@@ -302,7 +302,7 @@ function createNewContext(
     newCtx.mode = "active";
     logInfo("context_selector", `Auto-created context: ${newCtx.id}`);
     return [newCtx.id, "auto_created", formatContextCreated(newCtx)];
-  } catch (error: any) {
+  } catch (error: unknown) {
     logError("context_selector", `Primary context creation failed: ${error}`);
     try {
       const now = new Date();
@@ -323,7 +323,7 @@ function createNewContext(
       newCtx.mode = "active";
       logInfo("context_selector", `Fallback context created: ${newCtx.id}`);
       return [newCtx.id, "auto_created_fallback", formatContextCreated(newCtx)];
-    } catch (error: any) {
+    } catch (error: unknown) {
       logError("context_selector", `ALL context creation failed: ${error}`);
       return [null, "creation_failed", null];
     }
@@ -492,7 +492,7 @@ export function determineContext(
         if (sessionId) bindSession(matched.id, sessionId, projectRoot);
         updateMode(matched.id, "active", projectRoot, {
           work_consumed: true, // CHANGED: unified flag
-          plan_hash_consumed: matched.plan_hash,
+          ...(matched.plan_hash ? {plan_hash_consumed: matched.plan_hash} : {}),
         });
         matched.mode = "active";
         logInfo("context_selector", `Plan match (fallback): ${matched.id}`);
@@ -522,3 +522,5 @@ export function determineContext(
   // --- Case 4: default ---
   return createNewContext(prompt, projectRoot);
 }
+
+