@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/workflows/dag/path-safety.js

@@ -0,0 +1 @@
+export { assertReadableRegularFile, assertRealPathInsideBoundary, readFileBoundarySafe, } from "../../shared/path-safety.js";

package/dist/workflows/dag/prompt.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { DEFAULT_DAG_OUTPUT_LANGUAGE, } from "./types.js";
 import { formatStdoutPreview, formatUpstreamArtifactPointerMap, } from "./upstream-artifacts.js";
 export const MAX_UPSTREAM_CHARS = 2_000;
@@ -45,42 +46,9 @@ function formatResolvedSkillInstructions(instructions) {
     if (!instructions || instructions.length === 0)
         return "(none)";
     return instructions
-        .map((instruction) => formatSkillChecklist(instruction))
+        .map((instruction) => instruction.promptText)
         .join("\n\n---\n\n");
 }
-/** Keep skill provenance, but turn bounded inline manuals into a small action list. */
-function formatSkillChecklist(instruction) {
-    const metadata = [
-        `Skill: ${instruction.name}`,
-        `Resolution: ${instruction.resolution}`,
-        ...(instruction.path ? [`Path: ${instruction.path}`] : []),
-        ...(instruction.sha256 ? [`Sha256: ${instruction.sha256}`] : []),
-        "Injection mode: checklist",
-    ];
-    if (instruction.resolution !== "resolved")
-        return [...metadata, instruction.promptText].join("\n");
-    const source = instruction.promptText.split("Instructions:\n")[1] ?? "";
-    const candidates = source
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => /^(?:#{1,3}\s+|[-*]\s+|\d+[.)]\s+)/.test(line) || line.length > 0)
-        .map((line) => line.replace(/^#{1,3}\s+/, "").replace(/^[-*]\s+/, "").replace(/^\d+[.)]\s+/, ""))
-        .filter((line) => line.length > 0);
-    const checklist = [];
-    let chars = 0;
-    for (const item of candidates) {
-        const bounded = item.slice(0, 240);
-        if (checklist.length >= 10 || chars + bounded.length > 1_600)
-            break;
-        checklist.push(`- ${bounded}`);
-        chars += bounded.length;
-    }
-    return [
-        ...metadata,
-        "Checklist (apply these actions; consult the immutable resolved file only when a listed action requires detail):",
-        ...(checklist.length > 0 ? checklist : ["- Follow the resolved skill's declared workflow."]),
-    ].join("\n");
-}
 export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE) {
     if (language === "en") {
         return [
@@ -95,9 +63,10 @@ export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE
         "如果当前节点任务明确要求其他语言，以节点的明确要求为准。",
     ].join("\n");
 }
-export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS) {
+export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS, runDir) {
     const sections = [];
     const toleratedFailures = new Set(task.failureAwareDependsOn ?? []);
+    const consumedArtifactIds = new Set((task.consumesArtifacts ?? []).map((binding) => binding.artifactId));
     for (const depId of task.depends_on) {
         const record = upstream[depId];
         const stdout = record?.stdout?.trim() ? record.stdout : "";
@@ -151,6 +120,22 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
         }
         if (!record || record.status !== "FINISHED")
             continue;
+        const consumedArtifacts = (record.declaredArtifacts ?? []).filter((artifact) => consumedArtifactIds.has(artifact.artifactId));
+        const consumedArtifactSection = runDir && consumedArtifacts.length > 0
+            ? [
+                "Declared artifact bindings (read-only run evidence — use the exact paths below; do not edit):",
+                ...consumedArtifacts.flatMap((artifact) => {
+                    const absolutePath = path.resolve(runDir, ...artifact.path.split("/"));
+                    return [
+                        `- artifactId: ${artifact.artifactId}`,
+                        `  path: ${absolutePath}`,
+                        `  status: ${artifact.status}`,
+                        `  sha256: ${artifact.sha256 ?? "unknown"}`,
+                        `  mediaType: ${artifact.mediaType}`,
+                    ];
+                }),
+            ].join("\n")
+            : "";
         if (record.structuredArtifactPath &&
             record.structuredArtifactSchemaId ===
                 "frontend-implementation-contract-v1") {
@@ -163,8 +148,12 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
             ].join("\n"));
             continue;
         }
-        if (!upstreamText)
+        if (!upstreamText) {
+            if (consumedArtifactSection) {
+                sections.push(`## Upstream output: ${depId}\n${consumedArtifactSection}`);
+            }
             continue;
+        }
         const artifactKind = stdout ? "stdout" : "assistant";
         const artifactPath = stdout
             ? record.stdoutArtifactPath
@@ -180,6 +169,9 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
                 `- sha256: ${record.structuredArtifactSha256 ?? "unknown"}`,
             ].join("\n");
         }
