@angli/unit-test-tool 0.1.0

package/src/core/executor/claude-cli-executor.ts

@@ -0,0 +1,94 @@
+import type {
+  ClaudeCliExecutionInput,
+  ClaudeCliExecutionResult
+} from '../../types/index.js'
+import { execa } from 'execa'
+import path from 'node:path'
+import fs from 'node:fs/promises'
+
+export async function executeClaudeCli(
+  input: ClaudeCliExecutionInput
+): Promise<ClaudeCliExecutionResult> {
+  const startedAt = Date.now()
+  const heartbeatMs = 10000
+  let heartbeat: ReturnType<typeof setInterval> | undefined
+  try {
+    if (input.onProgress) {
+      heartbeat = setInterval(() => {
+        input.onProgress?.(Date.now() - startedAt)
+      }, heartbeatMs)
+    }
+
+    const args: string[] = ['-p', input.prompt]
+    if (input.outputFormat) args.push('--output-format', input.outputFormat)
+    if (input.systemPrompt) args.push('--system-prompt', input.systemPrompt)
+    if (input.appendSystemPrompt) args.push('--append-system-prompt', input.appendSystemPrompt)
+    if (input.allowedTools?.length) args.push('--allowedTools', input.allowedTools.join(','))
+    if (input.permissionMode) args.push('--permission-mode', input.permissionMode)
+    if (input.timeoutMs) args.push('--timeout', String(input.timeoutMs))
+
+    const result = await execa('claude', args, {
+      cwd: input.cwd,
+      reject: false,
+      timeout: input.timeoutMs ?? 120000,
+      stdin: 'ignore',
+      env: await buildClaudeEnv(input.cwd)
+    })
+
+    if (heartbeat) clearInterval(heartbeat)
+
+    return {
+      ok: result.exitCode === 0,
+      exitCode: result.exitCode ?? null,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      durationMs: Date.now() - startedAt,
+      taskMeta: input.taskMeta,
+      failureCategory: result.exitCode === 0 ? undefined : 'CLI_EXIT_NON_ZERO'
+    }
+  } catch (error) {
+    if (heartbeat) clearInterval(heartbeat)
+
+    const message = error instanceof Error ? error.message : String(error)
+    const category = message.includes('ENOENT')
+      ? 'CLI_NOT_FOUND'
+      : message.toLowerCase().includes('timed out')
+        ? 'CLI_TIMEOUT'
+        : 'RUNTIME_ENV_ERROR'
+    return {
+      ok: false,
+      exitCode: null,
+      stdout: '',
+      stderr: message,
+      durationMs: Date.now() - startedAt,
+      failureCategory: category,
+      taskMeta: input.taskMeta
+    }
+  }
+}
+
+async function buildClaudeEnv(cwd: string): Promise<NodeJS.ProcessEnv> {
+  const projectEnv = await loadProjectClaudeEnv(cwd)
+  return {
+    ...process.env,
+    ...(process.env.ANTHROPIC_BASE_URL ? { ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL } : {}),
+    ...(process.env.ANTHROPIC_AUTH_TOKEN ? { ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN } : {}),
+    ...projectEnv
+  }
+}
+
+async function loadProjectClaudeEnv(cwd: string): Promise<Partial<NodeJS.ProcessEnv>> {
+  try {
+    const configPath = path.join(cwd, '.claude', 'settings.local.json')
+    const raw = await fs.readFile(configPath, 'utf-8')
+    const parsed = JSON.parse(raw) as { env?: Record<string, string> }
+    const env = parsed?.env ?? {}
+    const result: Record<string, string> = {}
+    if (env.ANTHROPIC_BASE_URL) result.ANTHROPIC_BASE_URL = env.ANTHROPIC_BASE_URL
+    if (env.ANTHROPIC_AUTH_TOKEN) result.ANTHROPIC_AUTH_TOKEN = env.ANTHROPIC_AUTH_TOKEN
+    return result
+  } catch {
+    return {}
+  }
+}
+

