refactor: wave 2 - split atlas, auto-update-checker, session-recovery, todo-enforcer, background-task hooks

- Extract atlas/ into 15 focused modules (hook, event handler, tool policies, types, etc.)
- Split auto-update-checker into checker/ and hook/ subdirectories with single-purpose files
- Decompose session-recovery into separate recovery strategy files per error type
- Extract todo-continuation-enforcer from monolith to directory with dedicated modules
- Split background-task/tools.ts into individual tool creator files
- Extract command-executor, tmux-utils into focused sub-modules
- Split config/schema.ts into domain-specific schema files
- Decompose cli/config-manager.ts into focused modules
- Rollback skill-mcp-manager, model-availability, index.ts splits that broke tests
- Fix all import path depths for moved files (../../ -> ../../../)
- Add explicit type annotations to resolve TS7006 implicit any errors

Typecheck: 0 errors
Tests: 2359 pass, 5 fail (all pre-existing)

src/hooks/session-recovery/storage/empty-messages.ts

@@ -0,0 +1,47 @@
+import { messageHasContent } from "./part-content"
+import { readMessages } from "./messages-reader"
+
+export function findEmptyMessages(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const emptyIds: string[] = []
+
+  for (const msg of messages) {
+    if (!messageHasContent(msg.id)) {
+      emptyIds.push(msg.id)
+    }
+  }
+
+  return emptyIds
+}
+
+export function findEmptyMessageByIndex(sessionID: string, targetIndex: number): string | null {
+  const messages = readMessages(sessionID)
+
+  const indicesToTry = [
+    targetIndex,
+    targetIndex - 1,
+    targetIndex + 1,
+    targetIndex - 2,
+    targetIndex + 2,
+    targetIndex - 3,
+    targetIndex - 4,
+    targetIndex - 5,
+  ]
+
+  for (const index of indicesToTry) {
+    if (index < 0 || index >= messages.length) continue
+
+    const targetMessage = messages[index]
+
+    if (!messageHasContent(targetMessage.id)) {
+      return targetMessage.id
+    }
+  }
+
+  return null
+}
+
+export function findFirstEmptyMessage(sessionID: string): string | null {
+  const emptyIds = findEmptyMessages(sessionID)
+  return emptyIds.length > 0 ? emptyIds[0] : null
+}

src/hooks/session-recovery/storage/empty-text.ts

@@ -0,0 +1,55 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { PART_STORAGE } from "../constants"
+import type { StoredPart, StoredTextPart } from "../types"
+import { readMessages } from "./messages-reader"
+import { readParts } from "./parts-reader"
+
+export function replaceEmptyTextParts(messageID: string, replacementText: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+  if (!existsSync(partDir)) return false
+
+  let anyReplaced = false
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const filePath = join(partDir, file)
+      const content = readFileSync(filePath, "utf-8")
+      const part = JSON.parse(content) as StoredPart
+
+      if (part.type === "text") {
+        const textPart = part as StoredTextPart
+        if (!textPart.text?.trim()) {
+          textPart.text = replacementText
+          textPart.synthetic = true
+          writeFileSync(filePath, JSON.stringify(textPart, null, 2))
+          anyReplaced = true
+        }
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return anyReplaced
+}
+
+export function findMessagesWithEmptyTextParts(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (const msg of messages) {
+    const parts = readParts(msg.id)
+    const hasEmptyTextPart = parts.some((part) => {
+      if (part.type !== "text") return false
+      const textPart = part as StoredTextPart
+      return !textPart.text?.trim()
+    })
+
+    if (hasEmptyTextPart) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}

src/hooks/session-recovery/storage/message-dir.ts

@@ -0,0 +1,21 @@
+import { existsSync, readdirSync } from "node:fs"
+import { join } from "node:path"
+import { MESSAGE_STORAGE } from "../constants"
+
+export function getMessageDir(sessionID: string): string {
+  if (!existsSync(MESSAGE_STORAGE)) return ""
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) {
+    return directPath
+  }
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) {
+      return sessionPath
+    }
+  }
+
+  return ""
+}

