@angli/unit-test-tool 0.1.0

package/dist/src/core/planner/rule-planner.js

@@ -0,0 +1,41 @@
+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, candidates, coverageSnapshot) {
+    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) => 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(items, concurrency, mapper) {
+    const results = 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/dist/src/core/planner/score-candidate.js

@@ -0,0 +1,49 @@
+export function scoreCandidate(facts) {
+    const reasons = [];
+    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, facts) {
+    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/dist/src/core/prompts/case-library.js

@@ -0,0 +1,35 @@
+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，避免把整条调用链都模拟一遍。',
+            '优先断言上下文输入如何影响当前组件状态、调用参数和容错分支。'
+        ]
+    }
+];
+export function buildCaseLibraryPrompt() {
+    return [
+        '典型案例约束：',
+        ...DEFAULT_CASE_LIBRARY.flatMap((item) => [
+            `- ${item.title}：`,
+            ...item.lines.map((line) => `  - ${line}`)
+        ])
+    ].join('\n');
+}

package/dist/src/core/prompts/edit-boundary-prompt.js

@@ -0,0 +1,24 @@
+export function buildEditBoundaryPrompt(task) {
+    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/dist/src/core/prompts/retry-prompt.js

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

package/dist/src/core/prompts/system-prompt.js

@@ -0,0 +1,27 @@
+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) {
+    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/dist/src/core/prompts/task-prompt.js

@@ -0,0 +1,22 @@
+export function buildTaskPrompt(task, overrides) {
+    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/dist/src/core/reporter/index.js

@@ -0,0 +1,48 @@
+export async function reportStatus(ctx) {
+    const state = await ctx.stateStore.load();
+    const report = await ctx.reportStore.loadFinalReport();
+    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) {
+    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);
+    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/dist/src/core/state-machine/index.js

@@ -0,0 +1,12 @@
+export function deriveStatusFromPhase(phase) {
+    switch (phase) {
+        case 'BLOCKED':
+            return 'blocked';
+        case 'DONE':
+            return 'done';
+        case 'INIT':
+            return 'idle';
+        default:
+            return 'running';
+    }
+}

package/dist/src/core/storage/defaults.js

@@ -0,0 +1,16 @@
+export function defaultState() {
+    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/dist/src/core/storage/event-store.js

@@ -0,0 +1,16 @@
+export function createEventStore(paths, fileSystem) {
+    return {
+        async append(event) {
+            await fileSystem.appendLine(paths.eventsPath, JSON.stringify(event));
+        },
+        async readAll() {
+            const content = await fileSystem.readText(paths.eventsPath);
+            if (!content)
+                return [];
+            return content
+                .split('\n')
+                .filter(Boolean)
+                .map((line) => JSON.parse(line));
+        }
+    };
+}

package/dist/src/core/storage/lifecycle-store.js

@@ -0,0 +1,18 @@
+export function createLifecycleStore(paths, fileSystem) {
+    return {
+        async load() {
+            return fileSystem.readJson(paths.lifecyclePath);
+        },
+        async save(lifecycle) {
+            await fileSystem.writeJson(paths.lifecyclePath, lifecycle);
+        },
+        async patch(partial) {
+            const current = await fileSystem.readJson(paths.lifecyclePath);
+            if (!current)
+                return undefined;
+            const next = { ...current, ...partial };
+            await fileSystem.writeJson(paths.lifecyclePath, next);
+            return next;
+        }
+    };
+}

package/dist/src/core/storage/report-store.js

@@ -0,0 +1,16 @@
+export function createReportStore(paths, fileSystem) {
+    return {
+        async saveCoverageSummary(report) {
+            await fileSystem.writeJson(paths.coverageSummaryPath, report);
+        },
+        async loadCoverageSummary() {
+            return fileSystem.readJson(paths.coverageSummaryPath);
+        },
+        async saveFinalReport(report) {
+            await fileSystem.writeJson(paths.finalReportPath, report);
+        },
+        async loadFinalReport() {
+            return fileSystem.readJson(paths.finalReportPath);
+        }
+    };
+}

package/dist/src/core/storage/state-store.js

@@ -0,0 +1,11 @@
+import { defaultState } from './defaults.js';
+export function createStateStore(paths, fileSystem, initialState) {
+    return {
+        async load() {
+            return (await fileSystem.readJson(paths.statePath)) ?? initialState ?? defaultState();
+        },
+        async save(state) {
+            await fileSystem.writeJson(paths.statePath, state);
+        }
+    };
+}

package/dist/src/core/strategies/classify-failure.js

@@ -0,0 +1,14 @@
+export function classifyFailure(message) {
+    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/dist/src/core/strategies/switch-mock-strategy.js

@@ -0,0 +1,9 @@
+const STRATEGY_ORDER = ['pure-logic', 'light-mock', 'boundary-mock', 'ui-heavy'];
+export function switchMockStrategy(task) {
+    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
+    };
+}

package/dist/src/core/tools/analyze-baseline.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { deriveStatusFromPhase } from '../state-machine/index.js';
+import { runAndReadCoverage } from '../coverage/read-coverage-summary.js';
+export async function analyzeBaseline(ctx) {
+    await ctx.fileSystem.ensureDir(ctx.paths.runtimeDir);
+    await ctx.fileSystem.ensureDir(ctx.paths.logsPath);
+    await ctx.fileSystem.ensureDir(ctx.paths.promptsDir);
+    await ctx.fileSystem.ensureDir(ctx.paths.promptRunsDir);
+    await ctx.fileSystem.ensureDir(ctx.paths.reportsDir);
+    const packageJson = await ctx.fileSystem.readJson(path.join(ctx.projectPath, 'package.json'));
+    const framework = detectFramework(packageJson?.scripts ?? {});
+    const coverageSnapshot = await runAndReadCoverage(ctx);
+    await ctx.reportStore.saveCoverageSummary({
+        framework,
+        coverageSnapshot
+    });
+    const state = await ctx.stateStore.load();
+    const nextState = {
+        ...state,
+        phase: 'ANALYZE_BASELINE',
+        status: deriveStatusFromPhase('ANALYZE_BASELINE'),
+        coverageSnapshot,
+        lastAction: 'analyze-baseline',
+        nextSuggestedAction: 'run',
+        updatedAt: ctx.clock.nowIso()
+    };
+    await ctx.stateStore.save(nextState);
+    await ctx.eventStore.append({
+        eventType: 'baseline_analyzed',
+        phase: 'ANALYZE_BASELINE',
+        message: `baseline coverage lines=${coverageSnapshot.lines ?? 'unknown'}`,
+        data: { framework, coverageSnapshot },
+        timestamp: ctx.clock.nowIso()
+    });
+    return {
+        ok: true,
+        phase: 'ANALYZE_BASELINE',
+        summary: `完成真实覆盖率基线分析，lines=${coverageSnapshot.lines ?? 'unknown'}%。`,
+        nextAction: 'run',
+        artifacts: {
+            coverageSummaryPath: ctx.paths.coverageSummaryPath
+        },
+        coverageSnapshot,
+        testFramework: framework
+    };
+}
+function detectFramework(scripts) {
+    const scriptValues = Object.values(scripts).join(' ');
+    if (scriptValues.includes('vitest'))
+        return 'vitest';
+    if (scriptValues.includes('jest'))
+        return 'jest';
+    return 'unknown';
+}

package/dist/src/core/tools/guard.js

@@ -0,0 +1,68 @@
+import { execa } from 'execa';
+const DEFAULT_STALE_TIMEOUT_MS = 2 * 60_000;
+const DEFAULT_MAX_RESTART = 3;
+const DEFAULT_COOLDOWN_MS = 60_000;
+export async function runGuard(ctx, options = {}) {
+    const lifecycle = await ctx.lifecycleStore.load();
+    if (!lifecycle) {
+        return { recovered: false, summary: '未找到 lifecycle 记录。' };
+    }
+    const staleTimeoutMs = options.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS;
+    const maxRestart = options.maxRestart ?? DEFAULT_MAX_RESTART;
+    const cooldownMs = options.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+    const now = Date.now();
+    const lastHeartbeat = Date.parse(lifecycle.lastHeartbeat);
+    const isStale = Number.isFinite(lastHeartbeat) && now - lastHeartbeat > staleTimeoutMs;
+    const isAbnormal = (lifecycle.status === 'running' && isStale) || lifecycle.status === 'crashed';
+    if (!isAbnormal) {
+        return { recovered: false, summary: `无需恢复：status=${lifecycle.status}` };
+    }
+    if (lifecycle.command !== 'start') {
+        return { recovered: false, summary: `检测到 ${lifecycle.command} 异常，但按设计不自动恢复。` };
+    }
+    if (lifecycle.restartCount >= maxRestart) {
+        return { recovered: false, summary: `已达到最大恢复次数 ${maxRestart}。` };
+    }
+    const updatedAt = Date.parse(lifecycle.updatedAt);
+    if (Number.isFinite(updatedAt) && now - updatedAt < cooldownMs) {
+        return { recovered: false, summary: `仍处于冷却期，稍后再试。` };
+    }
+    const nextRestartCount = lifecycle.restartCount + 1;
+    const recoveringAt = ctx.clock.nowIso();
+    await ctx.lifecycleStore.patch({
+        status: 'recovering',
+        restartCount: nextRestartCount,
+        updatedAt: recoveringAt,
+        lastError: lifecycle.lastError ?? (isStale ? 'heartbeat stale' : 'crashed')
+    });
+    await ctx.eventStore.append({
+        eventType: 'lifecycle_recovering',
+        phase: 'BLOCKED',
+        message: `recover start process #${nextRestartCount}`,
+        data: { argv: lifecycle.argv },
+        timestamp: recoveringAt
+    });
+    const child = execa(process.execPath, lifecycle.argv, {
+        cwd: ctx.projectPath,
+        detached: true,
+        stdio: 'ignore'
+    });
+    child.unref();
+    return { recovered: true, summary: `已触发恢复，第 ${nextRestartCount} 次。` };
+}
+export async function runSchedule(ctx, intervalMs, guardOptions = {}) {
+    await runGuard(ctx, guardOptions);
+    setInterval(async () => {
+        try {
+            await runGuard(ctx, guardOptions);
+        }
+        catch (error) {
+            await ctx.eventStore.append({
+                eventType: 'schedule_guard_failed',
+                phase: 'BLOCKED',
+                message: error instanceof Error ? error.message : String(error),
+                timestamp: ctx.clock.nowIso()
+            });
+        }
+    }, intervalMs);
+}

package/dist/src/core/tools/run-loop.js

@@ -0,0 +1,108 @@
+import { analyzeBaseline } from './analyze-baseline.js';
+import { runWithClaudeCli } from './run-with-claude-cli.js';
+import { buildFinalReport } from '../reporter/index.js';
+export async function runLoop(ctx, input = {}) {
+    await analyzeBaseline(ctx);
+    const attemptedTargets = new Set();
+    let iterationCount = 0;
+    let completedTargets = 0;
+    let blockedTargets = 0;
+    let noOpTargets = 0;
+    let lastCompletedTarget;
+    let lastResult;
+    const maxIterations = input.targetFile ? 1 : Math.max(1, ctx.limits.maxIterationsPerRun);
+    let lastCoverage;
+    while (iterationCount < maxIterations) {
+        iterationCount += 1;
+        const result = await runWithClaudeCli(ctx, {
+            ...input,
+            excludeTargets: input.targetFile ? undefined : [...attemptedTargets]
+        });
+        lastResult = result;
+        if (result.targetFile)
+            attemptedTargets.add(result.targetFile);
+        const coverageSummary = await ctx.reportStore.loadCoverageSummary();
+        const currentCoverage = coverageSummary?.coverageSnapshot?.lines;
+        lastCoverage = currentCoverage;
+        if (currentCoverage !== undefined && currentCoverage >= ctx.coverageTarget) {
+            break;
+        }
+        if (result.ok) {
+            completedTargets += 1;
+            lastCompletedTarget = result.targetFile;
+            await syncLoopSummary(ctx, {
+                iterationCount,
+                completedTargets,
+                blockedTargets,
+                noOpTargets,
+                lastCompletedTarget
+            });
+            continue;
+        }
+        if (result.summary.includes('no-op')) {
+            noOpTargets += 1;
+        }
+        else {
+            blockedTargets += 1;
+        }
+        await syncLoopSummary(ctx, {
+            iterationCount,
+            completedTargets,
+            blockedTargets,
+            noOpTargets,
+            lastCompletedTarget
+        });
+        if (input.targetFile)
+            break;
+        if (blockedTargets >= Math.max(1, ctx.limits.maxRetryPerTask))
+            break;
+        if (noOpTargets >= Math.max(1, ctx.limits.loopThreshold))
+            break;
+        if (!result.targetFile)
+            break;
+    }
+    const finalLoopSummary = {
+        iterationCount,
+        completedTargets,
+        blockedTargets,
+        noOpTargets,
+        lastCompletedTarget
+    };
+    await syncLoopSummary(ctx, finalLoopSummary);
+    const report = await buildFinalReport(ctx);
+    await ctx.reportStore.saveFinalReport(report);
+    if (!lastResult) {
+        return {
+            ok: false,
+            phase: 'BLOCKED',
+            summary: '自动执行未产生任何任务结果。',
+            nextAction: 'manual-intervention'
+        };
+    }
+    const summaryParts = [
+        `completed=${completedTargets}`,
+        `blocked=${blockedTargets}`,
+        `noop=${noOpTargets}`,
+        `iterations=${iterationCount}`
+    ];
+    if (lastCoverage !== undefined) {
+        summaryParts.push(`coverage=${lastCoverage}/${ctx.coverageTarget}`);
+    }
+    return {
+        ...lastResult,
+        artifacts: {
+            ...lastResult.artifacts,
+            finalReportPath: ctx.paths.finalReportPath,
+            loopSummary: JSON.stringify(finalLoopSummary)
+        },
+        summary: `自动执行结束：${summaryParts.join(', ')}`
+    };
+}
+async function syncLoopSummary(ctx, loopSummary) {
+    const state = await ctx.stateStore.load();
+    await ctx.stateStore.save({
+        ...state,
+        loopSummary,
+        updatedAt: ctx.clock.nowIso()
+    });
+}