package/src/core/middleware/loop-detection.ts

@@ -0,0 +1,8 @@
+import type { TaskItem } from '../../types/index.js'
+
+export function loopDetection(task: TaskItem, threshold: number): { loopDetected: boolean } {
+  if (task.attemptCount >= threshold) {
+    return { loopDetected: true }
+  }
+  return { loopDetected: false }
+}

package/src/core/middleware/pre-completion-checklist.ts

@@ -0,0 +1,32 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { BaseToolResult } from '../../types/index.js'
+
+export async function preCompletionChecklist(ctx: AppContext): Promise<BaseToolResult> {
+  const lint = await ctx.commandRunner.run(ctx.commands.lint)
+  if (lint.exitCode !== 0) {
+    return {
+      ok: false,
+      phase: 'VERIFYING_FULL',
+      summary: 'lint 失败',
+      nextAction: 'manual-intervention',
+      artifacts: { stderr: lint.stderr }
+    }
+  }
+
+  const typecheck = await ctx.commandRunner.run(ctx.commands.typecheck)
+  if (typecheck.exitCode !== 0) {
+    return {
+      ok: false,
+      phase: 'VERIFYING_FULL',
+      summary: 'typecheck 失败',
+      nextAction: 'manual-intervention',
+      artifacts: { stderr: typecheck.stderr }
+    }
+  }
+
+  return {
+    ok: true,
+    phase: 'VERIFYING_FULL',
+    summary: 'checklist passed'
+  }
+}

package/src/core/middleware/silent-success-post-check.ts

@@ -0,0 +1,16 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { BaseToolResult } from '../../types/index.js'
+
+export async function silentSuccessPostCheck(ctx: AppContext, targetFile?: string): Promise<BaseToolResult> {
+  const result = await ctx.commandRunner.run(ctx.commands.incrementalTest(targetFile))
+  return {
+    ok: result.exitCode === 0,
+    phase: 'VERIFYING_FULL',
+    summary: result.exitCode === 0 ? 'incremental check passed' : 'incremental check failed',
+    nextAction: result.exitCode === 0 ? 'verify' : 'manual-intervention',
+    artifacts: {
+      stdout: result.stdout,
+      stderr: result.stderr
+    }
+  }
+}

package/src/core/planner/rank-candidates.ts

@@ -0,0 +1,5 @@
+import type { RuleRankedCandidate } from '../../types/index.js'
+
+export function rankCandidates(candidates: RuleRankedCandidate[]): RuleRankedCandidate[] {
+  return [...candidates].sort((a, b) => b.baseScore - a.baseScore)
+}

package/src/core/planner/rule-planner.ts

