@tea-agent/loop-agent 0.16.25 → 0.16.26

package/dist/worker/observe/spec-evidence.js

@@ -132,6 +132,90 @@ async function readSessionEvents(filePath) {
         return [];
     }
 }
+/**
+ * Coerce a `tool_execution_end` result body (toolResult.content or result.content)
+ * into a string. Accepts plain strings, `{type:"text", text}[]` arrays, and
+ * message.content shapes. Returns null when no usable body is present.
+ */
+function resultContentToString(content) {
+    if (content == null)
+        return null;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const part of content) {
+            if (typeof part === "string") {
+                parts.push(part);
+            }
+            else if (part && typeof part === "object" && typeof part.text === "string") {
+                parts.push(part.text);
+            }
+        }
+        return parts.length > 0 ? parts.join("\n") : null;
+    }
+    return null;
+}
+/**
+ * Scan session events for successful paired `read` tool calls and return the
+ * most recent result body + timestamp whose repo-relative path matches
+ * `relPath` exactly. Used for AC-002: show the content the model actually
+ * received at read time, never the current workspace file.
+ */
+export async function extractSpecReadContent(repoRoot, dagRunId, nodeId, relPath) {
+    if (!relPath || !isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    // The preview endpoint must expose exactly the same membership as the
+    // `specReads` list, not every file the node happened to read.
+    if (!isSpecFilePath(relPath))
+        return null;
+    const eventsPath = resolveSessionEventsPath(repoRoot, dagRunId, nodeId);
+    if (!eventsPath)
+        return null;
+    const events = await readSessionEvents(eventsPath);
+    const startMap = new Map();
+    let latest = null;
+    for (const event of events) {
+        const type = event.type;
+        const toolName = resolveToolName(event);
+        const toolCallId = event.toolCallId;
+        if (type === "tool_execution_start" && toolCallId) {
+            startMap.set(toolCallId, { toolName, input: eventToolArgs(event) });
+            continue;
+        }
+        if (type !== "tool_execution_end" || toolName !== "read" || !toolCallId)
+            continue;
+        const start = startMap.get(toolCallId);
+        if (!start || start.toolName !== "read")
+            continue;
+        const isErrored = event.isError === true ||
+            event.toolResult?.error != null ||
+            event.toolResult?.ok === false ||
+            event.result?.error != null ||
+            event.result?.ok === false;
+        if (isErrored) {
+            startMap.delete(toolCallId);
+            continue;
+        }
+        const startInput = start.input ?? {};
+        const filePath = typeof startInput.path === "string" ? startInput.path : undefined;
+        if (!filePath) {
+            startMap.delete(toolCallId);
+            continue;
+        }
+        const rel = toRepoRelative(repoRoot, filePath);
+        startMap.delete(toolCallId);
+        if (!rel || rel !== relPath)
+            continue;
+        const body = resultContentToString(event.toolResult?.content) ??
+            resultContentToString(event.result?.content);
+        if (body == null)
+            continue;
+        latest = { content: body, timestamp: eventTimestamp(event) };
+    }
+    return latest;
+}
 export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
     if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
         return null;

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

@@ -29,6 +29,29 @@ export async function fetchJsonResult(url) {
 	}
 }
 
+/**
+ * Fetch a spec-evidence file preview (binding source or successful read).
+ * Resolves to the parsed JSON body, or throws an Error carrying the HTTP
+ * status and server message so the UI can render an accessible error state.
+ */
+export async function fetchSpecEvidenceFile(runId, nodeId, source, relPath) {
+	const url = `/api/dag-runs/${encodeURIComponent(runId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence/file?source=${encodeURIComponent(source)}&path=${encodeURIComponent(relPath)}`;
+	const res = await fetch(url);
+	let body = null;
+	try {
+		body = await res.json();
+	} catch {
+		body = null;
+	}
+	if (!res.ok) {
+		const message = body?.error || `加载失败：HTTP ${res.status}`;
+		const error = new Error(message);
+		error.status = res.status;
+		throw error;
+	}
+	return body;
+}
+
 export function artifactUrl(artifactPath) {
 	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
 }

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

