@angli/unit-test-tool 0.1.0

package/dist/src/cli/context/create-context.js

@@ -0,0 +1,101 @@
+import path from 'node:path';
+import { buildPaths } from '../../utils/paths.js';
+import { createFileSystem } from '../../utils/fs.js';
+import { createClock } from '../../utils/clock.js';
+import { createCommandRunner } from '../../utils/command-runner.js';
+import { createStateStore } from '../../core/storage/state-store.js';
+import { createReportStore } from '../../core/storage/report-store.js';
+import { createEventStore } from '../../core/storage/event-store.js';
+import { createLifecycleStore } from '../../core/storage/lifecycle-store.js';
+import { createLogger } from '../../utils/logger.js';
+import { buildCommandSet } from '../../utils/commands.js';
+import { buildPromptBuilders } from '../../utils/prompts.js';
+export async function createContext(input) {
+    const projectPath = input.projectPath;
+    const paths = buildPaths(projectPath);
+    const fileSystem = createFileSystem();
+    const persistedConfig = await fileSystem.readJson(paths.configPath);
+    const config = await loadConfig(projectPath, input.coverageTarget, persistedConfig, input.configOverrides);
+    const projectPackageJson = await fileSystem.readJson(path.join(projectPath, 'package.json'));
+    const logger = createLogger(config.logLevel ?? 'info');
+    const clock = createClock();
+    const commandRunner = createCommandRunner({ cwd: projectPath });
+    const commands = buildCommandSet(config, projectPackageJson?.scripts ?? {});
+    const prompts = buildPromptBuilders(config.promptOverrides);
+    const limits = {
+        maxIterationsPerRun: config.maxIterationsPerRun ?? 5,
+        maxRetryPerTask: config.maxRetryPerTask ?? 2,
+        loopThreshold: config.loopThreshold ?? 2,
+        concurrency: config.concurrency ?? 8,
+        llmTopN: config.llmTopN ?? 20,
+        llmAdjustRange: config.llmAdjustRange ?? 10
+    };
+    const initialState = {
+        phase: 'INIT',
+        status: 'idle',
+        totals: {
+            pending: 0,
+            running: 0,
+            passed: 0,
+            failed: 0,
+            blocked: 0
+        },
+        lastAction: 'init',
+        nextSuggestedAction: 'analyze',
+        updatedAt: clock.nowIso()
+    };
+    const cache = {};
+    const runId = buildRunId(clock.nowIso());
+    return {
+        projectPath,
+        coverageTarget: config.coverageTarget,
+        mode: config.mode,
+        logger,
+        clock,
+        fileSystem,
+        commandRunner,
+        config,
+        paths,
+        commands,
+        prompts,
+        limits,
+        cache,
+        runId,
+        stateStore: createStateStore(paths, fileSystem, initialState),
+        reportStore: createReportStore(paths, fileSystem),
+        eventStore: createEventStore(paths, fileSystem),
+        lifecycleStore: createLifecycleStore(paths, fileSystem)
+    };
+}
+function buildRunId(timestamp) {
+    const compact = timestamp.replace(/[-:]/g, '').replace(/\..+$/, '');
+    return `r${compact}Z`;
+}
+async function loadConfig(projectPath, coverageTarget, persisted, overrides) {
+    const defaultConfig = {
+        projectPath,
+        coverageTarget,
+        include: ['src/**/*'],
+        exclude: ['node_modules/**', 'dist/**', 'coverage/**'],
+        mode: 'serial',
+        concurrency: 1,
+        maxIterationsPerRun: 5,
+        maxRetryPerTask: 2,
+        loopThreshold: 2,
+        allowSourceEdit: false,
+        testDirNames: ['__test__', '__tests__'],
+        commandOverrides: {},
+        priorityPaths: [],
+        deferredPaths: [],
+        excludePaths: [],
+        llmTopN: 20,
+        llmAdjustRange: 10
+    };
+    return {
+        ...defaultConfig,
+        ...persisted,
+        ...overrides,
+        projectPath,
+        coverageTarget: overrides?.coverageTarget ?? persisted?.coverageTarget ?? coverageTarget
+    };
+}