@@ -0,0 +1,65 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { CandidateFile, CoverageSnapshot, RuleRankedCandidate } from '../../types/index.js'
+import { runAnalyzers } from '../analyzers/index.js'
+import { buildRuleCandidate } from './score-candidate.js'
+import { rankCandidates } from './rank-candidates.js'
+import { pathPriorityAnalyzer } from '../analyzers/path-priority-analyzer.js'
+
+export async function rulePlanner(
+  ctx: AppContext,
+  candidates: CandidateFile[],
+  coverageSnapshot?: CoverageSnapshot
+): Promise<RuleRankedCandidate[]> {
+  const startedAt = Date.now()
+  const logEvery = 200
+
+  const filtered = candidates.filter((candidate) => {
+    const pathPriority = pathPriorityAnalyzer(candidate, ctx.config)
+    return pathPriority.label !== 'excluded'
+  })
+
+  ctx.logger.info(`[run] step=rank status=filter total=${candidates.length} remaining=${filtered.length}`)
+
+  const ranked = await mapWithConcurrency(filtered, Math.max(1, Math.min(ctx.limits.concurrency || 8, 16)), async (candidate, index) => {
+    if (index === 0 || (index + 1) % logEvery === 0 || index + 1 === filtered.length) {
+      ctx.logger.info(
+        `[run] step=rank status=progress current=${index + 1} total=${filtered.length} elapsedMs=${Date.now() - startedAt}`
+      )
+    }
+
+    const { facts } = await runAnalyzers(ctx, candidate, coverageSnapshot)
+    if (facts.pathPriority.label === 'excluded') return undefined
+    return buildRuleCandidate(candidate, facts)
+  })
+
+  const selected = ranked.filter((item): item is RuleRankedCandidate => Boolean(item))
+
+  ctx.logger.info(
+    `[run] step=rank status=done total=${filtered.length} selected=${selected.length} elapsedMs=${Date.now() - startedAt}`
+  )
+
+  return rankCandidates(selected).map((candidate, index) => ({
+    ...candidate,
+    taskId: `${ctx.runId}-${String(index + 1).padStart(3, '0')}`
+  }))
+}
+
+async function mapWithConcurrency<T, R>(
+  items: T[],
+  concurrency: number,
+  mapper: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = new Array(items.length)
+  let nextIndex = 0
+
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex
+      nextIndex += 1
+      results[currentIndex] = await mapper(items[currentIndex], currentIndex)
+    }
+  })
+
+  await Promise.all(workers)
+  return results
+}

package/src/core/planner/score-candidate.ts

@@ -0,0 +1,60 @@
+import type { AnalyzerFacts, CandidateFile, RuleRankedCandidate } from '../../types/index.js'
+
+export function scoreCandidate(facts: AnalyzerFacts): { baseScore: number; reasons: string[] } {
+  const reasons: string[] = []
+  let score = 0
+
+  if (facts.pathPriority.label === 'priority') {
+    score += 100
+    reasons.push('priority-path')
+  }
+  if (facts.pathPriority.label === 'deferred') {
+    score -= 100
+    reasons.push('deferred-path')
+  }
+
+  if (facts.coverage.coverageGap && facts.coverage.coverageGap > 0) {
+    score += Math.min(30, facts.coverage.coverageGap)
+    reasons.push('coverage-gap')
+  }
+
+  if (facts.dependencyComplexity.complexityLevel === 'low') {
+    score += 10
+    reasons.push('low-complexity')
+  }
+  if (facts.dependencyComplexity.complexityLevel === 'high') {
+    score -= 10
+    reasons.push('high-complexity')
+  }
+
+  if (facts.existingTest.hasExistingTest) {
+    score += 5
+    reasons.push('existing-tests')
+  }
+
+  score += facts.failureHistory.failurePenaltyScore
+  if (facts.failureHistory.failurePenaltyScore < 0) {
+    reasons.push('failure-penalty')
+  }
+
+  return { baseScore: score, reasons }
+}
+
+export function buildRuleCandidate(candidate: CandidateFile, facts: AnalyzerFacts): RuleRankedCandidate {
+  const { baseScore, reasons } = scoreCandidate(facts)
+  const estimatedDifficulty = facts.dependencyComplexity.complexityLevel
+
+  return {
+    taskId: '',
+    targetFile: candidate.targetFile,
+    baseScore,
+    pathPriority:
+      facts.pathPriority.label === 'priority' || facts.pathPriority.label === 'deferred'
+        ? facts.pathPriority.label
+        : 'normal',
+    estimatedDifficulty,
+    reasons,
+    suggestedStrategy: facts.fileClassification.ruleCategory,
+    analyzerFacts: facts
+  }
+}

package/src/core/prompts/case-library.ts

