@tea-agent/loop-agent 0.41.0 → 0.42.0-next.1

package/dist/workflows/dag/init-hybrid.js

@@ -45,6 +45,60 @@ const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
 const MAX_SOURCE_EXCERPT_CHARS = 2000;
 const MAX_INLINE_SOURCE_REFERENCE_DOCUMENTS = 8;
+/**
+ * Generation-time compiler for machine-declared structured artifacts. The
+ * frozen spec remains the sole runtime authority: this compiler never reads
+ * prompt/outputContract prose or workspace filenames, and historical specs
+ * loaded outside init-hybrid are left untouched.
+ */
+function stampGeneratedArtifactBindings(spec) {
+    const producedByNode = new Map();
+    for (const task of spec.tasks) {
+        if ((task.producesArtifacts?.length ?? 0) > 0) {
+            for (const artifact of task.producesArtifacts ?? []) {
+                producedByNode.set(task.id, artifact.artifactId);
+            }
+            continue;
+        }
+        const gate = task.shell?.jsonArtifactGate;
+        const structured = task.structuredContractOutput;
+        if (!gate && !structured)
+            continue;
+        const artifactId = `${task.id}.structured-output`;
+        const path = gate
+            ? `${gate.outputDir}/${gate.artifactName}`
+            : `contracts/candidates/${task.id}/canonical-contract.json`;
+        task.producesArtifacts = [
+            {
+                artifactId,
+                kind: "structured",
+                path,
+                mediaType: "application/json",
+                schemaId: gate?.schemaId ?? FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+                revisionPolicy: "replace-file",
+            },
+        ];
+        producedByNode.set(task.id, artifactId);
+    }
+    for (const task of spec.tasks) {
+        const existing = new Set((task.consumesArtifacts ?? []).map((binding) => binding.artifactId));
+        const generated = task.depends_on.flatMap((parentNodeId) => {
+            const artifactId = producedByNode.get(parentNodeId);
+            if (!artifactId || existing.has(artifactId))
+                return [];
+            existing.add(artifactId);
+            return [
+                {
+                    artifactId,
+                    required: task.dependsPolicy !== "all-or-condition-skip",
+                },
+            ];
+        });
+        if (generated.length > 0) {
+            task.consumesArtifacts = [...(task.consumesArtifacts ?? []), ...generated];
+        }
+    }
+}
 const INTERACTIVE_UI_DELIVERY_CONTRACT = [
     "[INTERACTIVE_UI_DELIVERY_CONTRACT]",
     "This is an interactive UI delivery task.",
@@ -2074,6 +2128,7 @@ export function buildStandardHybridDagFromTask(sources) {
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -2279,6 +2334,7 @@ function buildBlockedFrontendMockDag(sources, readOnlyPaths, forbiddenPaths, glo
         ],
     };
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -3353,6 +3409,7 @@ async function buildFrontendHybridDagFromTask(sources) {
     };
     spec.tasks = pruneFrontendTasksForRisk(spec.tasks, frontendRisk);
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -4020,6 +4077,84 @@ const BACKEND_TEST_SKILLS_BY_ROLE = {
     verifier: ["verification-before-completion", "systematic-debugging"],
     closeout: ["loop-agent", "verification-before-completion"],
 };
+/**
+ * Read-only Worker workflow for producing a revision-eligible Backend Test
+ * Analysis v2 contract without crossing into test generation or execution.
+ * The explicit consumer keeps artifact lineage meaningful for safe
+ * continuation: replacing the contract reruns review + deterministic closeout
+ * only.
+ */
+function buildBackendTestAnalysisHybridDag(sources) {
+    const analysis = buildAnalyzeInputsNode(sources);
+    const contract = buildBackendTestAnalysisContractGateNode(sources);
+    const review = {
+        id: "review-backend-test-analysis-pi",
+        depends_on: [contract.id],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Concise Markdown review of the validated Backend Test Analysis v2 contract, covering source binding, explicit requirement coverage, evidence gaps, risks, and downstream readiness. No file writes.",
+        subtask_prompt: [
+            "Review the validated run-owned `contracts/backend-test-analysis.json` artifact.",
+            "Treat that structured artifact as the authoritative analysis contract; do not substitute the producer's assistant prose.",
+            "Check that every explicit AC/REQ/BR is represented by acceptanceCriteria or an evidenceGap, source references are precise, and unknown behavior remains an evidence gap rather than an invented requirement.",
+            "Summarize source-binding integrity, coverage, risks, evidence gaps, and whether the contract is ready for a later backend-test generation workflow.",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+        ].join("\n\n"),
+    };
+    const closeout = {
+        id: "backend-test-analysis-closeout-static",
+        depends_on: [review.id],
+        role: "closeout",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic handoff pointing to the validated analysis contract and its independent read-only review.",
+        subtask_prompt: "Close the read-only analysis workflow after the structured contract and review both succeed.",
+        static: {
+            resultMarkdown: [
+                "# Backend-test analysis closeout",
+                "",
+                "Validated contract: `contracts/backend-test-analysis.json`.",
+                "Independent review: `review-backend-test-analysis-pi`.",
+            ].join("\n"),
+        },
+    };
+    const spec = {
+        version: 3,
+        title: `Backend test analysis DAG: ${sources.taskConfig.title}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, sources.taskConfig.title),
+        successCriteria: [
+            "A strict Backend Test Analysis v2 contract is materialized with immutable source binding",
+            "Every explicit requirement is covered or preserved as an evidence gap",
+            "An independent read-only review consumes the validated structured artifact",
+        ],
+        globalConstraints: [
+            ...sources.taskConfig.hardConstraints,
+            "This workflow is analysis-only: no repository writer, dynamic expansion, test generation, or test execution is allowed.",
+        ],
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: sources.taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        verifyStrategy: resolveDagVerifyStrategy(sources.taskConfig),
+        tasks: [analysis, contract, review, closeout],
+    };
+    applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
 /**
  * Plan D: gap-fill incremental DAG (mode=gap-fill).
  *
@@ -4421,6 +4556,7 @@ async function buildBackendTestGapFillDag(sources) {
         spec.backendTestSharedSetup = { ...sharedSetup };
     }
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -4923,6 +5059,7 @@ async function buildBackendTestHybridDag(sources) {
         spec.backendTestSharedSetup = { ...intake.sharedSetup };
     }
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -5677,6 +5814,7 @@ function buildFrontendTestHybridDag(sources) {
     };
     applyFrontendTestLayoutToDagSpec(spec, layout);
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -6179,6 +6317,7 @@ function buildKnowledgeSyncHybridDag(sources) {
             buildKnowledgeSyncPointerNode(sources, featureId),
         ],
     };
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -6625,6 +6764,7 @@ function buildKnowledgeGraphBootstrapHybridDag(sources) {
             buildKgBootstrapMaterializeNode(sources),
         ],
     };
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -6722,6 +6862,8 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
     }
     else if (template === "frontend-test-dag")
         spec = buildFrontendTestHybridDag(sources);
+    else if (template === "backend-test-analysis-dag")
+        spec = buildBackendTestAnalysisHybridDag(sources);
     else if (template === "backend-test-dag")
         spec = await buildBackendTestHybridDag(sources);
     else if (template === "knowledge-sync-dag")
@@ -6758,6 +6900,7 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
         template === "supervised-implementation") {
         stampTargetTemplateTransientRetryProfile(spec);
     }
+    stampGeneratedArtifactBindings(spec);
     spec = parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -6765,6 +6908,7 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
 const GOVERNANCE_DISALLOWED_TEMPLATES = new Set([
     "frontend-implementation",
     "frontend-test-dag",
+    "backend-test-analysis-dag",
     "backend-test-dag",
     "knowledge-sync-dag",
     "knowledge-graph-bootstrap-dag",
@@ -7125,6 +7269,7 @@ function buildReviewGatedHybridDag(standard, sources) {
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -7630,6 +7775,7 @@ async function buildSupervisedHybridDag(standard, sources) {
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;

package/dist/workflows/dag/node-execution.js

@@ -10,6 +10,7 @@ import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
+import { materializeDeclaredArtifactFacts } from "./artifact-bindings.js";
 import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry, } from "./backend-test-writer-completeness.js";
 import { computeBackoffDelayMs, isCanonicalFinalVerifyShellRetryCandidate, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, VERIFY_SHELL_RETRY_POLICY, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
@@ -42,7 +43,11 @@ function canonicalApprovalJson(value) {
 export function parseAndValidateFinalWriteSetApproval(input) {
     const binding = input.task.finalWriteSetApproval;
     if (!binding) {
-        return { ok: false, reason: "missing final write-set approval binding", approvalSourceNodeId: "(missing)" };
+        return {
+            ok: false,
+            reason: "missing final write-set approval binding",
+            approvalSourceNodeId: "(missing)",
+        };
     }
     const source = input.state.nodes[binding.approvalSourceNodeId];
     if (source?.status !== "FINISHED" || parseProcessVerdict(source) !== "pass") {
@@ -53,20 +58,44 @@ export function parseAndValidateFinalWriteSetApproval(input) {
         };
     }
     const raw = canonicalNodeOutput(source);
-    const blocks = [...raw.matchAll(/```FINAL_WRITE_SET_APPROVAL_JSON\s*\r?\n([\s\S]*?)\r?\n```/g)];
+    const blocks = [
+        ...raw.matchAll(/```FINAL_WRITE_SET_APPROVAL_JSON\s*\r?\n([\s\S]*?)\r?\n```/g),
+    ];
     if (blocks.length !== 1) {
-        return { ok: false, reason: `expected exactly one FINAL_WRITE_SET_APPROVAL_JSON block, found ${blocks.length}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: `expected exactly one FINAL_WRITE_SET_APPROVAL_JSON block, found ${blocks.length}`,
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     let approval;
     try {
         approval = JSON.parse(blocks[0][1]);
     }
     catch {
-        return { ok: false, reason: "final write-set approval is not valid JSON", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval is not valid JSON",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
-    const required = ["schemaVersion", "writerNodeId", "approvalSourceNodeId", "auditedPlanNodeId", "approvedWriteSet", "taskContractSha256", "auditedPlanSha256", "approvalDigest"];
-    if (Object.keys(approval).length !== required.length || required.some((key) => !(key in approval))) {
-        return { ok: false, reason: "final write-set approval has an invalid schema", approvalSourceNodeId: binding.approvalSourceNodeId };
+    const required = [
+        "schemaVersion",
+        "writerNodeId",
+        "approvalSourceNodeId",
+        "auditedPlanNodeId",
+        "approvedWriteSet",
+        "taskContractSha256",
+        "auditedPlanSha256",
+        "approvalDigest",
+    ];
+    if (Object.keys(approval).length !== required.length ||
+        required.some((key) => !(key in approval))) {
+        return {
+            ok: false,
+            reason: "final write-set approval has an invalid schema",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const approved = approval.approvedWriteSet;
     if (approval.schemaVersion !== 1 ||
@@ -79,12 +108,20 @@ export function parseAndValidateFinalWriteSetApproval(input) {
         typeof approval.taskContractSha256 !== "string" ||
         typeof approval.auditedPlanSha256 !== "string" ||
         typeof approval.approvalDigest !== "string") {
-        return { ok: false, reason: "final write-set approval binding or field types are invalid", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval binding or field types are invalid",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     if (!/^[a-f0-9]{64}$/.test(approval.taskContractSha256) ||
         !/^[a-f0-9]{64}$/.test(approval.auditedPlanSha256) ||
         !/^[a-f0-9]{64}$/.test(approval.approvalDigest)) {
-        return { ok: false, reason: "final write-set approval digest fields are invalid", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval digest fields are invalid",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const canonicalPayload = { ...approval };
     delete canonicalPayload.approvalDigest;
@@ -92,33 +129,70 @@ export function parseAndValidateFinalWriteSetApproval(input) {
         .update(canonicalApprovalJson(canonicalPayload))
         .digest("hex");
     if (approval.approvalDigest !== expectedDigest) {
-        return { ok: false, reason: "final write-set approval digest mismatch", approvalSourceNodeId: binding.approvalSourceNodeId };
+        return {
+            ok: false,
+            reason: "final write-set approval digest mismatch",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const expectedTaskDigest = input.spec.taskContractBinding?.canonicalHash;
     const plan = input.state.nodes[binding.auditedPlanNodeId];
     const expectedPlanDigest = createHash("sha256")
         .update(canonicalNodeOutput(plan))
         .digest("hex");
-    if (!expectedTaskDigest || approval.taskContractSha256 !== expectedTaskDigest || approval.auditedPlanSha256 !== expectedPlanDigest) {
-        return { ok: false, reason: "final write-set approval is stale for the task contract or audited plan", approvalSourceNodeId: binding.approvalSourceNodeId };
+    if (!expectedTaskDigest ||
+        approval.taskContractSha256 !== expectedTaskDigest ||
+        approval.auditedPlanSha256 !== expectedPlanDigest) {
+        return {
+            ok: false,
+            reason: "final write-set approval is stale for the task contract or audited plan",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     const effectiveWriteSet = approved;
-    if (effectiveWriteSet.length === 0 || new Set(effectiveWriteSet).size !== effectiveWriteSet.length) {
-        return { ok: false, reason: "final write-set approval must contain a non-empty ordered unique path set", approvalSourceNodeId: binding.approvalSourceNodeId };
+    if (effectiveWriteSet.length === 0 ||
+        new Set(effectiveWriteSet).size !== effectiveWriteSet.length) {
+        return {
+            ok: false,
+            reason: "final write-set approval must contain a non-empty ordered unique path set",
+            approvalSourceNodeId: binding.approvalSourceNodeId,
+        };
     }
     for (const entry of effectiveWriteSet) {
         const normalized = entry.replace(/\\/g, "/").replace(/^\.\//, "");
-        if (!normalized || normalized === "." || normalized === ".." || normalized.includes("*") || normalized.includes("?") || normalized.includes("REPLACE/") || normalized.includes("PLACEHOLDER")) {
-            return { ok: false, reason: `final write-set approval contains a broad or placeholder path: ${entry}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+        if (!normalized ||
+            normalized === "." ||
+            normalized === ".." ||
+            normalized.includes("*") ||
+            normalized.includes("?") ||
+            normalized.includes("REPLACE/") ||
+            normalized.includes("PLACEHOLDER")) {
+            return {
+                ok: false,
+                reason: `final write-set approval contains a broad or placeholder path: ${entry}`,
+                approvalSourceNodeId: binding.approvalSourceNodeId,
+            };
         }
         if (!input.task.allowedPaths.some((allowed) => pathMatchesPattern(normalized, allowed))) {
-            return { ok: false, reason: `final write-set approval exceeds allowedPaths: ${entry}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+            return {
+                ok: false,
+                reason: `final write-set approval exceeds allowedPaths: ${entry}`,
+                approvalSourceNodeId: binding.approvalSourceNodeId,
+            };
         }
         if (input.task.forbiddenPaths.some((forbidden) => pathMatchesPattern(normalized, forbidden))) {
-            return { ok: false, reason: `final write-set approval overlaps forbiddenPaths: ${entry}`, approvalSourceNodeId: binding.approvalSourceNodeId };
+            return {
+                ok: false,
+                reason: `final write-set approval overlaps forbiddenPaths: ${entry}`,
+                approvalSourceNodeId: binding.approvalSourceNodeId,
+            };
         }
     }
-    return { ok: true, effectiveWriteSet, approvalDigest: approval.approvalDigest };
+    return {
+        ok: true,
+        effectiveWriteSet,
+        approvalDigest: approval.approvalDigest,
+    };
 }
 export function buildNodePrompt(spec, task, upstream, options) {
     const policy = resolveContextPolicy(spec);
@@ -126,6 +200,7 @@ export function buildNodePrompt(spec, task, upstream, options) {
         spec,
         task,
         upstream,
+        runDir: options?.runDir,
         resolvedSkills: policy.resolveSkills(spec, task),
         maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
         projectGovernanceContext: options?.projectGovernanceContext,
@@ -314,10 +389,7 @@ function promptRestartCandidateForAttempt(input) {
     }
     const appendedPrefix = `${input.baseRuntimePrompt}\n\n`;
     if (input.attemptPrompt.startsWith(appendedPrefix)) {
-        return [
-            input.taskPrompt,
-            input.attemptPrompt.slice(appendedPrefix.length),
-        ]
+        return [input.taskPrompt, input.attemptPrompt.slice(appendedPrefix.length)]
             .filter(Boolean)
             .join("\n\n");
     }
@@ -353,6 +425,7 @@ export async function buildNodePromptWithResolvedSkillInstructions(spec, task, u
             spec,
             task,
             upstream,
+            runDir: options?.runDir,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
             maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
@@ -533,7 +606,11 @@ export async function executeDagNode(input) {
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
     };
     if (task.finalWriteSetApproval) {
-        const authorization = parseAndValidateFinalWriteSetApproval({ task, spec, state });
+        const authorization = parseAndValidateFinalWriteSetApproval({
+            task,
+            spec,
+            state,
+        });
         if (!authorization.ok) {
             node.runtimeWriteAuthorization = {
                 schemaVersion: 1,
@@ -622,6 +699,7 @@ export async function executeDagNode(input) {
                     spec,
                     task,
                     upstream: state.nodes,
+                    runDir,
                     snapshot: skillSnapshot,
                     projectGovernanceContext,
                 });
@@ -712,6 +790,7 @@ export async function executeDagNode(input) {
         else {
             ({ prompt, resolvedSkills } =
                 await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd, {
+                    runDir,
                     projectGovernanceContext,
                     convergenceFeedback: deriveConvergenceFeedback(state),
                 }));
@@ -875,6 +954,7 @@ export async function executeDagNode(input) {
                 model,
                 ...(thinking ? { thinking } : {}),
                 prompt: attemptPrompt,
+                resolvedSkills: resolvedSkills.map((skill) => skill.name),
                 attempt: attemptNumber,
                 reportActivity,
                 timeoutMs: livenessPolicy.absoluteMaxWallClockMs,
@@ -912,9 +992,7 @@ export async function executeDagNode(input) {
                         ...result,
                         ok: false,
                         failureCategory: GOVERNANCE_BLOCKED_CATEGORY,
-                        stderr: [result.stderr, audit.reason]
-                            .filter(Boolean)
-                            .join("\n"),
+                        stderr: [result.stderr, audit.reason].filter(Boolean).join("\n"),
                     };
                 }
             }
@@ -1237,6 +1315,13 @@ export async function executeDagNode(input) {
             node.structuredArtifactSha256 = pendingStructuredArtifact.sha256;
             node.structuredArtifactSchemaId = pendingStructuredArtifact.schemaId;
         }
+        if ((task.producesArtifacts?.length ?? 0) > 0) {
+            node.declaredArtifacts = await materializeDeclaredArtifactFacts({
+                runDir,
+                task,
+                node,
+            });
+        }
     }
     const finishedAt = new Date().toISOString();
     node.finishedAt = finishedAt;

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;
@@ -62,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 : "";
@@ -118,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") {
@@ -130,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
@@ -147,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);
         }
@@ -329,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)");
@@ -339,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>`,