@tea-agent/loop-agent 0.1.0

package/dist/workflows/dag/prompt-source.js

@@ -0,0 +1,88 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+const INLINE_PROMPT_FIELD = "subtask_prompt";
+const MARKDOWN_PROMPT_FIELD = "subtask_prompt_markdown";
+const HYPHENATED_MARKDOWN_PROMPT_FIELD = "subtask_prompt-markdown";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(record, key) {
+    return Object.hasOwn(record, key);
+}
+function taskLabel(task, index) {
+    return typeof task.id === "string" && task.id.trim() ? task.id : `#${index}`;
+}
+export function assertDagPromptSourceRule(raw, options) {
+    if (!isRecord(raw))
+        return;
+    if (!Array.isArray(raw.tasks))
+        return;
+    raw.tasks.forEach((taskRaw, index) => {
+        if (!isRecord(taskRaw))
+            return;
+        const label = taskLabel(taskRaw, index);
+        if (hasOwn(taskRaw, HYPHENATED_MARKDOWN_PROMPT_FIELD)) {
+            throw new Error(`task ${label} must use ${MARKDOWN_PROMPT_FIELD}, not ${HYPHENATED_MARKDOWN_PROMPT_FIELD}`);
+        }
+        const hasInline = hasOwn(taskRaw, INLINE_PROMPT_FIELD);
+        const hasMarkdown = hasOwn(taskRaw, MARKDOWN_PROMPT_FIELD);
+        if (hasInline === hasMarkdown) {
+            throw new Error(`task ${label} must contain exactly one of ${INLINE_PROMPT_FIELD} or ${MARKDOWN_PROMPT_FIELD}`);
+        }
+        if (hasInline) {
+            const prompt = taskRaw[INLINE_PROMPT_FIELD];
+            if (typeof prompt !== "string" || prompt.trim().length === 0) {
+                throw new Error(`task ${label} ${INLINE_PROMPT_FIELD} must be a non-empty string`);
+            }
+        }
+        if (hasMarkdown) {
+            if (!options.allowMarkdown) {
+                throw new Error(`task ${label} uses ${MARKDOWN_PROMPT_FIELD}; load DAGs with loadDagSpecFromFile so markdown prompts can be resolved`);
+            }
+            const markdownPath = taskRaw[MARKDOWN_PROMPT_FIELD];
+            if (typeof markdownPath !== "string" ||
+                markdownPath.trim().length === 0) {
+                throw new Error(`task ${label} ${MARKDOWN_PROMPT_FIELD} must be a non-empty string`);
+            }
+        }
+    });
+}
+export async function normalizeDagPromptSources(raw, dagDir) {
+    assertDagPromptSourceRule(raw, { allowMarkdown: true });
+    if (!isRecord(raw) || !Array.isArray(raw.tasks))
+        return raw;
+    const tasks = await Promise.all(raw.tasks.map(async (taskRaw, index) => {
+        if (!isRecord(taskRaw) || !hasOwn(taskRaw, MARKDOWN_PROMPT_FIELD)) {
+            return taskRaw;
+        }
+        const label = taskLabel(taskRaw, index);
+        const markdownPath = String(taskRaw[MARKDOWN_PROMPT_FIELD]);
+        const resolvedPath = path.resolve(dagDir, markdownPath);
+        let content;
+        try {
+            content = await readFile(resolvedPath, "utf-8");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`failed to read ${MARKDOWN_PROMPT_FIELD} for task ${label}: ${resolvedPath}: ${message}`);
+        }
+        if (content.trim().length === 0) {
+            throw new Error(`task ${label} ${MARKDOWN_PROMPT_FIELD} resolved to an empty file: ${resolvedPath}`);
+        }
+        const { [MARKDOWN_PROMPT_FIELD]: _markdown, ...rest } = taskRaw;
+        return {
+            ...rest,
+            [INLINE_PROMPT_FIELD]: content,
+            subtask_prompt_source: {
+                type: "markdown",
+                path: markdownPath,
+                sha256: createHash("sha256").update(content).digest("hex"),
+            },
+        };
+    }));
+    return {
+        ...raw,
+        tasks,
+    };
+}