+        if (consumedArtifactSection) {
+            section += `\n\n${consumedArtifactSection}`;
+        }
         if (truncated && artifactPath) {
             section += formatUpstreamArtifactPointerMap(record, artifactKind);
         }
@@ -362,7 +354,7 @@ function formatProjectGovernanceContext(ctx) {
     return lines.join("\n");
 }
 export function buildDagNodePromptEnvelope(input) {
-    const { spec, task, upstream, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, projectGovernanceContext, convergenceFeedback, } = input;
+    const { spec, task, upstream, runDir, resolvedSkills = [], resolvedSkillInstructions = [], maxUpstreamChars = MAX_UPSTREAM_CHARS, projectGovernanceContext, convergenceFeedback, } = input;
     const objective = spec.objective ?? spec.title;
     const successCriteria = formatBulletList(spec.successCriteria, "(none specified)");
     const globalConstraints = formatBulletList(spec.globalConstraints, "(none specified)");
@@ -372,7 +364,7 @@ export function buildDagNodePromptEnvelope(input) {
         ? resolvedSkills.map((skill) => `- ${skill}`).join("\n")
         : "(none)";
     const skillInstructionsSection = formatResolvedSkillInstructions(resolvedSkillInstructions);
-    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars);
+    const upstreamContext = buildUpstreamContext(task, upstream, maxUpstreamChars, runDir);
     const readOnlyBoundary = buildReadOnlyBoundary(writePolicy);
     const sections = [
         `<dag_objective>\n${objective}\n</dag_objective>`,

package/dist/workflows/dag/report.js

@@ -125,8 +125,6 @@ const dagNodeArtifactsReportSchema = z
     humanEscalationMd: dagArtifactRefSchema,
     humanApproval: dagArtifactRefSchema,
     humanRejection: dagArtifactRefSchema,
-    changeManifest: dagArtifactRefSchema,
-    changeManifestChangedFiles: z.array(z.string()).optional(),
 })
     .strict();
 const dagNodeReportRowSchema = z