package/dist/src/cli/index.js

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { registerInitCommand } from './commands/init.js';
+import { registerAnalyzeCommand } from './commands/analyze.js';
+import { registerVerifyCommand } from './commands/verify.js';
+import { registerStatusCommand } from './commands/status.js';
+import { registerStartCommand } from './commands/start.js';
+import { registerRunCommand } from './commands/run.js';
+import { registerGuardCommand } from './commands/guard.js';
+import { registerScheduleCommand } from './commands/schedule.js';
+const program = new Command();
+program
+    .name('testbot')
+    .description('Unit test auto-completion tool')
+    .version('0.1.0');
+registerInitCommand(program);
+registerAnalyzeCommand(program);
+registerRunCommand(program);
+registerVerifyCommand(program);
+registerStatusCommand(program);
+registerStartCommand(program);
+registerGuardCommand(program);
+registerScheduleCommand(program);
+program.parseAsync(process.argv);

package/dist/src/cli/utils/scan-dir.js

@@ -0,0 +1,6 @@
+export function buildIncludeFromScanDir(scanDir) {
+    if (!scanDir)
+        return undefined;
+    const normalized = scanDir.replace(/\\/g, '/').replace(/\/+$/, '');
+    return normalized ? [`${normalized}/**/*`] : undefined;
+}

package/dist/src/core/analyzers/coverage-analyzer.js

@@ -0,0 +1,8 @@
+export function coverageAnalyzer(candidate, coverageSnapshot) {
+    const gap = coverageSnapshot?.coverageGap ?? 0;
+    return {
+        lineRate: coverageSnapshot?.lines,
+        branchRate: coverageSnapshot?.branches,
+        coverageGap: gap
+    };
+}

package/dist/src/core/analyzers/dependency-complexity-analyzer.js

@@ -0,0 +1,19 @@
+export async function dependencyComplexityAnalyzer(ctx, candidate) {
+    const content = await ctx.fileSystem.readText(`${ctx.projectPath}/${candidate.targetFile}`);
+    if (!content) {
+        return {
+            importCount: 0,
+            externalDependencyCount: 0,
+            complexityLevel: 'low'
+        };
+    }
+    const importLines = content.split('\n').filter((line) => line.startsWith('import') || line.includes('require('));
+    const importCount = importLines.length;
+    const externalDependencyCount = importLines.filter((line) => line.includes("from '") || line.includes('require(')).length;
+    const complexityLevel = importCount > 15 ? 'high' : importCount > 5 ? 'medium' : 'low';
+    return {
+        importCount,
+        externalDependencyCount,
+        complexityLevel: complexityLevel
+    };
+}

package/dist/src/core/analyzers/existing-test-analyzer.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+export async function existingTestAnalyzer(ctx, candidate) {
+    const base = path.basename(candidate.targetFile, path.extname(candidate.targetFile));
+    const testFilesByBaseName = await getTestFilesByBaseName(ctx);
+    const matches = testFilesByBaseName[base] ?? [];
+    const relatedMatches = matches.filter((file) => isRelatedTestPath(candidate.targetFile, file));
+    return {
+        hasExistingTest: relatedMatches.length > 0,
+        testFilePaths: relatedMatches,
+        partialCoverageLikely: relatedMatches.length > 0
+    };
+}
+function isRelatedTestPath(targetFile, testFile) {
+    const normalizedTarget = normalizePath(targetFile);
+    const normalizedTest = normalizePath(testFile);
+    const targetDir = path.dirname(normalizedTarget);
+    const targetDirName = path.basename(targetDir);
+    const targetBase = path.basename(normalizedTarget, path.extname(normalizedTarget));
+    const testBase = path.basename(normalizedTest, path.extname(normalizedTest));
+    if (testBase === targetBase || testBase === `${targetBase}.test` || testBase === `${targetBase}.spec`)
+        return true;
+    if (normalizedTest.startsWith(`${targetDir}/`))
+        return true;
+    if (normalizedTest.includes(`/${targetDirName}/`))
+        return true;
+    return false;
+}
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+async function getTestFilesByBaseName(ctx) {
+    if (ctx.cache.testFilesByBaseName)
+        return ctx.cache.testFilesByBaseName;
+    const testDirNames = await detectTestDirNames(ctx);
+    const patterns = [
+        '**/*.test.*',
+        '**/*.spec.*',
+        ...testDirNames.map((dir) => `**/${dir}/**/*.*`)
+    ];
+    const files = await fg(patterns, { cwd: ctx.projectPath, ignore: ctx.config.exclude, onlyFiles: true });
+    const index = {};
+    for (const file of files) {
+        const base = path.basename(file, path.extname(file));
+        if (!index[base])
+            index[base] = [];
+        index[base].push(file);
+    }
+    ctx.cache.testFilesByBaseName = index;
+    return index;
+}
+async function detectTestDirNames(ctx) {
+    if (ctx.cache.detectedTestDirNames)
+        return ctx.cache.detectedTestDirNames;
+    const configured = ctx.config.testDirNames?.filter(Boolean) ?? ['__test__', '__tests__'];
+    const jestConfigPath = path.join(ctx.projectPath, 'jest.config.js');
+    const jestConfig = await ctx.fileSystem.readText(jestConfigPath);
+    if (!jestConfig) {
+        ctx.cache.detectedTestDirNames = configured;
+        return configured;
+    }
+    const detected = configured.filter((dir) => jestConfig.includes(dir));
+    const result = detected.length > 0 ? detected : configured;
+    ctx.cache.detectedTestDirNames = result;
+    return result;
+}