@@ -0,0 +1,36 @@
+const DEFAULT_CASE_LIBRARY = [
+  {
+    title: '普通组件',
+    lines: [
+      '先覆盖组件自身公开职责：computed、methods、事件分发、关键状态切换。',
+      '子组件只做 stub 或最小替身，不断言其内部 DOM 结构。',
+      '优先断言输入输出、事件、副作用和关键分支，不为凑覆盖率补无价值 snapshot。'
+    ]
+  },
+  {
+    title: 'render/HOC 包装组件',
+    lines: [
+      '把测试重点放在 render(h) 传给子组件的参数：props、attrs、on、scopedSlots。',
+      '验证包装层派生参数是否正确，例如附加的 fullHeight、stateServiceParams。',
+      '不要把最终渲染 DOM、data-* 标记、第三方包装细节当成主断言。'
+    ]
+  },
+  {
+    title: '强依赖上下文组件',
+    lines: [
+      '在实例创建前准备好上下文依赖（如 provide/mocks/props/data），避免 created/mounted 后再补写。',
+      '只 mock 当前组件直接依赖的边界接口，例如 context、service、plugin，避免把整条调用链都模拟一遍。',
+      '优先断言上下文输入如何影响当前组件状态、调用参数和容错分支。'
+    ]
+  }
+] as const
+
+export function buildCaseLibraryPrompt(): string {
+  return [
+    '典型案例约束：',
+    ...DEFAULT_CASE_LIBRARY.flatMap((item) => [
+      `- ${item.title}：`,
+      ...item.lines.map((line) => `  - ${line}`)
+    ])
+  ].join('\n')
+}

package/src/core/prompts/edit-boundary-prompt.ts

@@ -0,0 +1,26 @@
+import type { TaskItem } from '../../types/index.js'
+
+export function buildEditBoundaryPrompt(task: TaskItem): string {
+  const preferredTestDirs = task.testDirNames?.join(', ') || '__test__, __tests__'
+  const relatedTests = task.testFiles.length > 0 ? task.testFiles : []
+  const targetDir = task.targetFile.includes('/') ? task.targetFile.slice(0, task.targetFile.lastIndexOf('/')) : '.'
+  return [
+    '本轮允许修改的文件范围：',
+    ...(relatedTests.length > 0
+      ? relatedTests
+      : [
+          `优先只允许在 ${targetDir} 同级或子级创建/修改测试文件`,
+          `仅当目标模块附近已有明确测试约定时，才允许使用 ${preferredTestDirs}`
+        ]),
+    '',
+    '强约束：',
+    '- 必须新增或修改与目标直接相关的测试文件，否则本轮视为失败',
+    '- 默认不要把新测试放到 src/__tests__ 这类聚合目录，除非目标模块附近已有同类约定',
+    '',
+    '禁止修改：',
+    `- 与 ${task.targetFile} 无关的源码`,
+    `- ${task.targetFile} 本身（如发现源码问题，仅记录待办）`,
+    '- package.json、tsconfig、构建配置、测试框架配置',
+    '- 其他无关测试文件'
+  ].join('\n')
+}

package/src/core/prompts/retry-prompt.ts

@@ -0,0 +1,22 @@
+import type { TaskItem, PromptOverridesConfig } from '../../types/index.js'
+
+export function buildRetryPrompt(task: TaskItem, failure: string, overrides?: PromptOverridesConfig): string {
+  const lines = [
+    `上一次为 ${task.targetFile} 的补测尝试未通过，请只针对当前失败修正。`,
+    `失败摘要：${failure}`,
+    `上轮策略：${task.strategy}`,
+    '本轮要求：',
+    '- 只修复失败日志中暴露的问题',
+    '- 不扩大改动范围，不修改无关文件',
+    '- 优先修复断言、mock、类型、测试环境问题',
+    '- 如果失败来自 render/HOC 测试不稳定，回到组件职责重新设计断言，不要继续堆叠 DOM 或 mock 细节',
+    '- 优先收敛到最小稳定断言，而不是修补脆弱测试',
+    '- 修复后再次确保验证通过'
+  ]
+
+  if (overrides?.retryAppend) {
+    lines.push('', '项目重试补充要求：', overrides.retryAppend)
+  }
+
+  return lines.join('\n')
+}

package/src/core/prompts/system-prompt.ts