@@ -261,20 +259,6 @@ export async function probeArtifact(filePath) {
 export async function buildNodeArtifactsReport(runDir, nodeId) {
     const nodeDir = path.join(runDir, nodeId);
     const artifact = (name) => probeArtifact(path.join(nodeDir, name));
-    const changeManifestRef = await artifact("change-manifest.json");
-    let changeManifestChangedFiles;
-    if (changeManifestRef.exists) {
-        try {
-            const manifest = JSON.parse(await readFile(path.join(nodeDir, "change-manifest.json"), "utf-8"));
-            changeManifestChangedFiles = Array.isArray(manifest.changedFiles)
-                ? manifest.changedFiles
-                    .filter((item) => typeof item === "string")
-                : undefined;
-        }
-        catch {
-            // unreadable manifest → leave undefined
-        }
-    }
     return {
         resultSummary: await artifact("result.summary.md"),
         promptRedacted: await artifact("prompt.redacted.md"),
@@ -286,8 +270,6 @@ export async function buildNodeArtifactsReport(runDir, nodeId) {
         humanEscalationMd: await artifact("human-escalation.md"),
         humanApproval: await artifact("human-approval.json"),
         humanRejection: await artifact("human-rejection.json"),
-        changeManifest: changeManifestRef,
-        changeManifestChangedFiles,
     };
 }
 function taskById(spec) {
@@ -744,12 +726,6 @@ function formatArtifactFlags(artifacts) {
         flags.push("approval");
     if (artifacts.humanRejection.exists)
         flags.push("rejection");
-    if (artifacts.changeManifest.exists) {
-        const count = artifacts.changeManifestChangedFiles?.length;
-        flags.push(count !== undefined
-            ? `changed:${count}`
-            : "change-manifest");
-    }
     return flags.length > 0 ? flags.join(",") : "-";
 }
 function formatTimestamp(value) {
@@ -773,19 +749,7 @@ function summarizeNodeStatuses(nodes) {
     return `${total} total / ${finished} finished / ${failed} failed / ${skipped} skipped / ${pending} pending`;
 }
 function hasArtifact(artifacts) {
-    return [
-        artifacts.resultSummary,
-        artifacts.promptRedacted,
-        artifacts.skills,
-        artifacts.nodeRecord,
-        artifacts.decisionEnvelope,
-        artifacts.decisionEnvelopeValidation,
-        artifacts.humanEscalationJson,
-        artifacts.humanEscalationMd,
-        artifacts.humanApproval,
-        artifacts.humanRejection,
-        artifacts.changeManifest,
-    ].some((artifact) => artifact.exists);
+    return Object.values(artifacts).some((artifact) => artifact.exists);
 }
 function failureRows(run) {
     return run.nodes.filter((node) => node.status === "ERROR" ||

package/dist/workflows/dag/rerun-feedback.js

@@ -2,8 +2,6 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseJsonReviewVerdict } from "./output-protocol.js";
-import { FRONTEND_DESIGN_REVIEW_NODE_ID, FRONTEND_REVIEW_NODE_ID, readCommittedDesignRequestFact, readCommittedReviewRequestFact, } from "./frontend-review-findings.js";
-import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 export const MAX_RERUN_FEEDBACK_CHARS = 12_000;
 const RERUN_FEEDBACK_TRUNCATION_MARKER = "\n\n...[上一轮反馈已按长度上限截断]...\n\n";
 const MAX_EVIDENCE_REFS = 8;
@@ -37,44 +35,6 @@ function requestRevision(text) {
         return (emphasized?.[1] ?? trimmed).trim() === "VERDICT: request-revision";
     });
 }
-/**
- * Deterministically render a typed `request_review_changes` fact into feedback
- * text. Unlike the legacy text channel (VERDICT: request-revision), the
- * frontend review terminal is a committed typed fact; the findings are the
- * actionable body the next round must consume.
- */
-export function formatTypedReviewRequestFeedback(fact) {
-    const lines = [];
-    lines.push(`frontend review committed request_review_changes (issueCategory=${typeof fact.issueCategory === "string" ? fact.issueCategory : "unknown"})`);
-    if (Array.isArray(fact.findings) && fact.findings.length > 0) {
-        lines.push("review findings:");
-        for (const finding of fact.findings) {
-            if (!finding || typeof finding !== "object")
-                continue;
-            const record = finding;
-            const severity = typeof record.severity === "string" ? record.severity : "";
-            const issue = typeof record.issue === "string" ? record.issue : "";
-            const location = [
-                typeof record.file === "string" ? record.file : "",
-                typeof record.line === "number" ? String(record.line) : "",
-            ]
-                .filter(Boolean)
-                .join(":");
-            const prefix = location ? `[${location}] ` : "";
-            const requiredChange = typeof record.requiredChange === "string" &&
-                record.requiredChange.length > 0
-                ? ` (requiredChange: ${record.requiredChange})`
-                : "";
-            lines.push(`- ${prefix}${severity}: ${issue}${requiredChange}`);
-        }
-    }
-    if (Array.isArray(fact.evidenceRefs) && fact.evidenceRefs.length > 0) {
-        lines.push(`evidenceRefs: ${fact.evidenceRefs
-            .filter((ref) => typeof ref === "string")
-            .join(", ")}`);
-    }
-    return lines.join("\n");
-}
 function pathInside(root, candidate) {
     const relative = path.relative(root, candidate);
     return (relative === "" ||
@@ -167,162 +127,6 @@ function evidenceRefs(repoRoot, runDir, pass, sourceNodeId) {
     }
     return result;
 }
-/**
- * Read the committed frontend review request fact (typed terminal channel).
- * Returns { nodeId, fact } when the review node committed `request_review_changes`.
- */
-async function readTypedReviewRequestFact(runDir) {
-    const fact = await readCommittedReviewRequestFact({ runDir });
-    if (!fact)
-        return undefined;
-    return {
-        nodeId: FRONTEND_REVIEW_NODE_ID,
-        fact: {
-            issueCategory: fact.issueCategory,
-            evidenceRefs: fact.evidenceRefs,
-            findings: fact.findings,
-        },
-    };
-}
-/**
- * Read the committed frontend design request fact (typed terminal channel).
- * Returns { nodeId, fact } when the design review node committed
- * `request_design_changes` — the design analog of request_review_changes.
- */
-async function readTypedDesignRequestFact(runDir) {
-    const fact = await readCommittedDesignRequestFact({ runDir });
-    if (!fact)
-        return undefined;
-    return {
-        nodeId: FRONTEND_DESIGN_REVIEW_NODE_ID,
-        fact: {
-            issueCategory: fact.issueCategory,
-            evidenceRefs: fact.evidenceRefs,
-            findings: fact.findings,
-        },
-    };
-}
-const RERUN_FEEDBACK_LINEAGE_MAX_DEPTH = 5;
-const RERUN_FEEDBACK_LINEAGE_LIFECYCLES = [
-    "active",
-    "paused",
-    "completed",
-];
-function safeLineageRunId(value) {
-    if (typeof value !== "string" || !value || value !== value.trim())
-        return undefined;
-    if (value === "." ||
-        value === ".." ||
-        value.includes("/") ||
-        value.includes("\\") ||
-        value.includes("\0"))
-        return undefined;
-    return value;
-}
-async function readCommittedTerminalKind(input) {
-    try {
-        const records = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.nodeId, input.factsFile));
-        for (const record of records) {
-            if (record.phase !== "committed")
-                continue;
-            const kind = record.fact.kind;
-            if (typeof kind === "string" && input.kinds.includes(kind))
-                return kind;
-        }
-    }
-    catch {
-        // A missing/unreadable terminal store means this run did not establish a
-        // usable resolution barrier; lineage lookup may continue.
-    }
-    return undefined;
-}
-async function readReviewTerminalKind(runDir) {
-    return readCommittedTerminalKind({
-        runDir,
-        nodeId: FRONTEND_REVIEW_NODE_ID,
-        factsFile: "review-typed-facts.jsonl",
-        kinds: ["request_review_changes", "approve_review"],
-    });
-}
-async function readDesignTerminalKind(runDir) {
-    return readCommittedTerminalKind({
-        runDir,
-        nodeId: FRONTEND_DESIGN_REVIEW_NODE_ID,
-        factsFile: "design-typed-facts.jsonl",
-        kinds: ["request_design_changes", "approve_design"],
-    });
-}
-/**
- * Walk the rerun-task lineage chain (`<runDir>/.runtime/rerun-task-lineage.json`
- * → parentRunId) looking for the nearest ancestor run with a committed review
- * or design request fact. A nearer final-review approval resolves all older
- * findings; a nearer design approval resolves older design findings while
- * still allowing an older final-review request to survive. Bounded depth;
- * unsafe ids, mismatched state identities, cycles, and unreadable lineage
- * files terminate the walk with undefined.
- */
-async function readAncestorTypedRequestFact(runDir) {
-    let currentRunDir = runDir;
-    let currentRunId;
-    let designResolved = false;
-    const dagRunsRoot = path.resolve(runDir, "..", "..");
-    const visitedRunDirs = new Set([path.resolve(runDir)]);
-    for (let depth = 0; depth <= RERUN_FEEDBACK_LINEAGE_MAX_DEPTH; depth += 1) {
-        const reviewTerminalKind = await readReviewTerminalKind(currentRunDir);
-        if (currentRunId && reviewTerminalKind === "request_review_changes") {
-            const fact = await readTypedReviewRequestFact(currentRunDir);
-            if (fact)
-                return { ...fact, parentRunId: currentRunId };
-        }
-        if (reviewTerminalKind === "approve_review")
-            return undefined;
-        const designTerminalKind = await readDesignTerminalKind(currentRunDir);
-        if (currentRunId &&
-            !designResolved &&
-            designTerminalKind === "request_design_changes") {
-            const fact = await readTypedDesignRequestFact(currentRunDir);
-            if (fact)
-                return { ...fact, parentRunId: currentRunId };
-        }
-        if (designTerminalKind === "approve_design")
-            designResolved = true;
-        if (depth === RERUN_FEEDBACK_LINEAGE_MAX_DEPTH)
-            return undefined;
-        let parentRunId;
-        try {
-            const lineage = JSON.parse(await readFile(path.join(currentRunDir, ".runtime", "rerun-task-lineage.json"), "utf8"));
-            parentRunId = safeLineageRunId(lineage.parentRunId);
-        }
-        catch {
-            return undefined;
-        }
-        if (!parentRunId)
-            return undefined;
-        let ancestorRunDir;
-        for (const lifecycle of RERUN_FEEDBACK_LINEAGE_LIFECYCLES) {
-            const candidate = path.join(dagRunsRoot, lifecycle, parentRunId);
-            try {
-                const ancestorState = JSON.parse(await readFile(path.join(candidate, "state.json"), "utf8"));
-                if (ancestorState.runId === parentRunId) {
-                    ancestorRunDir = candidate;
-                    break;
-                }
-            }
-            catch {
-                // try next lifecycle
-            }
-        }
-        if (!ancestorRunDir)
-            return undefined;
-        const resolvedAncestorRunDir = path.resolve(ancestorRunDir);
-        if (visitedRunDirs.has(resolvedAncestorRunDir))
-            return undefined;
-        visitedRunDirs.add(resolvedAncestorRunDir);
-        currentRunDir = ancestorRunDir;
-        currentRunId = parentRunId;
-    }
-    return undefined;
-}
 /**
  * Derive only the latest unresolved verify/review feedback from canonical
  * parent-run facts. Provider-only failures intentionally return undefined.
@@ -340,67 +144,8 @@ export async function deriveDagRerunFeedback(input) {
             break;
         }
     }
-    if (!sourceNodeId || !sourceNode) {
-        // Typed terminal channel: the frontend review/design review commit their
-        // verdicts as typed facts (request_review_changes / request_design_changes)
-        // instead of VERDICT text, and the frontend DAG has no convergence
-        // passHistory. Fall back to reading the typed event stores so findings
-        // still flow into the next round as unresolved feedback. Prefer review;
-        // if absent, fall through to the design review (a design rejection also
-        // carries actionable findings the next plan round must consume). When
-        // the direct parent has neither because it failed before review, walk the
-        // rerun-task lineage chain — chained
-        // reruns otherwise lose the grandparent's code-review findings and the
-        // reviewer re-flags them as "unresolved previous-round feedback" (r18).
-        // A committed approval is a resolution barrier and prevents older
-        // findings from being resurrected.
-        const typedFact = (await readTypedReviewRequestFact(input.runDir)) ??
-            (await readTypedDesignRequestFact(input.runDir)) ??
-            (await readAncestorTypedRequestFact(input.runDir));
-        if (typedFact) {
-            const parentSourceBindingHash = sourceBindingHash(input.spec);
-            return withDigest({
-                schemaVersion: 1,
-                kind: "unresolved-terminal-feedback",
-                parentRunId: "parentRunId" in typedFact &&
-                    typeof typedFact.parentRunId === "string"
-                    ? typedFact.parentRunId
-                    : input.parentRunId,
-                taskId: input.taskId,
-                sourceNodeId: typedFact.nodeId,
-                verdict: "request-revision",
-                failureCategory: typedFact.nodeId === FRONTEND_REVIEW_NODE_ID
-                    ? "review-request-changes"
-                    : "design-request-changes",
-                feedbackText: scrubAndBoundFeedbackText(formatTypedReviewRequestFeedback(typedFact.fact), input.runDir, input.state.cwd),
-                evidenceRefs: [
-                    {
-                        nodeId: typedFact.nodeId,
-                        preservedNodeRecordPath: `${typedFact.nodeId}.json`,
-                    },
-                ],
-                attemptSummary: {
-                    completedPasses: 1,
-                    maxPasses: 1,
-                    ...(input.state.terminalReason
-                        ? { terminalReason: input.state.terminalReason }
-                        : {}),
-                },
-                binding: {
-                    ...(parentSourceBindingHash
-                        ? { sourceCanonicalHash: parentSourceBindingHash }
-                        : {}),
-                    ...(input.spec.taskContractBinding?.canonicalHash
-                        ? {
-                            taskContractCanonicalHash: input.spec.taskContractBinding.canonicalHash,
-                        }
-                        : {}),
-                    status: "unknown",
-                },
-            });
-        }
+    if (!sourceNodeId || !sourceNode)
         return undefined;
-    }
     const completedPasses = pass?.pass ?? Math.max(1, input.state.convergence?.currentPass ?? 1);
     const maxPasses = Math.max(completedPasses, input.state.convergence?.maxPasses ?? 1);
     const parentSourceBindingHash = sourceBindingHash(input.spec);