@@ -46,6 +46,13 @@ export const uiState = {
 	dagTimelineViewportState: null,
 	dagNodeOutputViewportState: null,
 	runOutputViewportState: null,
+	/**
+	 * Spec-evidence file preview drill-down. null = list view; otherwise
+	 * { source, path, loading, error, data, triggerId } for the active preview.
+	 */
+	specEvidenceDetail: null,
+	/** Last-rendered spec-evidence list, used to restore the list synchronously. */
+	specEvidenceListEvidence: null,
 	pollingGeneration: 0,
 };
 
@@ -271,3 +278,22 @@ export function bumpPollingGeneration() {
 	uiState.pollingGeneration += 1;
 	return uiState.pollingGeneration;
 }
+
+/** Open an in-inspector spec-evidence file preview (AC-001/002). */
+export function openSpecEvidenceDetail(source, path, triggerEl) {
+	uiState.specEvidenceDetail = {
+		source,
+		path,
+		loading: true,
+		error: null,
+		data: null,
+		triggerId: triggerEl?.id ?? null,
+	};
+}
+
+/** Close the preview; caller restores focus to the trigger element. */
+export function closeSpecEvidenceDetail() {
+	const detail = uiState.specEvidenceDetail;
+	uiState.specEvidenceDetail = null;
+	return detail;
+}

package/dist/worker/observe/static/styles.css

