aiwcli 0.15.5 → 0.15.7

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

@@ -3,53 +3,28 @@
  * PostToolUse:* hook: Monitor context window usage, trigger mode transitions,
  * and progressive-save state when context runs low.
  */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
+import { getContextBySessionId, saveState } from "../lib-ts/context/context-store.js";
+import { selectWarningMessage } from "../lib-ts/hooks/context-monitor-logic.js";
 import {
   emitContext, getContextPercentRemaining, hookLog,
-  loadHookInput,
-  logDebug, logDiagnostic, logInfo, logWarn, runHook,
-} from "../lib-ts/base/hook-utils.js";
-import { nowIso } from "../lib-ts/base/utils.js";
-import { getContextBySessionId, maybeActivate, saveState } from "../lib-ts/context/context-store.js";
+  requireBoundSession, logDebug, logDiagnostic, logInfo, runHook, safeMaybeActivate,
+} from "../lib-ts/hooks/hook-utils.js";
+import { nowIso } from "../lib-ts/runtime/utils.js";
 import type { ContextState } from "../lib-ts/types.js";
 
 const WRITE_TOOLS = new Set(["Bash", "Edit", "NotebookEdit", "Write"]);
 
 const SAVE_STATE_THRESHOLD = 60;
 
-const CONTEXT_WARNING_30 = "## Context Window: ~30% Remaining\n\n" +
-  "This session is approaching its context limit. Consider:\n\n" +
-  "- Completing your current task, then pausing for the user to decide next steps\n" +
-  "- If significant work remains, mention that `/aiwcli-shared:handoff` can capture progress " +
-  "for a fresh session\n\n" +
-  "Do not rush or cut corners — finish the current task properly. " +
-  "Just be aware that starting large new tasks may not complete before context runs out.";
-
-const CONTEXT_WARNING_15 = "## Context Window: ~15% Remaining — Wrap Up Now\n\n" +
-  "Context is critically low. After completing your current step:\n\n" +
-  "1. **Stop taking on new work**\n" +
-  "2. Summarize what was accomplished and what remains\n" +
-  "3. Offer to run `/aiwcli-shared:handoff` so progress transfers to a fresh session\n\n" +
-  "Do not start new multi-step tasks. Focus on clean closure.";
-
-const WARNING_THRESHOLDS = [
-  { pct: 15, msg: CONTEXT_WARNING_15 },  // Most urgent first
-  { pct: 30, msg: CONTEXT_WARNING_30 },
-];
-
-/** Transition idle/has_plan → active when implementation tools are used. */
+/** Transition idle/has_staged_work → active when implementation tools are used. */
 function checkAndTransitionMode(
-  state: ContextState,
+  stateId: string,
   toolName: string | undefined,
   permissionMode: string,
   projectRoot: string,
 ): void {
   if (!toolName || !WRITE_TOOLS.has(toolName)) return;
-  try {
-    maybeActivate(state.id, permissionMode, projectRoot, "context_monitor");
-  } catch (error) {
-    logWarn("context_monitor", `maybeActivate failed (non-critical): ${error}`);
-  }
+  safeMaybeActivate(stateId, permissionMode, projectRoot, "context_monitor");
 }
 
 /** Save state snapshot at SAVE_STATE_THRESHOLD. */
@@ -82,38 +57,31 @@ function checkContextWarnings(
     state.last_session = {};
   }
   const fired = state.last_session.context_warnings_fired ?? [];
-
-  for (const { pct, msg } of WARNING_THRESHOLDS) {
-    if (pctRemaining <= pct && !fired.includes(pct)) {
-      emitContext(msg);
-      state.last_session.context_warnings_fired = [...fired, pct];
-      saveState(state.id, state, projectRoot);
-      logInfo("context_monitor", `Context warning emitted at ${pct}% threshold`);
-      return; // One warning per tool call — most urgent fires first
-    }
-  }
+  const warning = selectWarningMessage(pctRemaining, fired);
+  if (!warning) return;
+
+  emitContext(warning.msg);
+  state.last_session.context_warnings_fired = [...fired, warning.pct];
+  saveState(state.id, state, projectRoot);
+  logInfo(
+    "context_monitor",
+    `Context warning emitted at ${warning.pct}% threshold`,
+  );
 }
 
 function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