@@ -0,0 +1,32 @@
+import type { PromptOverridesConfig } from '../../types/index.js'
+import { buildCaseLibraryPrompt } from './case-library.js'
+
+const DEFAULT_TEST_STRATEGY_GUIDELINES = [
+  '生成测试前先识别模块类型：工具函数/普通组件/交互组件/render-only/HOC/强依赖上下文。',
+  '只测试当前模块职责，不测试子组件或第三方内部行为。',
+  'render-only 或 HOC wrapper：优先测试 render 参数传递与 props/attrs/listeners/scopedSlots 透传，避免依赖最终 DOM。',
+  '禁止直接改写 Vue 只读属性（如 $attrs/$listeners/$scopedSlots）。',
+  '优先稳定断言（调用参数/事件/状态/关键分支），避免脆弱 DOM/snapshot 断言。'
+]
+
+export function buildSystemPrompt(overrides?: PromptOverridesConfig): string {
+  const base = [
+    '你是 Claude CLI 驱动的单元测试补齐执行器。',
+    '你只负责当前 target 的补测或修复，不负责全局规划。',
+    '优先复用项目现有测试风格，通过最小改动完成任务。',
+    '除非提示中明确允许，否则不要修改业务源码；只能修改目标测试文件及必要的新测试文件。',
+    '不要做与当前 target 无关的重构、批量迁移或配置改造。',
+    '完成后输出简洁摘要：修改文件列表、验证结果、剩余问题。',
+    '',
+    '通用单测策略：',
+    ...DEFAULT_TEST_STRATEGY_GUIDELINES.map((line) => `- ${line}`),
+    '',
+    buildCaseLibraryPrompt()
+  ]
+
+  if (overrides?.systemAppend) {
+    base.push('', '项目覆盖规则：', overrides.systemAppend)
+  }
+
+  return base.join('\n')
+}

package/src/core/prompts/task-prompt.ts

@@ -0,0 +1,26 @@
+import type { TaskItem, PromptOverridesConfig } from '../../types/index.js'
+
+export function buildTaskPrompt(task: TaskItem, overrides?: PromptOverridesConfig): string {
+  const preferredTestDirs = task.testDirNames?.join(', ') || '__test__, __tests__'
+  const lines = [
+    `任务目标：为 ${task.targetFile} 补充或修复单元测试。`,
+    `建议优先检查的测试文件：${task.testFiles.join(', ') || '当前仓库中没有明显同名测试，请优先在目标模块附近新建测试文件'}`,
+    `新测试文件优先放置目录：优先在目标模块同级或子级的 ${preferredTestDirs} 中创建；仅当项目已有明确聚合约定且就近放置不合适时，才考虑使用聚合测试目录。`,
+    `建议策略：${task.strategy}`,
+    `任务线索：${task.reasons.join(', ') || '无'}`,
+    '完成标准：',
+    '1. 必须新增或修改与目标相关的测试文件（否则视为失败）',
+    '2. 新测试默认优先就近放在目标模块附近，不要轻易放到 src/__tests__ 这类聚合目录',
+    '3. 当前 target 的测试补充完成',
+    '4. 不引入无关文件修改',
+    '5. 全量验证通过或明确说明阻塞原因',
+    '6. 如发现源码问题，只记录待办，不修改源码',
+    '7. 输出本轮结果摘要'
+  ]
+
+  if (overrides?.taskAppend) {
+    lines.push('', '项目补充要求：', overrides.taskAppend)
+  }
+
+  return lines.join('\n')
+}

package/src/core/reporter/index.ts