package/dist/src/core/analyzers/failure-history-analyzer.js

@@ -0,0 +1,9 @@
+export async function failureHistoryAnalyzer(_ctx, _candidate) {
+    return {
+        previousAttemptCount: 0,
+        loopDetected: false,
+        blockedBefore: false,
+        failurePenaltyScore: 0,
+        lastFailureCategory: undefined
+    };
+}

package/dist/src/core/analyzers/file-classifier-analyzer.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+export async function fileClassifierAnalyzer(_ctx, candidate) {
+    const ext = path.extname(candidate.targetFile);
+    const lower = candidate.targetFile.toLowerCase();
+    const uiSignal = /component|view|widget/.test(lower);
+    const domSignal = /dom|browser/.test(lower);
+    const frameworkSignal = /tsx?$/.test(ext);
+    let ruleCategory = 'unknown';
+    if (/util|helper|math|logic|transform/.test(lower))
+        ruleCategory = 'pure-logic';
+    else if (/service|api/.test(lower))
+        ruleCategory = 'business-logic';
+    else if (uiSignal)
+        ruleCategory = 'ui-heavy';
+    else if (/model|mapper|serializer/.test(lower))
+        ruleCategory = 'data-transform';
+    return {
+        ruleCategory,
+        semanticCategory: ruleCategory,
+        uiSignal,
+        domSignal,
+        frameworkSignal
+    };
+}

package/dist/src/core/analyzers/index.js

@@ -0,0 +1,37 @@
+import { coverageAnalyzer } from './coverage-analyzer.js';
+import { pathPriorityAnalyzer } from './path-priority-analyzer.js';
+import { fileClassifierAnalyzer } from './file-classifier-analyzer.js';
+import { dependencyComplexityAnalyzer } from './dependency-complexity-analyzer.js';
+import { existingTestAnalyzer } from './existing-test-analyzer.js';
+import { failureHistoryAnalyzer } from './failure-history-analyzer.js';
+import { llmSemanticAnalyzer } from './llm-semantic-analyzer.js';
+export async function runAnalyzers(ctx, candidate, coverageSnapshot) {
+    const warnings = [];
+    const coverage = coverageAnalyzer(candidate, coverageSnapshot);
+    const pathPriority = pathPriorityAnalyzer(candidate, ctx.config);
+    const existingTest = await existingTestAnalyzer(ctx, candidate);
+    const fileClassification = await fileClassifierAnalyzer(ctx, candidate);
+    const dependencyComplexity = await dependencyComplexityAnalyzer(ctx, candidate);
+    const failureHistory = await failureHistoryAnalyzer(ctx, candidate);
+    let llmSemantic;
+    try {
+        llmSemantic = await llmSemanticAnalyzer(ctx, candidate);
+    }
+    catch (error) {
+        warnings.push(`llmSemanticAnalyzer failed: ${String(error)}`);
+    }
+    return {
+        facts: {
+            targetFile: candidate.targetFile,
+            coverage,
+            pathPriority,
+            existingTest,
+            fileClassification,
+            dependencyComplexity,
+            failureHistory,
+            llmSemantic,
+            analyzerWarnings: warnings
+        },
+        warnings
+    };
+}

package/dist/src/core/analyzers/llm-semantic-analyzer.js

@@ -0,0 +1,3 @@
+export async function llmSemanticAnalyzer(_ctx, _candidate) {
+    return undefined;
+}

package/dist/src/core/analyzers/path-priority-analyzer.js