src/hooks/session-recovery/storage/messages-reader.ts

@@ -0,0 +1,27 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import type { StoredMessageMeta } from "../types"
+import { getMessageDir } from "./message-dir"
+
+export function readMessages(sessionID: string): StoredMessageMeta[] {
+  const messageDir = getMessageDir(sessionID)
+  if (!messageDir || !existsSync(messageDir)) return []
+
+  const messages: StoredMessageMeta[] = []
+  for (const file of readdirSync(messageDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const content = readFileSync(join(messageDir, file), "utf-8")
+      messages.push(JSON.parse(content))
+    } catch {
+      continue
+    }
+  }
+
+  return messages.sort((a, b) => {
+    const aTime = a.time?.created ?? 0
+    const bTime = b.time?.created ?? 0
+    if (aTime !== bTime) return aTime - bTime
+    return a.id.localeCompare(b.id)
+  })
+}

src/hooks/session-recovery/storage/orphan-thinking-search.ts

@@ -0,0 +1,43 @@
+import { THINKING_TYPES } from "../constants"
+import { readMessages } from "./messages-reader"
+import { readParts } from "./parts-reader"
+
+export function findMessagesWithOrphanThinking(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue
+
+    const parts = readParts(msg.id)
+    if (parts.length === 0) continue
+
+    const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id))
+    const firstPart = sortedParts[0]
+    const firstIsThinking = THINKING_TYPES.has(firstPart.type)
+
+    if (!firstIsThinking) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}
+
+export function findMessageByIndexNeedingThinking(sessionID: string, targetIndex: number): string | null {
+  const messages = readMessages(sessionID)
+
+  if (targetIndex < 0 || targetIndex >= messages.length) return null
+
+  const targetMessage = messages[targetIndex]
+  if (targetMessage.role !== "assistant") return null
+
+  const parts = readParts(targetMessage.id)
+  if (parts.length === 0) return null
+
+  const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id))
+  const firstPart = sortedParts[0]
+  const firstIsThinking = THINKING_TYPES.has(firstPart.type)
+
+  return firstIsThinking ? null : targetMessage.id
+}

src/hooks/session-recovery/storage/part-content.ts

@@ -0,0 +1,28 @@
+import { THINKING_TYPES, META_TYPES } from "../constants"
+import type { StoredPart, StoredTextPart } from "../types"
+import { readParts } from "./parts-reader"
+
+export function hasContent(part: StoredPart): boolean {
+  if (THINKING_TYPES.has(part.type)) return false
+  if (META_TYPES.has(part.type)) return false
+
+  if (part.type === "text") {
+    const textPart = part as StoredTextPart
+    return !!textPart.text?.trim()
+  }
+
+  if (part.type === "tool" || part.type === "tool_use") {
+    return true
+  }
+
+  if (part.type === "tool_result") {
+    return true
+  }
+
+  return false
+}
+
+export function messageHasContent(messageID: string): boolean {
+  const parts = readParts(messageID)
+  return parts.some(hasContent)
+}

src/hooks/session-recovery/storage/part-id.ts

@@ -0,0 +1,5 @@
+export function generatePartId(): string {
+  const timestamp = Date.now().toString(16)
+  const random = Math.random().toString(36).substring(2, 10)
+  return `prt_${timestamp}${random}`
+}

src/hooks/session-recovery/storage/parts-reader.ts

@@ -0,0 +1,22 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { PART_STORAGE } from "../constants"
+import type { StoredPart } from "../types"
+
+export function readParts(messageID: string): StoredPart[] {
+  const partDir = join(PART_STORAGE, messageID)
+  if (!existsSync(partDir)) return []
+
+  const parts: StoredPart[] = []
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const content = readFileSync(join(partDir, file), "utf-8")
+      parts.push(JSON.parse(content))
+    } catch {
+      continue
+    }
+  }
+
+  return parts
+}