@@ -0,0 +1,56 @@
+import type { AppContext } from '../../cli/context/create-context.js'
+import type { BaseToolResult, FinalReport } from '../../types/index.js'
+
+export async function reportStatus(ctx: AppContext): Promise<BaseToolResult> {
+  const state = await ctx.stateStore.load()
+  const report = await ctx.reportStore.loadFinalReport<FinalReport>()
+  const lifecycle = await ctx.lifecycleStore.load()
+
+  const summary = [
+    `phase=${state.phase}`,
+    `status=${state.status}`,
+    `passed=${state.totals.passed}`,
+    `failed=${state.totals.failed}`,
+    `report=${report ? 'ready' : 'missing'}`,
+    lifecycle ? `lifecycle=${lifecycle.status}` : 'lifecycle=missing',
+    lifecycle?.pid ? `pid=${lifecycle.pid}` : undefined,
+    lifecycle?.restartCount !== undefined ? `restart=${lifecycle.restartCount}` : undefined,
+    lifecycle?.lastHeartbeat ? `heartbeat=${lifecycle.lastHeartbeat}` : undefined,
+    ctx.config.include?.length ? `include=${ctx.config.include.join('|')}` : undefined,
+    state.loopSummary
+      ? `loop=iterations:${state.loopSummary.iterationCount},completed:${state.loopSummary.completedTargets},blocked:${state.loopSummary.blockedTargets},noop:${state.loopSummary.noOpTargets}`
+      : undefined
+  ]
+    .filter(Boolean)
+    .join(', ')
+
+  return {
+    ok: true,
+    phase: state.phase,
+    summary,
+    artifacts: {
+      statePath: ctx.paths.statePath,
+      finalReportPath: ctx.paths.finalReportPath
+    }
+  }
+}
+
+export async function buildFinalReport(ctx: AppContext): Promise<FinalReport> {
+  const state = await ctx.stateStore.load()
+  const events = await ctx.eventStore.readAll()
+
+  const blockedTasks = events
+    .filter((event) => event.eventType === 'cli_run_failed' && event.taskId)
+    .map((event) => event.taskId as string)
+  const failedTasks = state.status === 'failed' && state.currentTaskId ? [state.currentTaskId] : []
+
+  return {
+    generatedAt: ctx.clock.nowIso(),
+    totals: state.totals,
+    blockedTasks,
+    failedTasks,
+    coveragePassed: state.status === 'done',
+    loopSummary: state.loopSummary,
+    suggestedNextAction: state.nextSuggestedAction
+  }
+}

package/src/core/state-machine/index.ts

@@ -0,0 +1,14 @@
+import type { WorkflowPhase } from '../../types/index.js'
+
+export function deriveStatusFromPhase(phase: WorkflowPhase): 'idle' | 'running' | 'blocked' | 'done' | 'failed' {
+  switch (phase) {
+    case 'BLOCKED':
+      return 'blocked'
+    case 'DONE':
+      return 'done'
+    case 'INIT':
+      return 'idle'
+    default:
+      return 'running'
+  }
+}

package/src/core/storage/defaults.ts

@@ -0,0 +1,18 @@
+import type { StateFile } from '../../types/index.js'
+
+export function defaultState(): StateFile {
+  return {
+    phase: 'INIT',
+    status: 'idle',
+    totals: {
+      pending: 0,
+      running: 0,
+      passed: 0,
+      failed: 0,
+      blocked: 0
+    },
+    lastAction: 'init',
+    nextSuggestedAction: 'analyze',
+    updatedAt: new Date().toISOString()
+  }
+}

package/src/core/storage/event-store.ts

@@ -0,0 +1,18 @@
+import type { EventRecord, RuntimePaths } from '../../types/index.js'
+import type { createFileSystem } from '../../utils/fs.js'
+
+export function createEventStore(paths: RuntimePaths, fileSystem: ReturnType<typeof createFileSystem>) {
+  return {
+    async append(event: EventRecord): Promise<void> {
+      await fileSystem.appendLine(paths.eventsPath, JSON.stringify(event))
+    },
+    async readAll(): Promise<EventRecord[]> {
+      const content = await fileSystem.readText(paths.eventsPath)
+      if (!content) return []
+      return content
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => JSON.parse(line) as EventRecord)
+    }
+  }
+}

package/src/core/storage/lifecycle-store.ts