package/dist/workflows/dag/prompt.js

@@ -0,0 +1,130 @@
+import { formatStdoutPreview, formatUpstreamArtifactPointerMap, } from "./upstream-artifacts.js";
+export const MAX_UPSTREAM_CHARS = 2_000;
+/** Shared bullets for DAG authoring templates, docs, and planner-node envelopes. */
+export const DAG_AUTHORING_GUIDANCE = [
+    "Prefer same-rank parallel read-only scouts over unnecessary serial depends_on chains.",
+    "Add depends_on only when a child truly needs upstream output; default to independent ranks.",
+    "Every task must explicitly declare executor; defaults.executor is schema-only, not a runtime fallback.",
+    "Cursor remains a first-class executor for scouts and exclusive implementers when it fits the task.",
+    "exclusive nodes require narrow, concrete, disjoint writeSet paths; never use ** or repo root.",
+    "Read-only nodes must not write repository files, including root artifacts/**; return findings in node output only.",
+    "If the DAG is a single linear chain, challenge whether read-only work can run in parallel ranks.",
+];
+const PLANNER_AUTHORING_ROLES = new Set(["planner"]);
+function formatBulletList(items, emptyLabel) {
+    if (!items || items.length === 0)
+        return emptyLabel;
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function formatPaths(paths) {
+    if (!paths || paths.length === 0)
+        return "(none)";
+    return paths.join(", ");
+}
+function resolveWritePolicy(task, spec) {
+    return task.writePolicy ?? spec.defaults?.writePolicy ?? "(not specified)";
+}
+function resolveOutputContract(task) {
+    return task.outputContract ?? "(none)";
+}
+function formatAuthoringGuidanceBlock() {
+    return DAG_AUTHORING_GUIDANCE.map((item) => `- ${item}`).join("\n");
+}
+function formatExecutor(task) {
+    return (task.executor ??
+        "(not specified — declare executor explicitly on every task)");
+}
+function formatResolvedSkillInstructions(instructions) {
+    if (!instructions || instructions.length === 0)
+        return "(none)";
+    return instructions
+        .map((instruction) => instruction.promptText)
+        .join("\n\n---\n\n");
+}
+export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS) {
+    const sections = [];
+    for (const depId of task.depends_on) {
+        const record = upstream[depId];
+        const stdout = record?.stdout?.trim() ? record.stdout : "";
+        const assistantText = record?.assistantText?.trim()
+            ? record.assistantText
+            : "";
+        const upstreamText = stdout || assistantText;
+        if (!record || record.status !== "FINISHED" || !upstreamText)
+            continue;
+        const artifactKind = stdout ? "stdout" : "assistant";
+        const artifactPath = stdout
+            ? record.stdoutArtifactPath
+            : record.assistantArtifactPath;
+        const { preview, truncated } = formatStdoutPreview(upstreamText, maxChars);
+        let section = `## Upstream output: ${depId}\n${preview}`;
+        if (truncated && artifactPath) {
+            section += formatUpstreamArtifactPointerMap(record, artifactKind);
+        }
+        sections.push(section);
+    }
+    return sections.join("\n\n");
+}
+function buildReadOnlyBoundary(writePolicy) {
+    if (writePolicy !== "read-only")
+        return [];
+    return [
+        "Read-only boundary: do not write, create, edit, delete, stage, or commit any repository files.",
+        "This includes root artifacts/**; root artifacts/ is not a read-only scratchpad.",
+        "Return findings in the assistant response/stdout only; the DAG runner persists node artifacts under .harness/dag-runs/<state>/<run-id>/<node-id>/.",
+    ];
+}
+export function buildDagNodePromptEnvelope(input) {
+    const { spec, task, upstream, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, } = input;
+    const objective = spec.objective ?? spec.title;
+    const successCriteria = formatBulletList(spec.successCriteria, "(none specified)");
+    const globalConstraints = formatBulletList(spec.globalConstraints, "(none specified)");
+    const role = task.role ?? "(not specified)";
+    const writePolicy = resolveWritePolicy(task, spec);
+    const skillsSection = resolvedSkills.length > 0
+        ? resolvedSkills.map((skill) => `- ${skill}`).join("\n")
+        : "(none)";
+    const skillInstructionsSection = formatResolvedSkillInstructions(resolvedSkillInstructions);
+    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars);
+    const readOnlyBoundary = buildReadOnlyBoundary(writePolicy);
+    const sections = [
+        `<dag_objective>\n${objective}\n</dag_objective>`,
+        `<success_criteria>\n${successCriteria}\n</success_criteria>`,
+        `<global_constraints>\n${globalConstraints}\n</global_constraints>`,
+        [
+            "<node_contract>",
+            `Role: ${role}`,
+            `Executor: ${formatExecutor(task)}`,
+            `Write policy: ${writePolicy}`,
+            `Allowed paths: ${formatPaths(task.allowedPaths)}`,
+            `Forbidden paths: ${formatPaths(task.forbiddenPaths)}`,
+            `Write set: ${formatPaths(task.writeSet)}`,
+            `Output contract: ${resolveOutputContract(task)}`,
+            ...readOnlyBoundary,
+            "</node_contract>",
+        ].join("\n"),
+        [
+            "<required_skills>",
+            "Before acting, apply the following skills:",
+            skillsSection,
+            "</required_skills>",
+        ].join("\n"),
+        [
+            "<resolved_skill_instructions>",
+            "The DAG runner resolved these skill files deterministically. Apply the bounded instructions below when present. Missing/error entries mean only the skill name is available; do not assume hidden Pi ResourceLoader skills.",
+            skillInstructionsSection,
+            "</resolved_skill_instructions>",
+        ].join("\n"),
+    ];
+    if (task.role && PLANNER_AUTHORING_ROLES.has(task.role)) {
+        sections.push(`<authoring_guidance>\n${formatAuthoringGuidanceBlock()}\n</authoring_guidance>`);
+    }
+    if (upstreamContext) {
+        sections.push(`<upstream_context>\n${upstreamContext}\n</upstream_context>`);
+    }
+    else {
+        sections.push("<upstream_context>\n(none)\n</upstream_context>");
+    }
+    sections.push(`<task>\n${task.subtask_prompt}\n</task>`);
+    return sections.join("\n\n");
+}