+  const bound = requireBoundSession("context_monitor");
+  if (!bound) return;
 
-  const sessionId = payload.session_id;
-  if (!sessionId) return;
-
-  const projectRoot = getProjectRoot(payload.cwd);
+  const { payload, sessionId, projectRoot } = bound;
   const permissionMode = payload.permission_mode ?? "";
   const toolName = payload.tool_name;
 
   // Initial context lookup
-  let state = getContextBySessionId(sessionId, projectRoot);
-  if (!state) {
-    logDebug("context_monitor", `No context for session ${sessionId}`);
-    return;
-  }
+  let state = bound.state;
 
   // Phase 1: Mode transition for write tools
-  checkAndTransitionMode(state, toolName, permissionMode, projectRoot);
+  checkAndTransitionMode(state.id, toolName, permissionMode, projectRoot);
 
   // Phase 2: Context window check (log only, no warnings emitted)
   const [pctRemaining, tokensUsed, maxTokens] = getContextPercentRemaining(payload);

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

@@ -4,11 +4,11 @@
  * Outputs a plain JSON array (NOT hookSpecificOutput).
  */
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
-import { getContextFilePath, getContextHandoffsDir, getContextPlansDir, getContextReviewsDir, getProjectRoot } from "../lib-ts/base/constants.js";
-import { loadHookInput, logDebug, logError, runHook } from "../lib-ts/base/hook-utils.js";
 import { getAllContexts, getContextBySessionId } from "../lib-ts/context/context-store.js";
+import { loadHookInput, logDebug, logError, runHook } from "../lib-ts/hooks/hook-utils.js";
+import { getContextFilePath, getContextHandoffsDir, getContextPlansDir, getContextReviewsDir, getProjectRoot } from "../lib-ts/runtime/constants.js";
 import type { ContextState } from "../lib-ts/types.js";
 
 /** Get .md files sorted by mtime descending */
@@ -128,3 +128,4 @@ function main(): void {
 }
 
 runHook(main, "file-suggestion");
+

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

@@ -3,11 +3,11 @@
  * PostToolUse:Write|Edit hook: Run linter on edited files, feed errors to Claude.
  * Uses emitContext() for non-blocking context injection — Claude sees errors and self-corrects.
  */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
 import {
-  emitContext, getToolInput, loadHookInput, logDebug, runHook,
-} from "../lib-ts/base/hook-utils.js";
-import { formatLintErrors, getLinterForFile, runLinter } from "../lib-ts/base/lint-dispatch.js";
+  emitContext, logDebug, requireToolInput, runHook,
+} from "../lib-ts/hooks/hook-utils.js";
+import { getProjectRoot } from "../lib-ts/runtime/constants.js";
+import { formatLintErrors, getLinterForFile, runLinter } from "../lib-ts/runtime/lint-dispatch.js";
 
 // Extensions with no lint value
 const SKIP_EXTENSIONS = new Set([
@@ -31,11 +31,9 @@ function shouldSkip(filePath: string): boolean {
 }
 
 function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
-
-  const toolInput = getToolInput(payload);
-  if (!toolInput) return;
+  const context = requireToolInput("lint_after_edit");
+  if (!context) return;
+  const { payload, toolInput } = context;
 
   const filePath = toolInput.file_path as string | undefined;
   if (!filePath) return;

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

@@ -3,13 +3,13 @@
  * PreCompact hook: Save state.json snapshot before context compaction.
  * Captures git state and session metadata for recovery.
  */
-import { getProjectRoot } from "../lib-ts/base/constants.js";
-import { getGitState } from "../lib-ts/base/git-state.js";
+import { getContextBySessionId, saveState } from "../lib-ts/context/context-store.js";
 import {
   loadHookInput, logDebug, logError, logInfo, runHook,
-} from "../lib-ts/base/hook-utils.js";
-import { nowIso } from "../lib-ts/base/utils.js";
-import { getContextBySessionId, saveState } from "../lib-ts/context/context-store.js";
+} from "../lib-ts/hooks/hook-utils.js";
+import { getProjectRoot } from "../lib-ts/runtime/constants.js";
+import { getGitState } from "../lib-ts/runtime/git-state.js";
+import { nowIso } from "../lib-ts/runtime/utils.js";
 
 function main(): void {
   const payload = loadHookInput();

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");
+