@@ -0,0 +1,34 @@
+export function pathPriorityAnalyzer(candidate, config) {
+    const priorityPaths = config.priorityPaths ?? [];
+    const deferredPaths = config.deferredPaths ?? [];
+    const excludePaths = config.excludePaths ?? [];
+    const target = candidate.targetFile;
+    const matchedExclude = excludePaths.find((p) => target.startsWith(p));
+    if (matchedExclude) {
+        return {
+            label: 'excluded',
+            score: -999,
+            matchedPath: matchedExclude
+        };
+    }
+    const matchedPriority = priorityPaths.find((p) => target.startsWith(p));
+    if (matchedPriority) {
+        return {
+            label: 'priority',
+            score: 100,
+            matchedPath: matchedPriority
+        };
+    }
+    const matchedDeferred = deferredPaths.find((p) => target.startsWith(p));
+    if (matchedDeferred) {
+        return {
+            label: 'deferred',
+            score: -100,
+            matchedPath: matchedDeferred
+        };
+    }
+    return {
+        label: 'normal',
+        score: 0
+    };
+}

package/dist/src/core/coverage/read-coverage-summary.js

@@ -0,0 +1,183 @@
+import path from 'node:path';
+const DEFAULT_COVERAGE_FILES = [
+    path.join('coverage', 'coverage-summary.json'),
+    path.join('coverage', 'coverage-final.json'),
+    'coverage-summary.json',
+    'coverage-final.json'
+];
+const EXCLUDED_DIRS = new Set(['node_modules', '.git', '.unit_test_tool_workspace']);
+export async function runAndReadCoverage(ctx) {
+    ctx.logger.info(`[coverage] step=run status=start cmd=${ctx.commands.analyzeBaseline}`);
+    const result = await ctx.commandRunner.run(ctx.commands.analyzeBaseline);
+    ctx.logger.info(`[coverage] step=run status=done exit=${result.exitCode}`);
+    if (result.exitCode !== 0) {
+        const stderr = result.stderr?.trim();
+        const stdout = result.stdout?.trim();
+        const message = stderr || stdout || 'coverage command failed';
+        throw new Error(message);
+    }
+    const summary = await readCoverageSummary(ctx);
+    if (!summary) {
+        const searched = await listCoverageSearchPaths(ctx);
+        throw new Error(`coverage summary not found after command: ${ctx.commands.analyzeBaseline}. searched=${searched.join(', ') || 'none'}`);
+    }
+    return summary;
+}
+export async function readCoverageSummary(ctx) {
+    const searchPaths = await listCoverageSearchPaths(ctx);
+    for (const relativePath of searchPaths) {
+        const fullPath = path.join(ctx.projectPath, relativePath);
+        const data = await ctx.fileSystem.readJson(fullPath);
+        if (!data)
+            continue;
+        const snapshot = parseCoverageSummary(data);
+        if (snapshot)
+            return snapshot;
+        const finalSnapshot = parseCoverageFinal(data);
+        if (finalSnapshot)
+            return finalSnapshot;
+    }
+    return undefined;
+}
+async function listCoverageSearchPaths(ctx) {
+    const discovered = await findCoverageFiles(ctx.projectPath, '.');
+    return Array.from(new Set([...DEFAULT_COVERAGE_FILES, ...discovered]));
+}
+async function findCoverageFiles(projectPath, relativeDir) {
+    const fs = await import('node:fs/promises');
+    const dirPath = path.join(projectPath, relativeDir);
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const matches = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (EXCLUDED_DIRS.has(entry.name))
+                continue;
+            matches.push(...await findCoverageFiles(projectPath, path.join(relativeDir, entry.name)));
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (entry.name !== 'coverage-summary.json' && entry.name !== 'coverage-final.json')
+            continue;
+        matches.push(path.join(relativeDir, entry.name).replace(/^\.\//, ''));
+    }
+    return matches;
+}
+function parseCoverageSummary(summary) {
+    const totalEntry = summary.total;
+    if (!totalEntry)
+        return undefined;
+    const totals = totalEntry.total ?? totalEntry;
+    const snapshot = {
+        lines: totals.lines?.pct,
+        statements: totals.statements?.pct,
+        functions: totals.functions?.pct,
+        branches: totals.branches?.pct,
+        rawSummary: JSON.stringify(totals)
+    };
+    const fileEntries = {};
+    for (const [key, entry] of Object.entries(summary)) {
+        if (key === 'total')
+            continue;
+        const fileEntry = entry;
+        fileEntries[key] = {
+            lines: fileEntry.lines?.pct,
+            statements: fileEntry.statements?.pct,
+            functions: fileEntry.functions?.pct,
+            branches: fileEntry.branches?.pct
+        };
+    }
+    snapshot.fileEntries = fileEntries;
+    return snapshot;
+}
+function parseCoverageFinal(finalReport) {
+    const summary = summarizeCoverageFinal(finalReport);
+    if (!summary)
+        return undefined;
+    return {
+        lines: summary.lines,
+        statements: summary.statements,
+        functions: summary.functions,
+        branches: summary.branches,
+        rawSummary: JSON.stringify(summary),
+        fileEntries: summary.fileEntries
+    };
+}
+function summarizeCoverageFinal(finalReport) {
+    const files = Object.entries(finalReport).filter(([key]) => key !== 'total');
+    if (files.length === 0)
+        return undefined;
+    let totalStatements = 0;
+    let coveredStatements = 0;
+    let totalFunctions = 0;
+    let coveredFunctions = 0;
+    let totalBranches = 0;
+    let coveredBranches = 0;
+    let totalLines = 0;
+    let coveredLines = 0;
+    const fileEntries = {};
+    for (const [filePath, entry] of files) {
+        const statement = summarizeRecord(entry.s);
+        const fn = summarizeRecord(entry.f);
+        const branch = summarizeBranches(entry.b);
+        const line = summarizeRecord(entry.l);
+        totalStatements += statement.total;
+        coveredStatements += statement.covered;
+        totalFunctions += fn.total;
+        coveredFunctions += fn.covered;
+        totalBranches += branch.total;
+        coveredBranches += branch.covered;
+        totalLines += line.total;
+        coveredLines += line.covered;
+        fileEntries[filePath] = {
+            statements: toPct(statement.covered, statement.total),
+            functions: toPct(fn.covered, fn.total),
+            branches: toPct(branch.covered, branch.total),
+            lines: toPct(line.covered, line.total)
+        };
+    }
+    return {
+        statements: toPct(coveredStatements, totalStatements),
+        functions: toPct(coveredFunctions, totalFunctions),
+        branches: toPct(coveredBranches, totalBranches),
+        lines: toPct(coveredLines, totalLines),
+        fileEntries
+    };
+}
+function summarizeRecord(record) {
+    if (!record)
+        return { total: 0, covered: 0 };
+    let total = 0;
+    let covered = 0;
+    for (const value of Object.values(record)) {
+        total += 1;
+        if (value > 0)
+            covered += 1;
+    }
+    return { total, covered };
+}
+function summarizeBranches(record) {
+    if (!record)
+        return { total: 0, covered: 0 };
+    let total = 0;
+    let covered = 0;
+    for (const values of Object.values(record)) {
+        total += values.length;
+        for (const value of values) {
+            if (value > 0)
+                covered += 1;
+        }
+    }
+    return { total, covered };
+}
+function toPct(covered, total) {
+    if (total === 0)
+        return undefined;
+    return Math.round((covered / total) * 10000) / 100;
+}

package/dist/src/core/executor/claude-cli-executor.js

@@ -0,0 +1,91 @@
+import { execa } from 'execa';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+export async function executeClaudeCli(input) {
+    const startedAt = Date.now();
+    const heartbeatMs = 10000;
+    let heartbeat;
+    try {
+        if (input.onProgress) {
+            heartbeat = setInterval(() => {
+                input.onProgress?.(Date.now() - startedAt);
+            }, heartbeatMs);
+        }
+        const args = ['-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) {
+    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) {
+    try {
+        const configPath = path.join(cwd, '.claude', 'settings.local.json');
+        const raw = await fs.readFile(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const env = parsed?.env ?? {};
+        const result = {};
+        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/dist/src/core/middleware/loop-detection.js

@@ -0,0 +1,6 @@
+export function loopDetection(task, threshold) {
+    if (task.attemptCount >= threshold) {
+        return { loopDetected: true };
+    }
+    return { loopDetected: false };
+}

package/dist/src/core/middleware/pre-completion-checklist.js

@@ -0,0 +1,27 @@
+export async function preCompletionChecklist(ctx) {
+    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/dist/src/core/middleware/silent-success-post-check.js

@@ -0,0 +1,13 @@
+export async function silentSuccessPostCheck(ctx, targetFile) {
+    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/dist/src/core/planner/rank-candidates.js

@@ -0,0 +1,3 @@
+export function rankCandidates(candidates) {
+    return [...candidates].sort((a, b) => b.baseScore - a.baseScore);
+}