@@ -1863,6 +1863,16 @@ body.is-resizing-dag-graph {
 .spec-evidence-time { margin-left: auto; color: var(--muted); font-size: 10px; font-variant-numeric: tabular-nums; white-space: nowrap; }
 .spec-evidence-warning { display: flex; align-items: flex-start; gap: 8px; margin-top: var(--space-4); padding: 10px 12px; border: 1px solid color-mix(in srgb, var(--amber) 50%, var(--hairline)); border-radius: var(--radius-sm); background: #fff8e7; color: var(--body); font-size: 12px; line-height: 1.6; }
 .spec-evidence-warning > i { flex-shrink: 0; margin-top: 2px; color: var(--amber); }
+.spec-evidence-file-btn { display: flex; align-items: flex-start; gap: 6px; width: 100%; padding: 4px 0; background: none; border: none; text-align: left; cursor: pointer; color: inherit; font: inherit; line-height: 1.5; overflow-wrap: anywhere; border-radius: var(--radius-sm); }
+.spec-evidence-file-btn:hover, .spec-evidence-file-btn:focus-visible { background: color-mix(in srgb, var(--accent, #2563eb) 8%, transparent); outline: none; }
+.spec-evidence-file-btn:focus-visible { box-shadow: 0 0 0 2px var(--accent, #2563eb); }
+.spec-evidence-detail { display: grid; gap: var(--space-3); }
+.spec-evidence-back { display: inline-flex; align-items: center; gap: 6px; padding: 4px 10px; border: 1px solid var(--hairline); border-radius: var(--radius-sm); background: var(--surface, #fff); color: var(--ink); font-size: 12px; cursor: pointer; }
+.spec-evidence-back:hover, .spec-evidence-back:focus-visible { background: color-mix(in srgb, var(--accent, #2563eb) 8%, var(--surface, #fff)); }
+.spec-evidence-detail-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; font-size: 12px; color: var(--body); }
+.spec-evidence-detail-content { min-height: 0; max-width: 100%; margin: 0; padding: var(--space-3); border: 1px solid var(--hairline); border-radius: var(--radius-sm); background: var(--surface, #fff); white-space: pre-wrap; overflow-wrap: anywhere; font-size: 12px; line-height: 1.6; }
+.spec-evidence-detail-error { margin: 0; color: var(--red, #c00); font-size: 12px; }
+.spec-evidence-detail-truncated { margin: 0; color: var(--muted); font-size: 11px; }
 
 .run-layer-process {
 	display: grid;

package/dist/worker/observe/static/views/dag-inspector.js

@@ -10,12 +10,14 @@ import {
 	UI_TEXT,
 } from "../constants.js";
 import { clearNode, el } from "../dom.js";
-import { fetchJson } from "../api.js";
+import { fetchJson, fetchSpecEvidenceFile } from "../api.js";
 import { badge } from "../format.js";
 import { renderMarkdown } from "../markdown-render.js";
 import {
 	uiState,
 	makeSessionEventIdentity,
+	openSpecEvidenceDetail,
+	closeSpecEvidenceDetail,
 	updateDagTimelineViewportState,
 	updateDagOutputViewportState,
 	computeFollowLatest,
@@ -44,6 +46,10 @@ export function selectDagNode(dagRunId, nodeId) {
 	if (nodeChanged) {
 		uiState.sessionEventOffset = 0;
 		uiState.sessionEvents = [];
+		// Drop any open spec-evidence preview so a stale A detail cannot survive
+		// into node B's spec-evidence panel (AC-007 regression guard).
+		uiState.specEvidenceDetail = null;
+		uiState.specEvidenceListEvidence = null;
 		// Bump the session-event identity token so any in-flight response for the
 		// previous node is rejected before it can mutate the current node cache.
 		uiState.sessionEventIdentity = makeSessionEventIdentity(dagRunId, nodeId);
@@ -188,15 +194,20 @@ export function captureDagTimelineViewportState(panel) {
 	}
 }
 
-async function renderSpecEvidence(content, dagRunId, nodeId) {
-	const evidence = await fetchJson(
+async function renderSpecEvidence(content, dagRunId, nodeId, cachedEvidence) {
+	const evidence = cachedEvidence ?? await fetchJson(
 		`/api/dag-runs/${encodeURIComponent(dagRunId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence`,
 	);
 	if (!content.isConnected || content.dataset.dagNodeId !== String(nodeId)) return;
+	if (uiState.specEvidenceDetail) {
+		renderSpecEvidenceDetail(content, dagRunId, nodeId);
+		return;
+	}
 	if (!evidence) {
 		content.appendChild(el("p", "empty", "无法加载规范证据。"));
 		return;
 	}
+	uiState.specEvidenceListEvidence = evidence;
 
 	const statusLabels = {
 		"spec-read": "已读取规范",
@@ -241,9 +252,24 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 	});
 	appendListSection("已绑定任务源", evidence.sourceBinding?.sources, (source) => {
 		const item = el("li", null);
+		const button = document.createElement("button");
+		button.type = "button";
+		button.className = "spec-evidence-file-btn";
+		button.setAttribute("data-source", "binding");
+		button.setAttribute("data-path", source.path);
+		button.id = `spec-evidence-btn-binding-${source.path}`;
 		const icon = el("i", "ri-links-line");
 		icon.setAttribute("aria-hidden", "true");
-		item.append(icon, document.createTextNode(` ${source.kind}: `), el("code", null, source.path), document.createTextNode(` · sha256 ${source.sha256.slice(0, 12)}…`));
+		button.append(
+			icon,
+			document.createTextNode(` ${source.kind}: `),
+			el("code", null, source.path),
+			document.createTextNode(` · sha256 ${source.sha256.slice(0, 12)}…`),
+		);
+		button.addEventListener("click", () =>
+			onSpecEvidenceFileClick(content, dagRunId, nodeId, "binding", source.path, button),
+		);
+		item.appendChild(button);
 		return item;
 	});
 	appendListSection("显式需求编号", evidence.sourceBinding?.requirementIds, (id) => el("li", null, id));
@@ -252,11 +278,20 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 		evidence.specReads,
 		(read) => {
 			const item = el("li", null);
+			const button = document.createElement("button");
+			button.type = "button";
+			button.className = "spec-evidence-file-btn";
+			button.setAttribute("data-source", "read");
+			button.setAttribute("data-path", read.path);
+			if (read.timestamp) {
+				button.setAttribute("data-read-at", read.timestamp);
+			}
+			button.id = `spec-evidence-btn-read-${read.path}`;
 			const icon = el("i", "ri-file-text-line");
 			icon.setAttribute("aria-hidden", "true");
-			item.append(icon, el("code", null, read.path));
+			button.append(icon, el("code", null, read.path));
 			if (read.timestamp) {
-				item.appendChild(
+				button.appendChild(
 					el(
 						"span",
 						"spec-evidence-time",
@@ -264,6 +299,10 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 					),
 				);
 			}
+			button.addEventListener("click", () =>
+				onSpecEvidenceFileClick(content, dagRunId, nodeId, "read", read.path, button),
+			);
+			item.appendChild(button);
 			return item;
 		},
 	);
@@ -308,7 +347,135 @@ async function renderSpecEvidence(content, dagRunId, nodeId) {
 	}
 }
 
+/**
+ * Click handler for spec-evidence file buttons (AC-001/002). Opens the detail
+ * view in the same spec-evidence panel (no modal), records the trigger button
+ * so the back action can restore keyboard focus (AC-005).
+ */
+function onSpecEvidenceFileClick(content, dagRunId, nodeId, source, relPath, button) {
+	openSpecEvidenceDetail(source, relPath, button);
+	clearNode(content);
+	const detail = uiState.specEvidenceDetail;
+	renderSpecEvidenceDetail(content, dagRunId, nodeId);
+	void (async () => {
+		try {
+			const data = await fetchSpecEvidenceFile(dagRunId, nodeId, source, relPath);
+			if (
+				!content.isConnected ||
+				content.dataset.dagNodeId !== String(nodeId) ||
+				!uiState.specEvidenceDetail ||
+				uiState.specEvidenceDetail.source !== source ||
+				uiState.specEvidenceDetail.path !== relPath
+			) {
+				return;
+			}
+			detail.loading = false;
+			detail.data = data;
+		} catch (error) {
+			if (
+				!content.isConnected ||
+				content.dataset.dagNodeId !== String(nodeId) ||
+				!uiState.specEvidenceDetail ||
+				uiState.specEvidenceDetail.source !== source ||
+				uiState.specEvidenceDetail.path !== relPath
+			) {
+				return;
+			}
+			detail.loading = false;
+			detail.error = error instanceof Error ? error.message : String(error);
+		}
+		renderSpecEvidenceDetail(content, dagRunId, nodeId);
+	})();
+}
+
+/**
+ * Render the in-inspector file preview (AC-005). Single scroll container for
+ * the body, always-visible back button, and accessible loading/error states.
+ */
+function renderSpecEvidenceDetail(content, dagRunId, nodeId) {
+	const detail = uiState.specEvidenceDetail;
+	clearNode(content);
+	if (!detail) {
+		renderSpecEvidence(content, dagRunId, nodeId, uiState.specEvidenceListEvidence);
+		return;
+	}
+
+	const wrapper = el("div", "spec-evidence-detail");
+	const back = document.createElement("button");
+	back.type = "button";
+	back.className = "spec-evidence-back";
+	back.setAttribute("aria-label", "返回规范证据");
+	const backIcon = el("i", "ri-arrow-left-line");
+	backIcon.setAttribute("aria-hidden", "true");
+	back.append(backIcon, document.createTextNode(" 返回规范证据"));
+	back.addEventListener("click", () => {
+		const closed = closeSpecEvidenceDetail();
+		clearNode(content);
+		// Restore the list synchronously from the cached evidence so the user
+		// sees no flicker and the trigger button is immediately focusable.
+		renderSpecEvidence(content, dagRunId, nodeId, uiState.specEvidenceListEvidence);
+		if (closed?.triggerId) {
+			const trigger = document.getElementById(closed.triggerId);
+			trigger?.focus();
+		}
+	});
+	wrapper.appendChild(back);
+
+	const meta = el("div", "spec-evidence-detail-meta");
+	meta.appendChild(el("code", null, detail.path));
+	if (detail.source === "binding" && detail.data) {
+		meta.appendChild(
+			el(
+				"span",
+				"spec-evidence-detail-hash",
+				`绑定 sha256 ${String(detail.data.sha256 ?? "").slice(0, 12)}… · 当前 ${detail.data.hashMatch ? "一致" : "不一致"}`,
+			),
+		);
+	} else if (detail.source === "read" && detail.data?.readAt) {
+		meta.appendChild(
+			el(
+				"span",
+				"spec-evidence-detail-time",
+				`读取于 ${formatSessionEventTime({ timestamp: detail.data.readAt })}`,
+			),
+		);
+	}
+	wrapper.appendChild(meta);
+
+	if (detail.loading) {
+		const loading = el("p", "muted", "正在加载文件内容…");
+		loading.setAttribute("role", "status");
+		loading.setAttribute("aria-live", "polite");
+		wrapper.appendChild(loading);
+	} else if (detail.error) {
+		const error = el("p", "spec-evidence-detail-error", `加载失败：${detail.error}`);
+		error.setAttribute("role", "alert");
+		wrapper.appendChild(error);
+	} else if (detail.data) {
+		const body = el("pre", "spec-evidence-detail-content");
+		body.textContent = detail.data.content ?? "";
+		wrapper.appendChild(body);
+		if (detail.data.truncated) {
+			const note = el(
+				"p",
+				"spec-evidence-detail-truncated",
+				`已截断，仅显示前 ${detail.data.maxBytes ?? 0} 字节。`,
+			);
+			wrapper.appendChild(note);
+		}
+	}
+	content.appendChild(wrapper);
+}
+
 	function fillDagInspectorContent(content, dagRunId, node) {
+		const previousRenderedNode = content.dataset.dagNodeId ?? "";
+		const nodeChanged = previousRenderedNode !== String(node.nodeId ?? "");
+		if (nodeChanged) {
+			// Drop any open spec-evidence preview + cached list so a stale A detail
+			// cannot survive into node B (AC-007 regression guard).
+			uiState.specEvidenceDetail = null;
+			uiState.specEvidenceListEvidence = null;
+		}
 		const activeTab = ["timeline", "spec-evidence"].includes(
 			uiState.dagInspectorTab,
 		)

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

@@ -12,6 +12,7 @@ import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
 import { applySddEmbeddedEnhancements, probeRepoLocalSddSkills, } from "./sdd-embedded.js";
+import { discoverProjectGovernancePresence } from "./project-governance-context.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
@@ -1105,6 +1106,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         executorModelMatrix: resolveExecutorModelMatrices(manifest),
         verifyCommands,
         sddEmbeddedSkills: await probeRepoLocalSddSkills(repoRoot),
+        projectGovernancePresent: await discoverProjectGovernancePresence(repoRoot),
     };
     return sources;
 }
@@ -4663,11 +4665,35 @@ function buildHybridDagForTemplate(sources, template) {
         else
             spec = buildSupervisedHybridDag(standard, sources);
     }
+    applyProjectGovernanceReview(spec, template, sources);
     spec.sourceBinding = buildDagSourceBinding(sources);
+    assertNoGovernanceFlagOnDisallowedTemplate(spec, template);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
 }
+const GOVERNANCE_DISALLOWED_TEMPLATES = new Set([
+    "frontend-implementation",
+    "frontend-test-dag",
+    "backend-test-dag",
+    "knowledge-sync-dag",
+    "knowledge-graph-bootstrap-dag",
+]);
+/**
+ * Generate-time guard (constraint 2 / AC-007): the governance standard review
+ * flag must never appear on knowledge-sync, knowledge-graph-bootstrap,
+ * backend-test, or frontend tasks. Only standard verify-pi and the shared
+ * review-pi (reviewed/supervised) opt in explicitly.
+ */
+function assertNoGovernanceFlagOnDisallowedTemplate(spec, template) {
+    if (!GOVERNANCE_DISALLOWED_TEMPLATES.has(template))
+        return;
+    for (const task of spec.tasks) {
+        if (task.governanceStandardReview) {
+            throw new Error(`governanceStandardReview must not be set on ${template} task ${task.id}`);
+        }
+    }
+}
 export function buildHybridDagFromTask(sources, options = {}) {
     const selection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
@@ -4791,6 +4817,84 @@ function buildReviewGateNode(sources) {
         },
     };
 }
+function enableProjectGovernanceOnNode(task) {
+    task.governanceStandardReview = true;
+}
+/**
+ * Apply governance only to general implementation DAGs, and only when the
+ * target repository actually contains AGENTS.md. Standard reuses verify-pi;
+ * reviewed/supervised reuse review-pi and their existing review verdict gate.
+ */
+function applyProjectGovernanceReview(spec, template, sources) {
+    if (!sources.projectGovernancePresent)
+        return;
+    if (template === "standard-dag") {
+        const verify = spec.tasks.find((task) => task.id === "verify-pi");
+        if (!verify)
+            return;
+        enableProjectGovernanceOnNode(verify);
+        insertGovernanceStandardGate(spec, sources);
+        return;
+    }
+    if (template === "review-gated-dag" || template === "supervised-implementation") {
+        const review = spec.tasks.find((task) => task.id === "review-pi");
+        if (review)
+            enableProjectGovernanceOnNode(review);
+    }
+}
+/**
+ * Deterministic governance standard gate for standard-dag closeout. It reuses
+ * the standard `verdictGate` preset (fromNodeId=verify-pi, accept
+ * ["VERDICT: pass"], first-verdict-line). When no applicable AGENTS.md/standard
+ * exists, projectGovernanceGate returns success without parsing a verdict.
+ * When an applicable mandatory standard is violated, verify-pi must emit
+ * VERDICT: request-revision and the gate blocks closeout. No new model node.
+ */
+function buildGovernanceStandardGateNode(sources) {
+    return {
+        id: "governance-standard-gate-shell",
+        depends_on: ["verify-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic governance verdict gate: exit 0 only when verify-pi first VERDICT line is pass (covers applicable mandatory standard compliance). No file writes.",
+        subtask_prompt: "Deterministic gate: block closeout unless verify-pi emitted VERDICT: pass, which requires no unresolved applicable mandatory governance-standard violation. Read-only: do not modify files.",
+        shell: {
+            commands: [],
+            projectGovernanceGate: {
+                contextPath: ".runtime/project-governance-context.json",
+            },
+            verdictGate: {
+                fromNodeId: "verify-pi",
+                accept: ["VERDICT: pass"],
+                label: "governance-standard",
+                lineMode: "first-verdict-line",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+/**
+ * Insert the governance-standard gate between verify-pi and closeout-pi in a
+ * standard DAG. Idempotent and no-op if verify-pi/closeout-pi are absent.
+ */
+function insertGovernanceStandardGate(spec, sources) {
+    const closeout = spec.tasks.find((task) => task.id === "closeout-pi");
+    const verify = spec.tasks.find((task) => task.id === "verify-pi");
+    if (!closeout || !verify)
+        return;
+    if (spec.tasks.some((task) => task.id === "governance-standard-gate-shell")) {
+        return;
+    }
+    const gate = buildGovernanceStandardGateNode(sources);
+    const closeoutIndex = spec.tasks.findIndex((task) => task.id === "closeout-pi");
+    spec.tasks.splice(closeoutIndex, 0, gate);
+    closeout.depends_on = ["governance-standard-gate-shell"];
+}
 function buildReviewGatedHybridDag(standard, sources) {
     const spec = {
         ...standard,

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

@@ -9,11 +9,12 @@ import { buildDagNodePromptEnvelope } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
 import { writeDagNodeJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+import { buildProjectGovernanceContext, readCompletedWriterChangeManifests, writeProjectGovernanceContext, } from "./project-governance-context.js";
 import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
 import { resolveDagSkillInstructions, skillInstructionMetadata, } from "./skill-instructions.js";
 import { parseRepairArtifactFromText, resolveRepairTaskForGate, validateRepairArtifactScope, } from "./repair-artifact.js";
 import { resolveModelForTask, } from "./types.js";
-export function buildNodePrompt(spec, task, upstream) {
+export function buildNodePrompt(spec, task, upstream, options) {
     const policy = resolveContextPolicy(spec);
     return buildDagNodePromptEnvelope({
         spec,
@@ -21,9 +22,10 @@ export function buildNodePrompt(spec, task, upstream) {
         upstream,
         resolvedSkills: policy.resolveSkills(spec, task),
         maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
+        projectGovernanceContext: options?.projectGovernanceContext,
     });
 }
-export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd) {
+export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd, options) {
     const policy = resolveContextPolicy(spec);
     const skillNames = policy.resolveSkills(spec, task);
     const budget = policy.resolveSkillInstructionBudget(task);
@@ -43,6 +45,7 @@ export async function buildNodePromptWithResolvedSkillInstructions(spec, task, u
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
             maxUpstreamChars: policy.resolveMaxUpstreamChars(task),
+            projectGovernanceContext: options?.projectGovernanceContext,
         }),
         resolvedSkills: skillInstructionMetadata(resolvedSkillInstructions),
     };
@@ -138,12 +141,12 @@ export async function executeDagNode(input) {
     const { nodeId, tasksById, state, spec, cwd, runDir, executeNode } = input;
     const task = tasksById.get(nodeId);
     const node = state.nodes[nodeId];
-    const failSkillSnapshot = async (error) => {
+    const failBeforePrompt = async (error, failureCategory) => {
         const failedAt = new Date().toISOString();
         node.startedAt ??= failedAt;
         node.status = "ERROR";
         node.stderr = error instanceof Error ? error.message : String(error);
-        node.failureCategory = "skill-snapshot-integrity";
+        node.failureCategory = failureCategory;
         node.finishedAt = failedAt;
         node.lastActivityAt = node.finishedAt;
         node.durationMs = Math.max(0, Date.now() - new Date(node.startedAt).getTime());
@@ -152,6 +155,29 @@ export async function executeDagNode(input) {
         await input.persistState();
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
     };
+    const failSkillSnapshot = (error) => failBeforePrompt(error, "skill-snapshot-integrity");
+    let projectGovernanceContext;
+    if (task.governanceStandardReview) {
+        try {
+            const changeManifest = await readCompletedWriterChangeManifests({
+                runDir,
+                spec,
+                state,
+            });
+            projectGovernanceContext = await buildProjectGovernanceContext({
+                runId: state.runId,
+                cwd,
+                changeManifest,
+                runDir,
+            });
+            state.projectGovernanceContextRef = await writeProjectGovernanceContext(runDir, projectGovernanceContext);
+            await input.persistState();
+        }
+        catch (error) {
+            await failBeforePrompt(error, "project-governance-integrity");
+            return;
+        }
+    }
     const isDynamicTask = Boolean(task.dynamicExpansion
         || task.dynamicReduction
         || task.dynamicCondition
@@ -169,6 +195,7 @@ export async function executeDagNode(input) {
                     task,
                     upstream: state.nodes,
                     snapshot: skillSnapshot,
+                    projectGovernanceContext,
                 });
             }
         }
@@ -237,7 +264,7 @@ export async function executeDagNode(input) {
         }
         else {
             ({ prompt, resolvedSkills } =
-                await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd));
+                await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd, { projectGovernanceContext }));
         }
     }
     catch (error) {