@tea-agent/loop-agent 0.26.0 → 0.26.2

package/dist/task/source-prepare/reference-integrity.js

@@ -0,0 +1,274 @@
+import { createHash } from "node:crypto";
+import { lstat, open, readFile } from "node:fs/promises";
+import path from "node:path";
+import { getTaskPaths } from "../runtime.js";
+import { readSourceManifest, } from "../source-references.js";
+import { PREPARE_MAX_FILE_BYTES, PREPARE_MAX_PARSE_DOCS, PREPARE_MAX_TOTAL_BYTES, } from "./types.js";
+const PARSEABLE_EXTENSIONS = new Set([".md", ".markdown", ".txt"]);
+const PARSEABLE_ROLES = new Set(["requirement", "acceptance"]);
+function isSafeRelativeReferencePath(materializedPath) {
+    const normalized = materializedPath.replace(/\\/g, "/").trim();
+    if (!normalized)
+        return false;
+    if (normalized.includes("\0"))
+        return false;
+    if (path.isAbsolute(normalized) || /^[a-zA-Z]:[\\/]/.test(normalized)) {
+        return false;
+    }
+    if (normalized.split("/").some((part) => part === ".."))
+        return false;
+    if (!normalized.startsWith("references/"))
+        return false;
+    return true;
+}
+async function streamSha256AndBytes(filePath, maxBytes) {
+    const handle = await open(filePath, "r");
+    try {
+        const hash = createHash("sha256");
+        const buffer = Buffer.alloc(64 * 1024);
+        let bytes = 0;
+        while (true) {
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            bytes += bytesRead;
+            if (maxBytes !== undefined && bytes > maxBytes) {
+                throw Object.assign(new Error("INPUT_TOO_LARGE"), {
+                    code: "INPUT_TOO_LARGE",
+                    bytes,
+                });
+            }
+            hash.update(buffer.subarray(0, bytesRead));
+        }
+        return { sha256: hash.digest("hex"), bytes };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function isParseableDoc(doc) {
+    const ext = path.extname(doc.materializedPath).toLowerCase();
+    if (!PARSEABLE_EXTENSIONS.has(ext))
+        return false;
+    return PARSEABLE_ROLES.has(doc.role);
+}
+/**
+ * Validate source-manifest + reference files before deriving a draft.
+ * Fail-closed on taskId/path/hash/symlink/size issues.
+ */
+export async function validateImportedPrdReferences(input) {
+    const paths = getTaskPaths(input.repoRoot, input.taskId);
+    const issues = [];
+    const documents = [];
+    const manifest = await readSourceManifest(paths.sourceDir);
+    if (!manifest) {
+        issues.push({
+            code: "MANIFEST_MISSING",
+            level: "blocking",
+            message: "source-manifest.json missing; run import-prd before --use-imported-prd",
+            path: path.join(paths.sourceDir, "source-manifest.json"),
+        });
+        return { ok: false, issues, documents, parseableDocuments: [] };
+    }
+    if (manifest.schemaVersion !== 1) {
+        issues.push({
+            code: "MANIFEST_SCHEMA",
+            level: "blocking",
+            message: `unsupported source-manifest schemaVersion: ${String(manifest.schemaVersion)}`,
+        });
+    }
+    if (manifest.taskId !== input.taskId) {
+        issues.push({
+            code: "MANIFEST_TASK_MISMATCH",
+            level: "blocking",
+            message: `manifest.taskId "${manifest.taskId}" does not match task ${input.taskId}`,
+        });
+    }
+    if (!Array.isArray(manifest.documents)) {
+        issues.push({
+            code: "MANIFEST_INVALID",
+            level: "blocking",
+            message: "source-manifest.documents must be an array",
+        });
+        return { ok: false, issues, documents, parseableDocuments: [] };
+    }
+    // Stable order by materializedPath (import already sorts; re-sort for safety).
+    const ordered = [...manifest.documents].sort((a, b) => a.materializedPath < b.materializedPath
+        ? -1
+        : a.materializedPath > b.materializedPath
+            ? 1
+            : 0);
+    let totalParseBytes = 0;
+    let parseableCount = 0;
+    for (const doc of ordered) {
+        if (!doc ||
+            typeof doc.role !== "string" ||
+            typeof doc.name !== "string" ||
+            typeof doc.materializedPath !== "string" ||
+            typeof doc.sha256 !== "string" ||
+            typeof doc.bytes !== "number") {
+            issues.push({
+                code: "MANIFEST_DOC_INVALID",
+                level: "blocking",
+                message: "manifest document missing required fields",
+            });
+            continue;
+        }
+        if (!isSafeRelativeReferencePath(doc.materializedPath)) {
+            issues.push({
+                code: "REFERENCE_PATH_UNSAFE",
+                level: "blocking",
+                message: `reference path not contained under references/: ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+            continue;
+        }
+        const absolutePath = path.resolve(paths.sourceDir, doc.materializedPath);
+        const relativeToSource = path
+            .relative(paths.sourceDir, absolutePath)
+            .split(path.sep)
+            .join("/");
+        if (relativeToSource.startsWith("..") ||
+            path.isAbsolute(relativeToSource)) {
+            issues.push({
+                code: "REFERENCE_PATH_ESCAPE",
+                level: "blocking",
+                message: `reference path escapes source dir: ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+            continue;
+        }
+        let stats;
+        try {
+            stats = await lstat(absolutePath);
+        }
+        catch {
+            issues.push({
+                code: "REFERENCE_MISSING",
+                level: "blocking",
+                message: `reference file missing: ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+            continue;
+        }
+        if (stats.isSymbolicLink()) {
+            issues.push({
+                code: "REFERENCE_SYMLINK",
+                level: "blocking",
+                message: `reference must be a regular file (symlink rejected): ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+            continue;
+        }
+        if (!stats.isFile()) {
+            issues.push({
+                code: "REFERENCE_NOT_FILE",
+                level: "blocking",
+                message: `reference is not a regular file: ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+            continue;
+        }
+        const parseable = isParseableDoc(doc);
+        if (parseable) {
+            parseableCount += 1;
+            if (parseableCount > PREPARE_MAX_PARSE_DOCS) {
+                issues.push({
+                    code: "INPUT_TOO_LARGE",
+                    level: "blocking",
+                    message: `more than ${PREPARE_MAX_PARSE_DOCS} parseable imported docs`,
+                });
+                continue;
+            }
+        }
+        let hashResult;
+        try {
+            hashResult = await streamSha256AndBytes(absolutePath, parseable ? PREPARE_MAX_FILE_BYTES : undefined);
+        }
+        catch (error) {
+            if (error &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "INPUT_TOO_LARGE") {
+                issues.push({
+                    code: "INPUT_TOO_LARGE",
+                    level: "blocking",
+                    message: `reference exceeds ${PREPARE_MAX_FILE_BYTES} bytes: ${doc.materializedPath}`,
+                    path: doc.materializedPath,
+                });
+                continue;
+            }
+            issues.push({
+                code: "REFERENCE_READ_FAILED",
+                level: "blocking",
+                message: `failed to hash reference: ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+            continue;
+        }
+        if (hashResult.bytes !== doc.bytes) {
+            issues.push({
+                code: "REFERENCE_BYTES_MISMATCH",
+                level: "blocking",
+                message: `bytes mismatch for ${doc.materializedPath}: manifest=${doc.bytes} disk=${hashResult.bytes}`,
+                path: doc.materializedPath,
+            });
+        }
+        if (hashResult.sha256 !== doc.sha256) {
+            issues.push({
+                code: "REFERENCE_HASH_MISMATCH",
+                level: "blocking",
+                message: `sha256 mismatch for ${doc.materializedPath}`,
+                path: doc.materializedPath,
+            });
+        }
+        let content;
+        if (parseable) {
+            totalParseBytes += hashResult.bytes;
+            if (totalParseBytes > PREPARE_MAX_TOTAL_BYTES) {
+                issues.push({
+                    code: "INPUT_TOO_LARGE",
+                    level: "blocking",
+                    message: `total parseable reference bytes exceed ${PREPARE_MAX_TOTAL_BYTES}`,
+                });
+            }
+            else {
+                content = await readFile(absolutePath, "utf-8");
+            }
+        }
+        documents.push({
+            role: doc.role,
+            name: doc.name,
+            materializedPath: doc.materializedPath,
+            absolutePath,
+            sha256: hashResult.sha256,
+            bytes: hashResult.bytes,
+            content,
+            parseable,
+        });
+    }
+    const parseableDocuments = documents.filter((doc) => doc.parseable);
+    const hasRequirement = parseableDocuments.some((doc) => doc.role === "requirement");
+    if (input.requireParseableRequirement !== false && !hasRequirement) {
+        // Still allow if caller will supply supplemental flags/text; prepare.ts decides.
+        // Here we only mark warning-level absence; prepare elevates when needed.
+        issues.push({
+            code: "NO_PARSEABLE_REQUIREMENT",
+            level: "warning",
+            message: "no parseable requirement-role document under source/references (role=requirement, .md/.txt)",
+        });
+    }
+    const blocking = issues.some((issue) => issue.level === "blocking");
+    return {
+        ok: !blocking,
+        issues,
+        documents,
+        parseableDocuments,
+    };
+}
+export function draftReferencesFromManifest(documents) {
+    return documents.map((doc) => ({
+        role: doc.role,
+        ref: doc.materializedPath,
+    }));
+}

package/dist/task/source-prepare/types.js

@@ -0,0 +1,7 @@
+export const PREPARE_MAX_FILE_BYTES = 2 * 1024 * 1024;
+export const PREPARE_MAX_PARSE_DOCS = 8;
+export const PREPARE_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+export const PREPARE_DEFAULT_FORBIDDEN_PATHS = [
+    ".harness/**",
+    "node_modules/**",
+];

package/dist/worker/observability/read-model.js

@@ -1287,6 +1287,12 @@ function mergeDagRun(existing, incoming) {
         ...(ranks && ranks.length > 0 ? { ranks } : {}),
         nodes: mergeDagNodes(existing.nodes, incoming.nodes),
         edges: incoming.edges.length > 0 ? incoming.edges : existing.edges,
+        ...((incoming.controlEdges ?? existing.controlEdges)
+            ? { controlEdges: incoming.controlEdges ?? existing.controlEdges }
+            : {}),
+        ...((incoming.convergence ?? existing.convergence)
+            ? { convergence: incoming.convergence ?? existing.convergence }
+            : {}),
         ...((incoming.dagPath ?? existing.dagPath)
             ? { dagPath: incoming.dagPath ?? existing.dagPath }
             : {}),
@@ -1321,6 +1327,10 @@ function mergeDagNode(existing, incoming) {
         finishedAt: incoming.finishedAt ?? existing.finishedAt,
         outputPreview: incoming.outputPreview ?? existing.outputPreview,
         errorPreview: incoming.errorPreview ?? existing.errorPreview,
+        attemptCount: incoming.attemptCount ?? existing.attemptCount,
+        failureCategory: incoming.failureCategory ?? existing.failureCategory,
+        originKind: incoming.originKind ?? existing.originKind,
+        passes: incoming.passes ?? existing.passes,
     };
 }
 function computeDurationMs(startedAt, finishedAt) {
@@ -1569,6 +1579,9 @@ async function parseDagStateFile(statePath, now) {
         const nodes = parseDagNodes(parsed, rankByNode, modelByNode);
         const edges = await parseDagEdges(runSpecPath, nodes);
         const state = parsed;
+        const controlEdges = await deriveControlLoopEdges(runSpecPath, nodes, state);
+        const convergence = projectConvergenceSummary(state);
+        applyNodePasses(nodes, state);
         const liveness = assessDagRunLiveness({ state, now });
         const effectiveStatus = lifecycle
             ? deriveDagRunEffectiveStatus({
@@ -1647,6 +1660,8 @@ async function parseDagStateFile(statePath, now) {
             ...(ranks.length > 0 ? { ranks } : {}),
             nodes,
             edges,
+            ...(controlEdges.length > 0 ? { controlEdges } : {}),
+            ...(convergence ? { convergence } : {}),
             dagPath: runDir,
             ...(continuation ? { continuation } : {}),
             ...(backendTest ? { backendTest } : {}),
@@ -1683,6 +1698,125 @@ async function parseDagEdges(runPath, nodes) {
     }
     return [...edges.values()].sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
 }
+/**
+ * Derive presentation-only control-loop edges from the run spec's convergence
+ * chain. When the chain contains both `review-gate-shell` and `repair-pi`, the
+ * bounded repair-reverify-review loop exists at runtime and Observe renders it
+ * as a dashed feedback loop. The derived edge is never merged into `edges` or
+ * `ranks`, so DAG topological layout stays acyclic.
+ */
+async function deriveControlLoopEdges(runPath, nodes, state) {
+    const runtimeConvergence = state.convergence;
+    if (!runtimeConvergence?.enabled ||
+        runtimeConvergence.terminalReason === "feature-flag-off" ||
+        runtimeConvergence.terminalReason === "unsupported-dag-shape") {
+        return [];
+    }
+    const parsed = await safeReadJson(runPath);
+    if (!parsed)
+        return [];
+    const convergence = readObject(parsed, "convergence");
+    if (!convergence)
+        return [];
+    const chainNodeIds = readStringArray(convergence, "chainNodeIds");
+    if (chainNodeIds.length === 0)
+        return [];
+    if (!chainNodeIds.includes("review-gate-shell") ||
+        !chainNodeIds.includes("repair-pi")) {
+        return [];
+    }
+    const known = new Set(nodes.map((node) => node.nodeId));
+    if (!known.has("review-gate-shell") || !known.has("repair-pi")) {
+        return [];
+    }
+    return [{ from: "review-gate-shell", to: "repair-pi", kind: "control-loop" }];
+}
+/**
+ * Project `state.convergence` into the slim Observe summary. Keeps the budget
+ * envelope even when passHistory is empty.
+ */
+function projectConvergenceSummary(state) {
+    const convergence = state.convergence;
+    if (!convergence)
+        return undefined;
+    return {
+        enabled: convergence.enabled,
+        maxPasses: convergence.maxPasses,
+        currentPass: convergence.currentPass,
+        ...(convergence.terminalReason
+            ? { terminalReason: convergence.terminalReason }
+            : {}),
+        passHistory: convergence.passHistory.map((pass) => ({
+            pass: pass.pass,
+            ...(pass.reason ? { reason: pass.reason } : {}),
+            ...(pass.status ? { status: pass.status } : {}),
+            ...(pass.hardVerifyStatus
+                ? { hardVerifyStatus: pass.hardVerifyStatus }
+                : {}),
+            ...(pass.reviewVerdict ? { reviewVerdict: pass.reviewVerdict } : {}),
+            ...(pass.reviewGateStatus
+                ? { reviewGateStatus: pass.reviewGateStatus }
+                : {}),
+        })),
+    };
+}
+/**
+ * Record convergence participation from archived pass artifacts plus the live
+ * current pass. The controller archives only retry/terminal failures, so an
+ * active pass or a successful final pass must be derived from current node
+ * state to avoid dropping its pass marker from Observe.
+ */
+function applyNodePasses(nodes, state) {
+    const passesByNode = new Map();
+    const addPass = (nodeId, pass) => {
+        const passes = passesByNode.get(nodeId) ?? new Set();
+        passes.add(pass);
+        passesByNode.set(nodeId, passes);
+    };
+    for (const pass of state.convergence?.passHistory ?? []) {
+        for (const ref of pass.artifactRefs)
+            addPass(ref.nodeId, pass.pass);
+    }
+    const initialPassNodeIds = new Set([
+        "initial-review-pi",
+        "initial-review-gate-shell",
+        "initial-review-pass-shell",
+    ]);
+    for (const node of nodes) {
+        if (!initialPassNodeIds.has(node.nodeId))
+            continue;
+        const status = (node.status ?? "").toUpperCase();
+        if (["RUNNING", "FINISHED", "ERROR"].includes(status)) {
+            addPass(node.nodeId, 1);
+        }
+    }
+    const currentPass = state.convergence?.currentPass;
+    if (currentPass && currentPass > 0) {
+        const convergenceNodeIds = new Set([
+            "process-supervisor-pi",
+            "process-gate-shell",
+            "repair-pi",
+            "hard-verify-shell",
+            "review-pi",
+            "review-verdict-recovery-pi",
+            "review-gate-shell",
+        ]);
+        for (const node of nodes) {
+            if (!convergenceNodeIds.has(node.nodeId))
+                continue;
+            const status = (node.status ?? "").toUpperCase();
+            if (["RUNNING", "FINISHED", "ERROR"].includes(status)) {
+                addPass(node.nodeId, currentPass);
+            }
+        }
+    }
+    for (const node of nodes) {
+        const passes = passesByNode.get(node.nodeId);
+        if (passes && passes.size > 0) {
+            node.passes = [...passes].sort((left, right) => left - right);
+        }
+    }
+}
 function buildRankIndex(ranks) {
     const index = new Map();
     for (let i = 0; i < ranks.length; i++) {

package/dist/worker/observe/static/copy.js

@@ -1,67 +1,67 @@
-/** Copy-only recommended commands (Observe UI R5). */
-import { el } from "./dom.js";
-
-export async function copyText(text) {
-	const value = String(text ?? "");
-	if (!value) return false;
-	try {
-		if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
-			await navigator.clipboard.writeText(value);
-			return true;
-		}
-	} catch {
-		// fall through
-	}
-	try {
-		const ta = document.createElement("textarea");
-		ta.value = value;
-		ta.setAttribute("readonly", "");
-		ta.style.position = "fixed";
-		ta.style.left = "-9999px";
-		document.body.appendChild(ta);
-		ta.select();
-		const ok = document.execCommand("copy");
-		document.body.removeChild(ta);
-		return ok;
-	} catch {
-		return false;
-	}
-}
-
-/** Advisory recommended command: copy-only, never executes. */
-export function renderRecommendedCommand(action) {
-	const block = el("div", "recommended-command");
-	if (!action) {
-		block.appendChild(el("span", "muted", "缺失"));
-		return block;
-	}
-	const head = el("div", "recommended-command-head");
-	if (action.kind) {
-		head.appendChild(el("span", "recommended-command-kind", action.kind));
-	}
-	head.appendChild(
-		el("span", "recommended-command-label", action.label ?? "—"),
-	);
-	block.appendChild(head);
-	if (action.command) {
-		const body = el("div", "recommended-command-body");
-		const code = el("code", "recommended-command-text", action.command);
-		body.appendChild(code);
-		const btn = el("button", "copy-command", "复制");
-		btn.type = "button";
-		btn.addEventListener("click", (e) => {
-			e.preventDefault();
-			e.stopPropagation();
-			void copyText(action.command).then((ok) => {
-				btn.textContent = ok ? "已复制" : "复制失败";
-				setTimeout(() => {
-					btn.textContent = "复制";
-				}, 1500);
-			});
-		});
-		body.appendChild(btn);
-		block.appendChild(body);
-	}
-	return block;
-}
-
+/** Copy-only recommended commands (Observe UI R5). */
+import { el } from "./dom.js";
+
+export async function copyText(text) {
+	const value = String(text ?? "");
+	if (!value) return false;
+	try {
+		if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+			await navigator.clipboard.writeText(value);
+			return true;
+		}
+	} catch {
+		// fall through
+	}
+	try {
+		const ta = document.createElement("textarea");
+		ta.value = value;
+		ta.setAttribute("readonly", "");
+		ta.style.position = "fixed";
+		ta.style.left = "-9999px";
+		document.body.appendChild(ta);
+		ta.select();
+		const ok = document.execCommand("copy");
+		document.body.removeChild(ta);
+		return ok;
+	} catch {
+		return false;
+	}
+}
+
+/** Advisory recommended command: copy-only, never executes. */
+export function renderRecommendedCommand(action) {
+	const block = el("div", "recommended-command");
+	if (!action) {
+		block.appendChild(el("span", "muted", "缺失"));
+		return block;
+	}
+	const head = el("div", "recommended-command-head");
+	if (action.kind) {
+		head.appendChild(el("span", "recommended-command-kind", action.kind));
+	}
+	head.appendChild(
+		el("span", "recommended-command-label", action.label ?? "—"),
+	);
+	block.appendChild(head);
+	if (action.command) {
+		const body = el("div", "recommended-command-body");
+		const code = el("code", "recommended-command-text", action.command);
+		body.appendChild(code);
+		const btn = el("button", "copy-command", "复制");
+		btn.type = "button";
+		btn.addEventListener("click", (e) => {
+			e.preventDefault();
+			e.stopPropagation();
+			void copyText(action.command).then((ok) => {
+				btn.textContent = ok ? "已复制" : "复制失败";
+				setTimeout(() => {
+					btn.textContent = "复制";
+				}, 1500);
+			});
+		});
+		body.appendChild(btn);
+		block.appendChild(body);
+	}
+	return block;
+}
+

package/dist/worker/observe/static/dag-layout.d.ts

@@ -1,31 +1,31 @@
-export type DagLayoutNodeInput = { nodeId: string };
-export type DagLayoutEdgeInput = { from: string; to: string };
-export type DagLayoutNode = {
-	nodeId: string;
-	rank: number;
-	index: number;
-	x: number;
-	y: number;
-	width: number;
-	height: number;
-};
-export type DagLayoutEdge = DagLayoutEdgeInput & { path: string };
-export type DagLayout = {
-	width: number;
-	height: number;
-	nodes: DagLayoutNode[];
-	edges: DagLayoutEdge[];
-};
-
-export function layoutDag(
-	nodes?: DagLayoutNodeInput[],
-	edges?: DagLayoutEdgeInput[],
-	ranks?: string[][],
-	options?: Partial<{
-		nodeWidth: number;
-		nodeHeight: number;
-		rankGap: number;
-		nodeGap: number;
-		padding: number;
-	}>,
-): DagLayout;
+export type DagLayoutNodeInput = { nodeId: string };
+export type DagLayoutEdgeInput = { from: string; to: string };
+export type DagLayoutNode = {
+	nodeId: string;
+	rank: number;
+	index: number;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+};
+export type DagLayoutEdge = DagLayoutEdgeInput & { path: string };
+export type DagLayout = {
+	width: number;
+	height: number;
+	nodes: DagLayoutNode[];
+	edges: DagLayoutEdge[];
+};
+
+export function layoutDag(
+	nodes?: DagLayoutNodeInput[],
+	edges?: DagLayoutEdgeInput[],
+	ranks?: string[][],
+	options?: Partial<{
+		nodeWidth: number;
+		nodeHeight: number;
+		rankGap: number;
+		nodeGap: number;
+		padding: number;
+	}>,
+): DagLayout;