@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/records/one-shot-runs.js

@@ -0,0 +1,386 @@
+import { access, readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { truncateOutput } from '../shared/output-truncation.js';
+import { createOneShotActiveRunDir, ensureOneShotRunDirs, finalizeLegacyRunLogToCompleted, transferOneShotRunToCompleted, transferOneShotRunToFailed, writeOneShotActiveLogAtPath, writeOneShotRunMarkdown, writeOneShotRunMeta, } from '../infrastructure/harness/one-shot-run-store.js';
+/** Maximum chars for result summary in the run log. */
+export const RUN_LOG_RESULT_MAX = 4_000;
+/** Placeholder written to active logs before execution finishes. */
+export const RUN_LOG_RUNNING_PLACEHOLDER = '_(执行中…)_';
+/**
+ * Compute the active run directory under .harness/runs/active/<slug>/.
+ * Creates the directory and returns the path.
+ */
+export async function computeRunDir(cwd, task) {
+    const harnessDir = path.join(cwd, '.harness');
+    try {
+        await access(harnessDir);
+    }
+    catch {
+        return null;
+    }
+    const datePrefix = new Date().toISOString().slice(0, 10);
+    const slug = deriveRunSlug(task);
+    return createOneShotActiveRunDir(cwd, `${datePrefix}-${slug}`);
+}
+/**
+ * Persist a human-readable run log under `.harness/runs/`.
+ *
+ * Lifecycle:
+ *   1. Write to `.harness/runs/active/<date>-<slug>/run.md`
+ *   2. If execution succeeded, move the run directory to `.harness/runs/completed/`
+ *   3. If execution failed, move the run directory to `.harness/runs/failed/`
+ *
+ * No-op when `cwd` does not contain a `.harness/` directory.
+ */
+export async function persistCursorRunLog(cwd, input) {
+    const harnessDir = path.join(cwd, '.harness');
+    try {
+        await access(harnessDir);
+    }
+    catch {
+        return null; // not a harness repo — skip silently
+    }
+    const datePrefix = new Date().toISOString().slice(0, 10);
+    const slug = deriveRunSlug(input.task);
+    const baseName = `${datePrefix}-${slug}`;
+    await ensureOneShotRunDirs(cwd);
+    const activeRunDir = input.runDir ?? await createOneShotActiveRunDir(cwd, baseName);
+    const content = buildRunLogMarkdown(input);
+    await writeOneShotRunMarkdown(cwd, activeRunDir, content);
+    await writeRunMeta(cwd, activeRunDir, input);
+    if (input.result.ok) {
+        const completedPath = await transferOneShotRunToCompleted(cwd, activeRunDir, path.basename(activeRunDir));
+        return { logPath: path.join(completedPath, 'run.md'), completed: true };
+    }
+    if (input.result.status === 'failed' || input.result.status === 'timeout' || input.result.status === 'cancelled') {
+        const failedPath = await transferOneShotRunToFailed(cwd, activeRunDir, path.basename(activeRunDir));
+        return { logPath: path.join(failedPath, 'run.md'), completed: false };
+    }
+    return { logPath: path.join(activeRunDir, 'run.md'), completed: false };
+}
+async function writeRunMeta(repoRoot, runDir, input, statusOverride) {
+    const runId = path.basename(runDir);
+    const status = statusOverride ?? (input.result.ok ? 'completed' : input.result.status);
+    await writeOneShotRunMeta(repoRoot, runDir, {
+        runId,
+        taskId: input.taskId,
+        status,
+        model: input.model,
+        channel: input.channel,
+        cwd: input.cwd,
+        startedDate: new Date().toISOString().slice(0, 10),
+        durationMs: input.result.durationMs,
+        failureCategory: input.result.failureCategory,
+        artifactsDir: 'artifacts',
+        logPath: 'run.md',
+    });
+}
+function isRunMarkdownPath(logPath) {
+    return path.basename(logPath) === 'run.md';
+}
+function runDirForLogPath(logPath) {
+    return isRunMarkdownPath(logPath) ? path.dirname(logPath) : '';
+}
+function parseTaskIdFallback(logPath) {
+    if (isRunMarkdownPath(logPath))
+        return path.basename(path.dirname(logPath));
+    return path.basename(logPath, '.md');
+}
+/**
+ * Write an in-progress run log under `.harness/runs/active/`.
+ * Optional helper for two-phase logging; Pi `cursor` tool uses sync `persistCursorRunLog` instead.
+ */
+export async function createActiveCursorRun(cwd, input) {
+    const harnessDir = await resolveHarnessDir(cwd);
+    if (!harnessDir)
+        return null;
+    const datePrefix = new Date().toISOString().slice(0, 10);
+    const slug = deriveRunSlug(input.task);
+    const baseName = `${datePrefix}-${slug}`;
+    const activeRunDir = await createOneShotActiveRunDir(cwd, baseName);
+    const content = buildActiveRunLogMarkdown(input);
+    await writeOneShotRunMarkdown(cwd, activeRunDir, content);
+    await writeRunMeta(cwd, activeRunDir, {
+        taskId: input.taskId,
+        task: input.task,
+        model: input.model,
+        channel: input.channel,
+        cwd: input.cwd,
+        result: {
+            ok: false,
+            status: 'failed',
+            failureCategory: 'unknown',
+            model: input.model,
+            durationMs: 0,
+            stdout: '',
+            stderr: '',
+        },
+    }, 'running');
+    return { logPath: path.join(activeRunDir, 'run.md'), taskId: input.taskId };
+}
+/**
+ * Finalize an active run log with execution results.
+ * Moves successful runs to `.harness/runs/completed/`.
+ */
+export async function finalizeCursorRunLog(logPath, input) {
+    const harnessDir = await resolveHarnessDir(input.cwd);
+    if (!harnessDir)
+        return null;
+    const existing = await readFile(logPath, 'utf-8').catch(() => '');
+    const taskId = existing ? parseCursorRunLog(existing, logPath).taskId : undefined;
+    const content = buildRunLogMarkdown({ ...input, taskId });
+    const activeRunDir = runDirForLogPath(logPath);
+    if (activeRunDir) {
+        await writeOneShotRunMarkdown(input.cwd, activeRunDir, content);
+        await writeRunMeta(input.cwd, activeRunDir, { ...input, taskId });
+    }
+    else {
+        await writeOneShotActiveLogAtPath(input.cwd, logPath, content);
+    }
+    if (isRunMarkdownPath(logPath)) {
+        const transfer = input.result.ok ? transferOneShotRunToCompleted : transferOneShotRunToFailed;
+        const destDir = await transfer(input.cwd, path.dirname(logPath), path.basename(path.dirname(logPath)));
+        return { logPath: path.join(destDir, 'run.md'), completed: input.result.ok };
+    }
+    if (!input.result.ok) {
+        return { logPath, completed: false };
+    }
+    const completedPath = await finalizeLegacyRunLogToCompleted(input.cwd, logPath, content);
+    return { logPath: completedPath, completed: true };
+}
+/**
+ * Query Cursor run records from `.harness/runs/` (for `cursor-task` history / stale detection).
+ */
+export async function queryCursorRuns(cwd, options = {}) {
+    const harnessDir = await resolveHarnessDir(cwd);
+    if (!harnessDir)
+        return [];
+    const runsRoot = path.join(harnessDir, 'runs');
+    const activeDir = path.join(runsRoot, 'active');
+    const completedDir = path.join(runsRoot, 'completed');
+    const failedDir = path.join(runsRoot, 'failed');
+    const records = [];
+    for (const dir of [activeDir, failedDir, completedDir]) {
+        let entries;
+        try {
+            entries = (await readdir(dir)).sort();
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry);
+            const logPath = entry.endsWith('.md') ? entryPath : path.join(entryPath, 'run.md');
+            const content = await readFile(logPath, 'utf-8').catch(() => '');
+            if (!content)
+                continue;
+            const parsed = parseCursorRunLog(content, logPath);
+            parsed.status = resolveRunStatus(parsed, dir === completedDir, options.inMemoryTaskId, dir === failedDir);
+            records.push(parsed);
+            if (options.taskId && parsed.taskId === options.taskId) {
+                return [parsed];
+            }
+        }
+    }
+    if (options.taskId)
+        return [];
+    const activeRecords = records
+        .filter((record) => record.status === 'running' || record.status === 'stale' || record.status === 'failed')
+        .sort((a, b) => (b.startTime ?? '').localeCompare(a.startTime ?? ''));
+    const completedRecords = records
+        .filter((record) => record.status === 'completed')
+        .sort((a, b) => (b.startTime ?? '').localeCompare(a.startTime ?? ''))
+        .slice(0, options.maxCompleted ?? 10);
+    return [...activeRecords, ...completedRecords];
+}
+export function parseCursorRunLog(content, logPath) {
+    const readField = (field) => {
+        const match = content.match(new RegExp(`\\| ${field} \\| ([^|]+) \\|`));
+        return match?.[1]?.trim();
+    };
+    const resultMatch = content.match(/## 结果摘要\s*\n\s*\n([\s\S]*?)(?:\n\n_\(|$)/);
+    const rawSummary = resultMatch?.[1]?.trim() ?? '';
+    const truncated = content.includes('_(输出已截断)_');
+    return {
+        taskId: readField('taskId') ?? parseTaskIdFallback(logPath),
+        status: 'running',
+        logPath,
+        task: extractTaskSection(content),
+        model: readField('模型') ?? 'default',
+        cwd: readField('cwd') ?? '',
+        channel: (readField('通道') ?? 'tool'),
+        startTime: readField('日期'),
+        durationSec: readField('耗时')?.replace(/s$/, ''),
+        tableStatus: readField('状态'),
+        failureCategory: readField('失败分类'),
+        resultSummary: rawSummary === RUN_LOG_RUNNING_PLACEHOLDER ? undefined : rawSummary,
+        resultTruncated: truncated,
+    };
+}
+export function resolveRunStatus(record, inCompletedDir, inMemoryTaskId, inFailedDir = false) {
+    if (inCompletedDir)
+        return 'completed';
+    if (inFailedDir)
+        return 'failed';
+    if (record.resultSummary) {
+        if (record.tableStatus === 'completed')
+            return 'completed';
+        return 'failed';
+    }
+    if (record.tableStatus && record.tableStatus !== 'running') {
+        return 'failed';
+    }
+    if (inMemoryTaskId && record.taskId === inMemoryTaskId) {
+        return 'running';
+    }
+    return 'stale';
+}
+function extractTaskSection(content) {
+    const match = content.match(/## 任务\s*\n\s*\n([\s\S]*?)\n\s*\n## /);
+    return match?.[1]?.trim() ?? '';
+}
+async function resolveHarnessDir(cwd) {
+    const harnessDir = path.join(cwd, '.harness');
+    try {
+        await access(harnessDir);
+        return harnessDir;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Derive a filesystem-safe slug from a task description.
+ *
+ * Rules:
+ *   - Take first 40 characters
+ *   - Replace non-alphanumeric (except CJK) with `-`
+ *   - Collapse consecutive `-`
+ *   - Trim leading/trailing `-`
+ *   - Empty task → `untitled`
+ */
+export function deriveRunSlug(task) {
+    const raw = task.trim().slice(0, 40);
+    if (!raw)
+        return 'untitled';
+    // Allow alphanumeric, CJK unified ideographs (U+4E00–U+9FFF), hiragana, katakana
+    // Replace everything else with `-`
+    const slug = raw
+        .replace(/[^\p{L}\p{N}]/gu, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return slug || 'untitled';
+}
+/**
+ * Canonical one-shot run id format.
+ *
+ * One-shot Cursor/Pi run ids are directory basenames under
+ * `.harness/runs/<state>/`. New runs use the form produced by
+ * `computeRunDir` / `persistCursorRunLog`:
+ *
+ *   YYYY-MM-DD-<kebab-slug>[-N]
+ *
+ * where `-N` is the collision suffix appended by `resolveUniqueRunPath`
+ * (e.g. `-2`, `-3`). Legacy `.md`-only run logs (read-only compatible) may
+ * use the bare `YYYY-MM-DD-<slug>.md` form.
+ */
+export const CANONICAL_ONE_SHOT_RUN_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z0-9]+(-[a-z0-9]+)*(?:-(?!r\d)\d+)?$/;
+/** Bare `.md` legacy log name: `YYYY-MM-DD-<slug>.md` (read-only compatibility). */
+const LEGACY_ONE_SHOT_MD_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z0-9]+(-[a-z0-9]+)*\.md$/;
+/**
+ * Validate a one-shot run id (or legacy `.md` log basename) against the
+ * canonical format. Legacy ids remain readable; this only emits warnings.
+ *
+ * Accepts either a directory-style id (`YYYY-MM-DD-<slug>[-N]`) or a legacy
+ * markdown log name (`YYYY-MM-DD-<slug>.md`).
+ */
+export function validateOneShotRunId(runId) {
+    const warnings = [];
+    const trimmed = runId.trim();
+    if (!trimmed) {
+        warnings.push("one-shot runId cannot be empty");
+        return { warnings };
+    }
+    const stripped = trimmed.endsWith(".md")
+        ? trimmed.slice(0, -3)
+        : trimmed;
+    if (CANONICAL_ONE_SHOT_RUN_ID_PATTERN.test(stripped) ||
+        LEGACY_ONE_SHOT_MD_PATTERN.test(trimmed)) {
+        return { warnings };
+    }
+    warnings.push(`one-shot runId "${trimmed}" does not match canonical YYYY-MM-DD-<slug>; legacy run evidence remains readable`);
+    return { warnings };
+}
+/**
+ * If `baseName` already exists in `dir`, append `-2`, `-3`, etc.
+ */
+export async function resolveUniqueRunPath(dir, baseName) {
+    let candidate = path.join(dir, baseName);
+    let counter = 1;
+    while (true) {
+        try {
+            await access(candidate);
+            // File exists — try next suffix
+            counter += 1;
+            const ext = path.extname(baseName);
+            const stem = path.basename(baseName, ext);
+            candidate = path.join(dir, `${stem}-${counter}${ext}`);
+        }
+        catch {
+            // File does not exist — use this path
+            return candidate;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Markdown builder
+// ---------------------------------------------------------------------------
+function buildRunLogMarkdown(input) {
+    const durationSec = (input.result.durationMs / 1000).toFixed(1);
+    const outputText = input.result.stdout || input.result.stderr || '(no output)';
+    const truncated = truncateOutput(outputText, RUN_LOG_RESULT_MAX);
+    const lines = [
+        '# Cursor 执行记录',
+        '',
+        '| 字段 | 值 |',
+        '|------|----|',
+    ];
+    if (input.taskId) {
+        lines.push(`| taskId | ${input.taskId} |`);
+    }
+    lines.push(`| 日期 | ${new Date().toISOString().slice(0, 10)} |`, `| 模型 | ${input.model} |`, `| 耗时 | ${durationSec}s |`, `| 状态 | ${input.result.ok ? 'completed' : input.result.status} |`, `| 通道 | ${input.channel} |`, `| cwd | ${input.cwd} |`);
+    if (!input.result.ok && input.result.failureCategory !== 'success') {
+        lines.push(`| 失败分类 | ${input.result.failureCategory} |`);
+    }
+    lines.push('', '## 任务', '', input.task, '', '## 结果摘要', '', truncated.text);
+    if (truncated.truncated) {
+        lines.push('', '_(输出已截断)_');
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function buildActiveRunLogMarkdown(input) {
+    const lines = [
+        '# Cursor 执行记录',
+        '',
+        '| 字段 | 值 |',
+        '|------|----|',
+        `| taskId | ${input.taskId} |`,
+        `| 日期 | ${new Date().toISOString().slice(0, 10)} |`,
+        `| 模型 | ${input.model} |`,
+        `| 耗时 | - |`,
+        `| 状态 | running |`,
+        `| 通道 | ${input.channel} |`,
+        `| cwd | ${input.cwd} |`,
+        '',
+        '## 任务',
+        '',
+        input.task,
+        '',
+        '## 结果摘要',
+        '',
+        RUN_LOG_RUNNING_PLACEHOLDER,
+        '',
+    ];
+    return lines.join('\n');
+}

package/dist/records/promotion.js

@@ -0,0 +1,200 @@
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getArtifactPath, writeArtifactForStep } from '../shared/artifacts-core.js';
+import { getDagRunDir, readDagRunState } from '../workflows/dag/lifecycle.js';
+import { parseCursorRunLog, resolveRunStatus } from './one-shot-runs.js';
+import { getTaskDir } from '../task/runtime.js';
+export async function promoteRunEvidence(repoRoot, taskId, runId) {
+    const dag = await loadCompletedDagEvidence(repoRoot, runId).catch(() => null);
+    if (dag) {
+        return writePromotion(repoRoot, taskId, runId, 'dag', buildDagModifyLog(taskId, runId, dag), buildDagVerifyResult(taskId, runId, dag));
+    }
+    const oneShot = await loadCompletedOneShotEvidence(repoRoot, runId);
+    if (oneShot) {
+        return writePromotion(repoRoot, taskId, runId, 'one-shot', buildOneShotModifyLog(taskId, runId, oneShot), buildOneShotVerifyResult(taskId, runId, oneShot));
+    }
+    throw new Error(`completed run evidence not found for run-id: ${runId}`);
+}
+export async function closeoutTask(repoRoot, taskId) {
+    const taskDir = getTaskDir(repoRoot, taskId);
+    const modifyPath = getArtifactPath(taskDir, 'implement');
+    const verifyPath = getArtifactPath(taskDir, 'verify');
+    const modify = await readFile(modifyPath, 'utf-8').catch(() => '');
+    const verify = await readFile(verifyPath, 'utf-8').catch(() => '');
+    const slug = taskId.replace(/^\d{4}-\d{2}-\d{2}-/, '');
+    const datePrefix = taskId.match(/^\d{4}-\d{2}-\d{2}/)?.[0] ?? new Date().toISOString().slice(0, 10);
+    // Runtime bridge evidence stays under .harness/ so promote/closeout never
+    // invents tracked docs/progress writes outside TaskSpec allowed_paths.
+    const progressDir = path.join(repoRoot, '.harness', 'task-pool', 'artifacts', 'closeout');
+    await mkdir(progressDir, { recursive: true });
+    const progressPath = path.join(progressDir, `${datePrefix}-${slug}.md`);
+    const verificationSummary = summarizeVerification(verify);
+    const content = [
+        `# ${taskId}`,
+        '',
+        '## Summary',
+        '',
+        summarizeSection(modify) || '- No promoted modification summary found.',
+        '',
+        '## Verification',
+        '',
+        verificationSummary,
+        '',
+        '## Remaining Risk',
+        '',
+        verificationSummary.includes('No concrete verification evidence')
+            ? '- Verification evidence is incomplete; do not treat this closeout as proof of passing tests.'
+            : '- Review remaining risks in task artifacts and related run facts before archiving.',
+        '',
+    ].join('\n');
+    await writeFile(progressPath, content, 'utf-8');
+    return { taskId, progressPath };
+}
+async function writePromotion(repoRoot, taskId, runId, sourceKind, modifyLog, verifyResult) {
+    const taskDir = getTaskDir(repoRoot, taskId);
+    const modifyLogPath = getArtifactPath(taskDir, 'implement');
+    const verifyResultPath = getArtifactPath(taskDir, 'verify');
+    await writeArtifactForStep(taskDir, 'implement', modifyLog);
+    await writeArtifactForStep(taskDir, 'verify', verifyResult);
+    return { taskId, runId, sourceKind, modifyLogPath, verifyResultPath };
+}
+async function loadCompletedDagEvidence(repoRoot, runId) {
+    const runDir = getDagRunDir(repoRoot, 'completed', runId);
+    const state = await readDagRunState(runDir);
+    if (state.status !== 'finished') {
+        throw new Error(`completed DAG run ${runId} is not finished (status=${state.status})`);
+    }
+    return state;
+}
+async function loadCompletedOneShotEvidence(repoRoot, runId) {
+    const completedDir = path.join(repoRoot, '.harness', 'runs', 'completed');
+    const direct = await readOneShotRecord(path.join(completedDir, runId, 'run.md'), true);
+    if (direct)
+        return direct;
+    const legacy = await readOneShotRecord(path.join(completedDir, `${runId}.md`), true);
+    if (legacy)
+        return legacy;
+    const entries = await readdir(completedDir).catch(() => []);
+    for (const entry of entries) {
+        const logPath = entry.endsWith('.md')
+            ? path.join(completedDir, entry)
+            : path.join(completedDir, entry, 'run.md');
+        const record = await readOneShotRecord(logPath, true);
+        if (record && oneShotRunIdFromLogPath(logPath) === runId)
+            return record;
+    }
+    return null;
+}
+async function readOneShotRecord(logPath, completed) {
+    const content = await readFile(logPath, 'utf-8').catch(() => '');
+    if (!content)
+        return null;
+    const record = parseCursorRunLog(content, logPath);
+    record.status = resolveRunStatus(record, completed);
+    return record.status === 'completed' ? record : null;
+}
+function oneShotRunIdFromLogPath(logPath) {
+    if (path.basename(logPath) === 'run.md')
+        return path.basename(path.dirname(logPath));
+    return path.basename(logPath, '.md');
+}
+function buildDagModifyLog(taskId, runId, state) {
+    const finished = Object.values(state.nodes).filter((node) => node.status === 'FINISHED');
+    return [
+        '# 修改记录',
+        '',
+        '## 1. 修改文件清单',
+        '',
+        `- Promoted from completed DAG run \`${runId}\` for task \`${taskId}\`.`,
+        '',
+        '## 2. 关键改动说明',
+        '',
+        ...finished.map((node) => `- ${node.id}: ${excerpt(node.assistantText ?? node.stdout ?? 'finished')}`),
+        '',
+    ].join('\n');
+}
+function buildDagVerifyResult(taskId, runId, state) {
+    const nodes = Object.values(state.nodes);
+    const verifyNodes = nodes.filter((node) => /verify|ci|check/i.test(node.id));
+    const failed = nodes.filter((node) => node.status === 'ERROR');
+    const lines = [
+        '# 验证结果',
+        '',
+        '## 1. 执行的命令',
+        '',
+        verifyNodes.length > 0
+            ? verifyNodes.map((node) => `- DAG node \`${node.id}\`: ${node.failureCategory ?? node.status}`).join('\n')
+            : '- No dedicated verify/ci/check DAG node was found in completed run facts.',
+        '',
+        '## 2. 通过项',
+        '',
+        `- Promoted deterministic evidence from completed DAG run \`${runId}\` for task \`${taskId}\`.`,
+        ...verifyNodes.filter((node) => node.status === 'FINISHED').map((node) => `- ${node.id}: ${node.failureCategory ?? 'success'}`),
+        '',
+        '## 3. 失败项',
+        '',
+        failed.length > 0
+            ? failed.map((node) => `- ${node.id}: ${node.failureCategory ?? 'error'}`).join('\n')
+            : '- No failed DAG nodes recorded.',
+        '',
+    ];
+    return lines.join('\n');
+}
+function buildOneShotModifyLog(taskId, runId, record) {
+    return [
+        '# 修改记录',
+        '',
+        '## 1. 修改文件清单',
+        '',
+        `- Promoted from completed one-shot run \`${runId}\` for task \`${taskId}\`.`,
+        '',
+        '## 2. 关键改动说明',
+        '',
+        `- Task: ${record.task || '(not recorded)'}`,
+        `- Result: ${excerpt(record.resultSummary ?? 'completed')}`,
+        '',
+    ].join('\n');
+}
+function buildOneShotVerifyResult(taskId, runId, record) {
+    return [
+        '# 验证结果',
+        '',
+        '## 1. 执行的命令',
+        '',
+        '- One-shot run evidence does not expose deterministic shell commands; inspect the run log for details.',
+        '',
+        '## 2. 通过项',
+        '',
+        `- One-shot run \`${runId}\` for task \`${taskId}\` completed with status ${record.tableStatus ?? record.status}.`,
+        '',
+        '## 3. 失败项',
+        '',
+        record.failureCategory && record.failureCategory !== 'success'
+            ? `- Failure category recorded: ${record.failureCategory}`
+            : '- No failure category recorded.',
+        '',
+    ].join('\n');
+}
+function summarizeSection(content) {
+    return content
+        .split(/\r?\n/)
+        .filter((line) => line.trim().startsWith('- '))
+        .slice(0, 8)
+        .join('\n');
+}
+function summarizeVerification(content) {
+    if (!/npm|vitest|check-repo|typecheck|lint|CI|exit code|passed|failed/i.test(content)) {
+        return '- No concrete verification evidence found in task artifacts.';
+    }
+    const bullets = summarizeSection(content);
+    return bullets || '- Verification artifact exists; inspect task artifacts for details.';
+}
+function excerpt(value, max = 220) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, max)}...`;
+}
+export async function pathExists(filePath) {
+    return Boolean(await stat(filePath).catch(() => null));
+}