src/hooks/session-recovery/storage/text-part-injector.ts

@@ -0,0 +1,30 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { PART_STORAGE } from "../constants"
+import type { StoredTextPart } from "../types"
+import { generatePartId } from "./part-id"
+
+export function injectTextPart(sessionID: string, messageID: string, text: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true })
+  }
+
+  const partId = generatePartId()
+  const part: StoredTextPart = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "text",
+    text,
+    synthetic: true,
+  }
+
+  try {
+    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2))
+    return true
+  } catch {
+    return false
+  }
+}

src/hooks/session-recovery/storage/thinking-block-search.ts

@@ -0,0 +1,42 @@
+import { THINKING_TYPES } from "../constants"
+import { hasContent } from "./part-content"
+import { readMessages } from "./messages-reader"
+import { readParts } from "./parts-reader"
+
+export function findMessagesWithThinkingBlocks(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue
+
+    const parts = readParts(msg.id)
+    const hasThinking = parts.some((part) => THINKING_TYPES.has(part.type))
+    if (hasThinking) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}
+
+export function findMessagesWithThinkingOnly(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue
+
+    const parts = readParts(msg.id)
+    if (parts.length === 0) continue
+
+    const hasThinking = parts.some((part) => THINKING_TYPES.has(part.type))
+    const hasTextContent = parts.some(hasContent)
+
+    if (hasThinking && !hasTextContent) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}

src/hooks/session-recovery/storage/thinking-prepend.ts

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { PART_STORAGE, THINKING_TYPES } from "../constants"
+import { readMessages } from "./messages-reader"
+import { readParts } from "./parts-reader"
+
+function findLastThinkingContent(sessionID: string, beforeMessageID: string): string {
+  const messages = readMessages(sessionID)
+
+  const currentIndex = messages.findIndex((message) => message.id === beforeMessageID)
+  if (currentIndex === -1) return ""
+
+  for (let i = currentIndex - 1; i >= 0; i--) {
+    const message = messages[i]
+    if (message.role !== "assistant") continue
+
+    const parts = readParts(message.id)
+    for (const part of parts) {
+      if (THINKING_TYPES.has(part.type)) {
+        const thinking = (part as { thinking?: string; text?: string }).thinking
+        const reasoning = (part as { thinking?: string; text?: string }).text
+        const content = thinking || reasoning
+        if (content && content.trim().length > 0) {
+          return content
+        }
+      }
+    }
+  }
+
+  return ""
+}
+
+export function prependThinkingPart(sessionID: string, messageID: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+
+  if (!existsSync(partDir)) {
+    mkdirSync(partDir, { recursive: true })
+  }
+
+  const previousThinking = findLastThinkingContent(sessionID, messageID)
+
+  const partId = "prt_0000000000_thinking"
+  const part = {
+    id: partId,
+    sessionID,
+    messageID,
+    type: "thinking",
+    thinking: previousThinking || "[Continuing from previous reasoning]",
+    synthetic: true,
+  }
+
+  try {
+    writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2))
+    return true
+  } catch {
+    return false
+  }
+}

src/hooks/session-recovery/storage/thinking-strip.ts

@@ -0,0 +1,27 @@
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs"
+import { join } from "node:path"
+import { PART_STORAGE, THINKING_TYPES } from "../constants"
+import type { StoredPart } from "../types"
+
+export function stripThinkingParts(messageID: string): boolean {
+  const partDir = join(PART_STORAGE, messageID)
+  if (!existsSync(partDir)) return false
+
+  let anyRemoved = false
+  for (const file of readdirSync(partDir)) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const filePath = join(partDir, file)
+      const content = readFileSync(filePath, "utf-8")
+      const part = JSON.parse(content) as StoredPart
+      if (THINKING_TYPES.has(part.type)) {
+        unlinkSync(filePath)
+        anyRemoved = true
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return anyRemoved
+}