aiwcli 0.15.5 → 0.17.0

package/dist/templates/{_shared → core}/hooks-ts/session_end.ts

@@ -1,22 +1,26 @@
 #!/usr/bin/env bun
 /**
  * SessionEnd hook: Save session state, assign plan fields (fallback),
- * stage has_plan/has_handoff for next session.
+ * stage has_staged_work for next session.
  */
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { getProjectRoot, getContextDir } from "../lib-ts/base/constants.js";
-import { getGitState } from "../lib-ts/base/git-state.js";
+import { saveState, determineArtifactType } from "../lib-ts/context/context-store.js";
 import {
-  loadHookInput, runHook, logDebug, logInfo, logError, logDiagnostic,
-} from "../lib-ts/base/hook-utils.js";
-import { nowIso } from "../lib-ts/base/utils.js";
-import { getContextBySessionId, saveState, determineArtifactType } from "../lib-ts/context/context-store.js";
-import {
-  findLatestPlan, normalizePlanContent, generatePlanId, extractPlanAnchors,
+  findLatestPlan,
 } from "../lib-ts/context/plan-manager.js";
+import {
+  requireBoundSession, runHook, logDebug, logInfo, logError, logDiagnostic,
+} from "../lib-ts/hooks/hook-utils.js";
+import {
+  buildSessionMetadata,
+  computePlanFallback,
+  generateArchiveFilename,
+  shouldStage,
+} from "../lib-ts/hooks/session-end-logic.js";
+import { getContextDir } from "../lib-ts/runtime/constants.js";
+import { nowIso } from "../lib-ts/runtime/utils.js";
 
 /**
  * Archive session transcript to context's session-transcripts/ folder.
@@ -39,25 +43,10 @@ function archiveTranscript(
   const transcriptsDir = path.join(contextDir, "session-transcripts");
   fs.mkdirSync(transcriptsDir, { recursive: true });
 
-  // 3. Generate archive filename: YYYY-MM-DD-HHMM-{session_id}.jsonl
-  const now = new Date();
-  // Format: 2026-02-14-1400 (year-month-day-hourminute)
-  // Note: Hours and minutes are concatenated without separator (HHMM)
-  const timestamp =
-    `${now.getFullYear()}-` +
-    `${String(now.getMonth() + 1).padStart(2, "0")}-` +
-    `${String(now.getDate()).padStart(2, "0")}-` +
-    `${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
-
-  // 4. Handle collisions (rare, but possible with rapid session churn)
-  let archiveName = `${timestamp}-${sessionId}.jsonl`;
-  let archivePath = path.join(transcriptsDir, archiveName);
-  let counter = 2;
-  while (fs.existsSync(archivePath)) {
-    archiveName = `${timestamp}-${sessionId}-${counter}.jsonl`;
-    archivePath = path.join(transcriptsDir, archiveName);
-    counter++;
-  }
+  // 3. Generate archive filename with collision handling
+  const existingNames = new Set(fs.readdirSync(transcriptsDir));
+  const archiveName = generateArchiveFilename(sessionId, new Date(), existingNames);
+  const archivePath = path.join(transcriptsDir, archiveName);
 
   // 5. Copy transcript file
   try {
@@ -70,46 +59,27 @@ function archiveTranscript(
 }
 
 function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
-
-  const sessionId = payload.session_id;
-  if (!sessionId) {
-    logDebug("session_end", "No session_id, skipping");
-    return;
-  }
+  const bound = requireBoundSession("session_end");
+  if (!bound) return;
 
-  const projectRoot = getProjectRoot(payload.cwd);
+  const { payload, sessionId, projectRoot, state } = bound;
   const source = payload.source ?? "unknown";
   const permissionMode = payload.permission_mode ?? "";
 
-  const state = getContextBySessionId(sessionId, projectRoot);
-  if (!state) {
-    logDebug("session_end", `No context bound to session ${sessionId}`);
-    return;
-  }
-
-  // Capture git state
-  const gitState = getGitState(projectRoot);
-
   // Save session metadata
-  state.last_session = {
-    session_id: sessionId,
-    save_reason: source,
-    saved_at: nowIso(),
-    transcript_path: payload.transcript_path ?? undefined,
-    git_state: gitState,
-  };
+  state.last_session = buildSessionMetadata(
+    sessionId,
+    source,
+    payload.transcript_path ?? undefined,
+  );
   state.last_active = nowIso();
 
-  // Archive transcript (NEW)
-  // Note: state is a ContextState object (from getContextBySessionId on line 33)
-  // state.id is the context ID used to construct paths like _output/contexts/{context_id}/
+  // Archive transcript
   if (payload.transcript_path) {
     try {
       const archived = archiveTranscript(
         payload.transcript_path,
-        state.id,  // Context ID, verified by existing code on line 98: saveState(state.id, ...)
+        state.id,
         sessionId,
         projectRoot,
       );
@@ -153,22 +123,12 @@ function main(): void {
     const latestPlanPath = findLatestPlan(state.id, projectRoot);
     if (latestPlanPath) {
       try {
-        const content = fs.readFileSync(latestPlanPath, "utf-8");
-        const normalized = normalizePlanContent(content);
-        const planHash = crypto
-          .createHash("sha256")
-          .update(normalized, "utf-8")
-          .digest("hex")
-          .slice(0, 12);
-
-        state.plan_hash = planHash;
-        state.plan_path = latestPlanPath;
-        state.plan_signature = content.slice(0, 200);
-        state.plan_id = generatePlanId();
-        state.plan_anchors = extractPlanAnchors(content);
-        state.work_consumed = state.work_consumed ?? false; // CHANGED: unified flag
-
-        logInfo("session_end", `Assigned plan fallback: hash=${planHash}`);
+        const content = fs.readFileSync(latestPlanPath, "utf8");
+        const fallback = computePlanFallback(state, content);
+        Object.assign(state, fallback, { plan_path: latestPlanPath });
+        if (fallback.plan_hash) {
+          logInfo("session_end", `Assigned plan fallback: hash=${fallback.plan_hash}`);
+        }
       } catch (error) {
         logError("session_end", `Failed to read plan: ${error}`);
       }
@@ -177,9 +137,7 @@ function main(): void {
 
   // Unified staging logic (replaces separate plan/handoff checks)
   const artifactType = determineArtifactType(state);
-  // Allow staging from active mode OR when session ends in plan mode (fixes plan mode staging bug)
-  const canStage = state.mode === "active" || permissionMode === "plan";
-  if (artifactType && canStage && !state.work_consumed) {
+  if (artifactType && shouldStage(state, permissionMode)) {
     state.mode = "has_staged_work"; // CHANGED: unified mode
     state.next_artifact_type = artifactType;
     logInfo("session_end", `Staged ${state.id}: ${state.mode} → has_staged_work (${artifactType})`);
@@ -195,3 +153,5 @@ function main(): void {
 }
 
 runHook(main, "session_end");
+
+

package/dist/templates/{_shared → core}/hooks-ts/session_start.ts

@@ -3,11 +3,6 @@
  * SessionStart hook: Restore context after /clear (plan/handoff) or compaction.
  * Routes by source field to appropriate handler.
  */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import {
-  loadHookInput, emitContext, runHookAsync,
-  logDebug, logInfo, logWarn, logDiagnostic,
-} from "../lib-ts/base/hook-utils.js";
 import {
   buildRestoreSections, formatHandoffContinuation, getModeDisplay,
   buildContextInventory,
@@ -15,6 +10,11 @@ import {
 import {
   getContextBySessionId, getAllContexts, bindSession, updateMode, determineArtifactType,
 } from "../lib-ts/context/context-store.js";
+import {
+  loadHookInput, emitContext, runHookAsync,
+  logDebug, logInfo, logWarn, logDiagnostic,
+} from "../lib-ts/hooks/hook-utils.js";
+import { getProjectRoot } from "../lib-ts/runtime/constants.js";
 
 
 /**

package/dist/templates/core/hooks-ts/task_create_capture.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env bun
+/**
+ * PostToolUse:TaskCreate hook: Persist Claude's TaskCreate calls to state.json.
+ */
+import { addTask } from "../lib-ts/context/task-tracker.js";
+import {
+  logError, logInfo, logWarn, requirePersistenceContext, runHook,
+} from "../lib-ts/hooks/hook-utils.js";
+
+function main(): void {
+  const context = requirePersistenceContext("TaskCreate", "task_create_capture");
+  if (!context) return;
+  const { toolInput, sessionId, projectRoot, state } = context;
+
+  const subject = toolInput.subject as string | undefined;
+  if (!subject) {
+    logWarn("task_create_capture", "TaskCreate missing subject field");
+    return;
+  }
+
+  const description = (toolInput.description as string) ?? "";
+  const activeForm = (toolInput.activeForm as string) ?? "";
+
+  const task = addTask(state.id, subject, description, activeForm, sessionId, projectRoot);
+  if (task) {
+    logInfo("task_create_capture", `Persisted task ${task.id}: ${subject}`);
+  } else {
+    logError("task_create_capture", `Failed to persist task: ${subject}`);
+  }
+}
+
+runHook(main, "task_create_capture");

package/dist/templates/{_shared → core}/hooks-ts/task_update_capture.ts

@@ -3,31 +3,15 @@
  * PostToolUse:TaskUpdate hook: Persist Claude's TaskUpdate calls to state.json.
  * Maps Claude's ephemeral task IDs to persistent aiw-N IDs.
  */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import {
-  checkSkipPersistence, getToolInput, loadHookInput, logDebug,
-  logError as _logError, logInfo, logWarn, runHook, validateHookEvent,
-} from "../lib-ts/base/hook-utils.js";
-import { getContextBySessionId } from "../lib-ts/context/context-store.js";
 import { deleteTask, updateTask } from "../lib-ts/context/task-tracker.js";
+import {
+  logInfo, logWarn, requirePersistenceContext, runHook,
+} from "../lib-ts/hooks/hook-utils.js";
 
 function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
-  if (!validateHookEvent(payload, "PostToolUse", "TaskUpdate")) return;
-
-  const toolInput = getToolInput(payload);
-  if (!toolInput) return;
-  if (checkSkipPersistence(payload, "task_update_capture")) return;
-
-  const projectRoot = getProjectRoot(payload.cwd);
-  const sessionId = payload.session_id ?? "unknown";
-
-  const state = getContextBySessionId(sessionId, projectRoot);
-  if (!state) {
-    logDebug("task_update_capture", `No context for session ${sessionId}`);
-    return;
-  }
+  const context = requirePersistenceContext("TaskUpdate", "task_update_capture");
+  if (!context) return;
+  const { toolInput, sessionId, projectRoot, state } = context;
 
   const claudeTaskId = toolInput.taskId as string | undefined;
   if (!claudeTaskId) {
@@ -36,7 +20,7 @@ function main(): void {
   }
 
   // Map Claude's ephemeral ID to persistent ID
-  const metadata = (toolInput.metadata ?? {}) as Record<string, any>;
+  const metadata = (toolInput.metadata ?? {}) as Record<string, unknown>;
   const persistentId = (metadata.persistent_id as string) ?? `aiw-${claudeTaskId}`;
 
   const status = toolInput.status as string | undefined;
@@ -53,7 +37,7 @@ function main(): void {
   }
 
   if (status) {
-    const opts: Record<string, any> = { status };
+    const opts: Record<string, unknown> = { status };
     if (metadata.evidence) opts.evidence = metadata.evidence;
     if (metadata.work_summary) opts.work_summary = metadata.work_summary;
     if (metadata.files_changed && Array.isArray(metadata.files_changed)) {
@@ -72,3 +56,4 @@ function main(): void {
 }
 
 runHook(main, "task_update_capture");
+

package/dist/templates/core/hooks-ts/user_prompt_submit.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+/**
+ * UserPromptSubmit hook: Context enforcement — ensures every prompt belongs
+ * to a tracked context. The most complex shared hook.
+ *
+ * Uses emitContext() for output — context text is passed via hookSpecificOutput JSON.
+ * Catches BlockRequest and uses emitBlock() to block the prompt.
+ */
+import {
+  loadHookInput, runHookAsync, logDebug, emitContext, emitBlock,
+} from "../lib-ts/hooks/hook-utils.js";
+import { executePromptBinding } from "../lib-ts/hooks/prompt-binding-logic.js";
+import { getProjectRoot } from "../lib-ts/runtime/constants.js";
+
+async function asyncMain(): Promise<void> {
+  const payload = loadHookInput();
+  if (!payload) return;
+
+  const prompt = (payload as unknown).prompt as string | undefined;
+  const sessionId = payload.session_id;
+  const permissionMode = payload.permission_mode ?? "";
+  const projectRoot = getProjectRoot(payload.cwd);
+
+  if (!sessionId) {
+    logDebug("user_prompt_submit", "No session_id");
+    return;
+  }
+
+  const result = await executePromptBinding(
+    prompt,
+    sessionId,
+    permissionMode,
+    projectRoot,
+  );
+  if (result.blockedReason) {
+    emitBlock(result.blockedReason);
+    return;
+  }
+
+  if (result.outputs.length > 0) {
+    emitContext(result.outputs.join("\n\n"));
+  }
+}
+
+runHookAsync(asyncMain, "user_prompt_submit");
+

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/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);
 }
+
+