package/dist/workflows/dag/reconcile-tasks.js

@@ -0,0 +1,404 @@
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getArtifactPath, validateArtifactContent } from '../../shared/artifacts-core.js';
+import { parseCursorRunLog, resolveRunStatus } from '../../records/one-shot-runs.js';
+import { listAllDagRunEntries, readDagRunSpec, readDagRunState, } from './lifecycle.js';
+import { matchGlob } from '../../shared/reference-context.js';
+import { getTaskPaths } from '../../task/runtime.js';
+const TASKS_DIR = path.join('.harness', 'tasks');
+const REQUIRED_ARTIFACTS = [
+    { fileName: '修改记录.md', step: 'implement', label: 'modify log' },
+    { fileName: '验证结果.md', step: null, label: 'verify result' },
+];
+const TEMPLATE_MARKERS = [/TODO/i, /REPLACE/i, /<template/i, /待替换/];
+const VERIFY_MARKERS = [/npm\s+(run\s+)?test/i, /vitest/i, /check-repo\.sh/i, /typecheck/i, /lint/i, /CI/i, /verify/i, /验证/];
+const CLOSEOUT_NAMES = ['复盘报告.md', 'closeout.md', 'closeout.json', 'handoff.md'];
+export async function runTaskReconcile(repoRoot, options) {
+    const glob = options.glob || '*';
+    const patchMode = Boolean(options.patch);
+    const taskIds = await listMatchingTaskIds(repoRoot, glob);
+    const dagRuns = await loadDagRunFacts(repoRoot);
+    const oneShotRuns = await loadOneShotRunFacts(repoRoot);
+    const misplacedArtifacts = await listMisplacedCodeAgentArtifacts(repoRoot);
+    const patches = [];
+    const tasks = [];
+    for (const taskId of taskIds) {
+        const report = await reconcileOneTask(repoRoot, taskId, dagRuns, oneShotRuns, misplacedArtifacts, patchMode, patches);
+        tasks.push(report);
+    }
+    const findings = tasks.flatMap((task) => task.findings);
+    const errors = findings.filter((finding) => finding.severity === 'error').length;
+    const warnings = findings.filter((finding) => finding.severity === 'warning').length;
+    const infos = findings.filter((finding) => finding.severity === 'info').length;
+    return {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        glob,
+        mode: patchMode ? 'patch' : 'report-only',
+        ok: findings.length === 0,
+        summary: {
+            tasksScanned: tasks.length,
+            findings: findings.length,
+            errors,
+            warnings,
+            infos,
+            patches: patches.length,
+        },
+        tasks,
+        patches,
+    };
+}
+export function formatTaskReconcileJson(report) {
+    return `${JSON.stringify(report, null, 2)}\n`;
+}
+export function formatTaskReconcileMarkdown(report) {
+    const lines = [
+        '# Task Reconcile Report',
+        '',
+        `- glob: \`${report.glob}\``,
+        `- mode: \`${report.mode}\``,
+        `- tasks scanned: ${report.summary.tasksScanned}`,
+        `- findings: ${report.summary.findings} (${report.summary.errors} errors, ${report.summary.warnings} warnings, ${report.summary.infos} info)`,
+        `- patches: ${report.summary.patches}`,
+        '',
+        '| Task | Severity | Kind | Message |',
+        '|---|---|---|---|',
+    ];
+    const findings = report.tasks.flatMap((task) => task.findings);
+    if (findings.length === 0) {
+        lines.push('| - | - | - | No drift detected |');
+    }
+    else {
+        for (const finding of findings) {
+            lines.push(`| \`${finding.taskId}\` | ${finding.severity} | ${finding.kind} | ${escapeMarkdownTable(finding.message)} |`);
+        }
+    }
+    if (report.patches.length > 0) {
+        lines.push('', '## Patches', '', '| Task | Action | Path |', '|---|---|---|');
+        for (const patch of report.patches) {
+            lines.push(`| \`${patch.taskId}\` | ${escapeMarkdownTable(patch.action)} | \`${patch.path}\` |`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+async function listMatchingTaskIds(repoRoot, glob) {
+    const tasksRoot = path.join(repoRoot, TASKS_DIR);
+    let entries;
+    try {
+        entries = await readdir(tasksRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((taskId) => matchGlob(glob, taskId))
+        .sort((left, right) => left.localeCompare(right));
+}
+async function reconcileOneTask(repoRoot, taskId, dagRuns, oneShotRuns, misplacedArtifacts, patchMode, patches) {
+    const findings = [];
+    const paths = getTaskPaths(repoRoot, taskId);
+    const rawTask = await readJsonFile(paths.taskConfigPath);
+    const workflow = await readJsonFile(paths.statePath);
+    const taskJsonStatus = typeof rawTask?.status === 'string' ? rawTask.status : null;
+    const workflowStatus = isWorkflowStatus(workflow?.status) ? workflow.status : null;
+    if (!workflowStatus) {
+        findings.push(finding(taskId, 'error', 'state-drift', 'missing or unreadable .workflow_state.json status', [relative(repoRoot, paths.statePath)]));
+    }
+    if (taskJsonStatus && workflowStatus && taskJsonStatus !== workflowStatus) {
+        findings.push(finding(taskId, 'warning', 'state-drift', `task.json.status (${taskJsonStatus}) differs from workflow status (${workflowStatus})`, [relative(repoRoot, paths.taskConfigPath), relative(repoRoot, paths.statePath)]));
+        if (patchMode) {
+            await patchTaskJsonStatus(paths.taskConfigPath, workflowStatus);
+            patches.push({ taskId, action: `set task.json.status to ${workflowStatus}`, path: relative(repoRoot, paths.taskConfigPath) });
+        }
+    }
+    await checkArtifacts(repoRoot, taskId, findings, patchMode, patches);
+    await checkDagRuns(repoRoot, taskId, workflowStatus, dagRuns, findings);
+    await checkOneShotRuns(repoRoot, taskId, workflowStatus, oneShotRuns, findings);
+    checkMisplacedArtifacts(repoRoot, taskId, misplacedArtifacts, findings);
+    await checkVerification(repoRoot, taskId, findings);
+    return {
+        taskId,
+        status: { taskJsonStatus, workflowStatus },
+        findings,
+    };
+}
+async function checkOneShotRuns(repoRoot, taskId, workflowStatus, oneShotRuns, findings) {
+    const related = oneShotRuns.filter((run) => oneShotMentionsTask(run, taskId));
+    if (related.length === 0)
+        return;
+    const paths = getTaskPaths(repoRoot, taskId);
+    const modifyPath = getArtifactPath(paths.taskDir, 'implement');
+    const verifyPath = getArtifactPath(paths.taskDir, 'verify');
+    const needsPromotion = await artifactNeedsPromotion(modifyPath, verifyPath);
+    for (const run of related) {
+        if (run.lifecycle === 'active') {
+            findings.push(finding(taskId, 'warning', 'run-drift', `active one-shot run ${run.runId} is ${run.record.status}; reconcile or archive it`, [relative(repoRoot, run.runDir)]));
+            continue;
+        }
+        if (run.lifecycle === 'failed' && workflowStatus === 'completed') {
+            findings.push(finding(taskId, 'error', 'run-drift', `failed one-shot run ${run.runId} exists for completed task`, [relative(repoRoot, run.runDir)]));
+            continue;
+        }
+        if (run.lifecycle === 'completed' && workflowStatus && workflowStatus !== 'completed') {
+            findings.push(finding(taskId, 'warning', 'run-drift', `completed one-shot run ${run.runId} exists while task status is ${workflowStatus}`, [relative(repoRoot, run.runDir)]));
+        }
+        if (run.lifecycle === 'completed' && needsPromotion) {
+            findings.push(finding(taskId, 'warning', 'promotion-drift', `completed one-shot run ${run.runId} has not been promoted to task artifacts; run: npm run dev -- promote-run ${taskId} --run-id ${run.runId}`, [relative(repoRoot, run.runDir), relative(repoRoot, modifyPath), relative(repoRoot, verifyPath)]));
+        }
+    }
+}
+function checkMisplacedArtifacts(repoRoot, taskId, misplacedArtifacts, findings) {
+    if (misplacedArtifacts.length === 0)
+        return;
+    findings.push(finding(taskId, 'error', 'artifact-drift', './artifacts contains misplaced runtime artifacts; DAG Cursor artifacts must live under .harness/dag-runs/<state>/<run-id>/artifacts/<node-id>/', misplacedArtifacts.map((artifact) => relative(repoRoot, artifact))));
+}
+async function checkArtifacts(repoRoot, taskId, findings, patchMode, patches) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const requirementPath = path.join(paths.sourceDir, '需求.md');
+    if (!(await fileExists(requirementPath))) {
+        findings.push(finding(taskId, 'error', 'artifact-drift', 'missing source/需求.md', [relative(repoRoot, requirementPath)]));
+        if (patchMode) {
+            await mkdir(path.dirname(requirementPath), { recursive: true });
+            await writeFile(requirementPath, '# 需求\n\n<!-- TODO: fill task requirements -->\n', 'utf-8');
+            patches.push({ taskId, action: 'created missing requirement skeleton', path: relative(repoRoot, requirementPath) });
+        }
+    }
+    const constraintsPath = path.join(paths.sourceDir, '执行约束.md');
+    if (await fileExists(constraintsPath)) {
+        const constraints = await readFile(constraintsPath, 'utf-8');
+        if (!constraints.trim()) {
+            findings.push(finding(taskId, 'warning', 'artifact-drift', 'source/执行约束.md exists but is empty', [relative(repoRoot, constraintsPath)]));
+            if (patchMode) {
+                await writeFile(constraintsPath, '# 执行约束\n\n<!-- TODO: fill execution constraints -->\n', 'utf-8');
+                patches.push({ taskId, action: 'created execution constraint skeleton', path: relative(repoRoot, constraintsPath) });
+            }
+        }
+    }
+    for (const artifact of REQUIRED_ARTIFACTS) {
+        const artifactPath = artifact.step
+            ? getArtifactPath(paths.taskDir, artifact.step)
+            : path.join(paths.taskDir, 'artifacts', artifact.fileName);
+        if (!(await fileExists(artifactPath))) {
+            findings.push(finding(taskId, 'warning', 'artifact-drift', `missing ${artifact.label} artifact`, [relative(repoRoot, artifactPath)]));
+            if (patchMode) {
+                await mkdir(path.dirname(artifactPath), { recursive: true });
+                await writeFile(artifactPath, `# ${artifact.fileName.replace(/\.md$/, '')}\n\n<!-- TODO: fill real ${artifact.label}; this is not verification evidence -->\n`, 'utf-8');
+                patches.push({ taskId, action: `created ${artifact.label} skeleton`, path: relative(repoRoot, artifactPath) });
+            }
+            continue;
+        }
+        const content = await readFile(artifactPath, 'utf-8');
+        const messages = artifact.step
+            ? validateArtifactContent(artifact.step, content)
+            : validateVerifyArtifact(content);
+        if (messages.length > 0) {
+            findings.push(finding(taskId, 'warning', 'artifact-drift', `${artifact.label} artifact is not substantive: ${messages.join('; ')}`, [relative(repoRoot, artifactPath)]));
+        }
+    }
+}
+async function checkDagRuns(repoRoot, taskId, workflowStatus, dagRuns, findings) {
+    const related = dagRuns.filter((run) => dagRunMentionsTask(run, taskId));
+    const paths = getTaskPaths(repoRoot, taskId);
+    const needsPromotion = await artifactNeedsPromotion(getArtifactPath(paths.taskDir, 'implement'), getArtifactPath(paths.taskDir, 'verify'));
+    for (const run of related) {
+        if (!run.state)
+            continue;
+        if (run.lifecycle === 'completed' && run.state.status === 'finished' && workflowStatus && workflowStatus !== 'completed') {
+            findings.push(finding(taskId, 'warning', 'dag-run-drift', `completed DAG run ${run.runId} finished while task status is ${workflowStatus}`, [relative(repoRoot, run.runDir)]));
+        }
+        if (run.lifecycle === 'completed' && run.state.status === 'finished' && needsPromotion) {
+            findings.push(finding(taskId, 'warning', 'promotion-drift', `completed DAG run ${run.runId} has not been promoted to task artifacts; run: npm run dev -- promote-run ${taskId} --run-id ${run.runId}`, [relative(repoRoot, run.runDir)]));
+        }
+        if (run.state.status === 'failed' && workflowStatus === 'completed') {
+            findings.push(finding(taskId, 'error', 'dag-run-drift', `DAG run ${run.runId} failed while task is completed`, [relative(repoRoot, run.runDir)]));
+        }
+        if ((run.lifecycle === 'active' || run.lifecycle === 'paused') && workflowStatus === 'completed') {
+            findings.push(finding(taskId, 'warning', 'dag-run-drift', `${run.lifecycle} DAG run ${run.runId} exists for completed task`, [relative(repoRoot, run.runDir)]));
+        }
+    }
+}
+async function checkVerification(repoRoot, taskId, findings) {
+    const paths = getTaskPaths(repoRoot, taskId);
+    const verifyPath = path.join(paths.taskDir, 'artifacts', '验证结果.md');
+    const verifyStat = await stat(verifyPath).catch(() => null);
+    const verifyContent = verifyStat ? await readFile(verifyPath, 'utf-8') : '';
+    const hasVerifyArtifact = validateVerifyArtifact(verifyContent).length === 0;
+    const executorVerify = await latestExecutorVerifyTimestamp(path.join(paths.logsDir, 'executor.jsonl'));
+    const dagVerify = await latestDagShellVerifyTimestamp(repoRoot, taskId);
+    const latestVerifyMs = Math.max(verifyStat?.mtimeMs ?? 0, executorVerify ?? 0, dagVerify ?? 0);
+    if (!hasVerifyArtifact && !executorVerify && !dagVerify) {
+        findings.push(finding(taskId, 'warning', 'verification-drift', 'missing final verify / CI / check-repo evidence', [relative(repoRoot, verifyPath), relative(repoRoot, path.join(paths.logsDir, 'executor.jsonl'))]));
+    }
+    const closeout = await latestCloseoutTimestamp(paths.taskDir);
+    if (closeout && latestVerifyMs > 0 && latestVerifyMs < closeout.mtimeMs) {
+        findings.push(finding(taskId, 'warning', 'verification-drift', 'latest verification evidence is older than closeout artifact', [relative(repoRoot, closeout.path)]));
+    }
+}
+async function loadDagRunFacts(repoRoot) {
+    const entries = await listAllDagRunEntries(repoRoot);
+    const facts = [];
+    for (const entry of entries) {
+        const state = await readDagRunState(entry.runDir).catch(() => null);
+        const spec = await readDagRunSpec(entry.runDir).catch(() => null);
+        facts.push({
+            ...entry,
+            state,
+            specText: spec ? JSON.stringify(spec) : '',
+        });
+    }
+    return facts;
+}
+async function loadOneShotRunFacts(repoRoot) {
+    const facts = [];
+    for (const lifecycle of ['active', 'completed', 'failed']) {
+        const dir = path.join(repoRoot, '.harness', 'runs', lifecycle);
+        const entries = await readdir(dir).catch(() => []);
+        for (const entry of entries) {
+            if (entry === '.gitkeep' || entry === '.DS_Store')
+                continue;
+            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 record = parseCursorRunLog(content, logPath);
+            record.status = resolveRunStatus(record, lifecycle === 'completed', undefined, lifecycle === 'failed');
+            facts.push({
+                runId: entry.endsWith('.md') ? entry.replace(/\.md$/, '') : entry,
+                lifecycle,
+                runDir: entryPath,
+                record,
+            });
+        }
+    }
+    return facts;
+}
+async function listMisplacedCodeAgentArtifacts(repoRoot) {
+    const root = path.join(repoRoot, 'tools', 'loop-agent', 'artifacts');
+    const results = [];
+    await collectFiles(root, results);
+    return results;
+}
+async function collectFiles(dir, results) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectFiles(entryPath, results);
+        }
+        else if (entry.name !== '.gitkeep') {
+            results.push(entryPath);
+        }
+    }
+}
+function dagRunMentionsTask(run, taskId) {
+    const title = run.state?.title ?? '';
+    return run.runId.includes(taskId)
+        || title.includes(taskId)
+        || run.specText.includes(`taskId: ${taskId}`)
+        || run.specText.includes(`"taskId":"${taskId}"`)
+        || run.specText.includes(taskId);
+}
+function oneShotMentionsTask(run, taskId) {
+    return run.runId.includes(taskId)
+        || run.record.taskId === taskId
+        || run.record.task.includes(taskId)
+        || run.record.logPath.includes(taskId);
+}
+async function artifactNeedsPromotion(modifyPath, verifyPath) {
+    const modify = await readFile(modifyPath, 'utf-8').catch(() => '');
+    const verify = await readFile(verifyPath, 'utf-8').catch(() => '');
+    return validateArtifactContent('implement', modify).length > 0 || validateVerifyArtifact(verify).length > 0;
+}
+async function latestExecutorVerifyTimestamp(logPath) {
+    const raw = await readFile(logPath, 'utf-8').catch(() => '');
+    let latest = 0;
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const record = JSON.parse(line);
+            if (record.step === 'verify' && (record.ok === true || record.exitCode === 0) && typeof record.timestamp === 'string') {
+                const time = Date.parse(record.timestamp);
+                if (!Number.isNaN(time))
+                    latest = Math.max(latest, time);
+            }
+        }
+        catch {
+            // Ignore malformed log lines; reconcile reports missing evidence if nothing valid exists.
+        }
+    }
+    return latest || null;
+}
+async function latestDagShellVerifyTimestamp(repoRoot, taskId) {
+    const runs = await loadDagRunFacts(repoRoot);
+    let latest = 0;
+    for (const run of runs.filter((candidate) => dagRunMentionsTask(candidate, taskId))) {
+        for (const [nodeId, node] of Object.entries(run.state?.nodes ?? {})) {
+            if (!/verify|ci|check/i.test(nodeId))
+                continue;
+            if (node.status !== 'FINISHED' || node.failureCategory !== 'success')
+                continue;
+            const time = typeof node.finishedAt === 'string' ? Date.parse(node.finishedAt) : 0;
+            if (!Number.isNaN(time))
+                latest = Math.max(latest, time);
+        }
+    }
+    return latest || null;
+}
+async function latestCloseoutTimestamp(taskDir) {
+    const artifactsDir = path.join(taskDir, 'artifacts');
+    let latest = null;
+    for (const name of CLOSEOUT_NAMES) {
+        const candidate = path.join(artifactsDir, name);
+        const candidateStat = await stat(candidate).catch(() => null);
+        if (!candidateStat)
+            continue;
+        if (!latest || candidateStat.mtimeMs > latest.mtimeMs) {
+            latest = { path: candidate, mtimeMs: candidateStat.mtimeMs };
+        }
+    }
+    return latest;
+}
+async function patchTaskJsonStatus(taskConfigPath, status) {
+    const raw = await readJsonFile(taskConfigPath);
+    const next = { ...(raw ?? {}), status };
+    await writeFile(taskConfigPath, `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+}
+function validateVerifyArtifact(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return ['artifact content is empty'];
+    if (TEMPLATE_MARKERS.some((marker) => marker.test(trimmed))) {
+        return ['artifact contains template marker'];
+    }
+    if (!VERIFY_MARKERS.some((marker) => marker.test(trimmed))) {
+        return ['artifact does not mention verification commands or CI evidence'];
+    }
+    return [];
+}
+async function readJsonFile(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function fileExists(filePath) {
+    return Boolean(await stat(filePath).catch(() => null));
+}
+function isWorkflowStatus(value) {
+    return value === 'draft' || value === 'active' || value === 'completed' || value === 'failed';
+}
+function finding(taskId, severity, kind, message, evidence) {
+    return { taskId, severity, kind, message, evidence };
+}
+function relative(repoRoot, target) {
+    return path.relative(repoRoot, target).replace(/\\/g, '/');
+}
+function escapeMarkdownTable(value) {
+    return value.replace(/\|/g, '\\|').replace(/\n/g, ' ');
+}