@@ -0,0 +1,20 @@
+import type { LifecycleFile, RuntimePaths } from '../../types/index.js'
+import type { createFileSystem } from '../../utils/fs.js'
+
+export function createLifecycleStore(paths: RuntimePaths, fileSystem: ReturnType<typeof createFileSystem>) {
+  return {
+    async load(): Promise<LifecycleFile | undefined> {
+      return fileSystem.readJson<LifecycleFile>(paths.lifecyclePath)
+    },
+    async save(lifecycle: LifecycleFile): Promise<void> {
+      await fileSystem.writeJson(paths.lifecyclePath, lifecycle)
+    },
+    async patch(partial: Partial<LifecycleFile>): Promise<LifecycleFile | undefined> {
+      const current = await fileSystem.readJson<LifecycleFile>(paths.lifecyclePath)
+      if (!current) return undefined
+      const next = { ...current, ...partial }
+      await fileSystem.writeJson(paths.lifecyclePath, next)
+      return next
+    }
+  }
+}

package/src/core/storage/report-store.ts

@@ -0,0 +1,19 @@
+import type { FinalReport, RuntimePaths } from '../../types/index.js'
+import type { createFileSystem } from '../../utils/fs.js'
+
+export function createReportStore(paths: RuntimePaths, fileSystem: ReturnType<typeof createFileSystem>) {
+  return {
+    async saveCoverageSummary(report: unknown): Promise<void> {
+      await fileSystem.writeJson(paths.coverageSummaryPath, report)
+    },
+    async loadCoverageSummary<T>(): Promise<T | undefined> {
+      return fileSystem.readJson<T>(paths.coverageSummaryPath)
+    },
+    async saveFinalReport(report: FinalReport): Promise<void> {
+      await fileSystem.writeJson(paths.finalReportPath, report)
+    },
+    async loadFinalReport<T>(): Promise<T | undefined> {
+      return fileSystem.readJson<T>(paths.finalReportPath)
+    }
+  }
+}

package/src/core/storage/state-store.ts

@@ -0,0 +1,18 @@
+import type { RuntimePaths, StateFile } from '../../types/index.js'
+import { defaultState } from './defaults.js'
+import type { createFileSystem } from '../../utils/fs.js'
+
+export function createStateStore(
+  paths: RuntimePaths,
+  fileSystem: ReturnType<typeof createFileSystem>,
+  initialState?: StateFile
+) {
+  return {
+    async load(): Promise<StateFile> {
+      return (await fileSystem.readJson<StateFile>(paths.statePath)) ?? initialState ?? defaultState()
+    },
+    async save(state: StateFile): Promise<void> {
+      await fileSystem.writeJson(paths.statePath, state)
+    }
+  }
+}

package/src/core/strategies/classify-failure.ts

@@ -0,0 +1,9 @@
+export function classifyFailure(message: string): string {
+  const lower = message.toLowerCase()
+  if (lower.includes('timeout')) return 'CLI_TIMEOUT'
+  if (lower.includes('type')) return 'TYPE_ERROR'
+  if (lower.includes('assert')) return 'ASSERTION_FAILED'
+  if (lower.includes('mock')) return 'MOCK_MISSING'
+  if (lower.includes('syntax')) return 'SYNTAX_ERROR'
+  return 'RUNTIME_ENV_ERROR'
+}

package/src/core/strategies/switch-mock-strategy.ts

@@ -0,0 +1,12 @@
+import type { TaskItem } from '../../types/index.js'
+
+const STRATEGY_ORDER = ['pure-logic', 'light-mock', 'boundary-mock', 'ui-heavy']
+
+export function switchMockStrategy(task: TaskItem): TaskItem {
+  const index = STRATEGY_ORDER.indexOf(task.strategy)
+  const next = index >= 0 && index < STRATEGY_ORDER.length - 1 ? STRATEGY_ORDER[index + 1] : task.strategy
+  return {
+    ...task,
+    strategy: next
+  }
+}