@tea-agent/loop-agent 0.4.0 → 0.6.0

package/dist/worker/runner/run-ready.js

@@ -2,10 +2,10 @@ import { createHash } from "node:crypto";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
-import { deriveFailureRoute } from "../pool/failure-routing.js";
+import { deriveFailureRoute, deriveFailureRouteFromError, } from "../pool/failure-routing.js";
 import { findRunByWorkerRunId, getTaskPoolRoot, readAllTaskPoolStates, recordTaskPoolRun, writeTaskPoolState, } from "../pool/run-store.js";
 import { runTaskSpec, } from "../run-task/run-task.js";
-import { formatDuration, noopProgressReporter } from "../progress-reporter.js";
+import { formatDuration, noopProgressReporter, } from "../progress-reporter.js";
 import { computeReadyQueue } from "../task-graph/ready-queue.js";
 import { taskGraphSpecSchema } from "../task-graph/task-graph-schema.js";
 import { taskSpecSchema } from "../task-spec/schema.js";
@@ -23,18 +23,43 @@ export async function runReadyTasks(options) {
     const total = limitedTaskIds.length;
     let index = 0;
     const batchStartedAt = Date.now();
+    emit(progress, {
+        type: "readyQueue.computed",
+        source: "worker",
+        label: `ready queue: ${total} task${total === 1 ? "" : "s"} ready`,
+        batchRunId,
+    });
     progress.batch(`batch ${batchRunId}: feature=${graph.feature_id}, ${total} task${total === 1 ? "" : "s"} ready → starting`);
+    emit(progress, {
+        type: "batch.started",
+        source: "worker",
+        label: `batch ${batchRunId}: feature=${graph.feature_id}, ${total} task${total === 1 ? "" : "s"} ready`,
+        batchRunId,
+        status: "running",
+    });
     for (const taskId of limitedTaskIds) {
         index += 1;
         const node = graph.nodes.find((candidate) => candidate.id === taskId);
         const taskSpecPath = path.join(options.featureDir, "tasks", node?.task ?? `${taskId}.yaml`);
         const taskSpec = await loadTaskSpec(taskSpecPath);
-        const workerRunId = options.workerRunIdForTask?.(taskId, taskSpec) ??
-            buildStableWorkerRunId(taskId, taskSpec, now);
+        const retryOfWorkerRunId = states[taskId]?.retryOfWorkerRunId;
+        const workerRunId = retryOfWorkerRunId
+            ? buildRetryWorkerRunId(taskId, retryOfWorkerRunId, now)
+            : options.workerRunIdForTask?.(taskId, taskSpec) ??
+                buildStableWorkerRunId(taskId, taskSpec, now);
         if (workerRunId) {
             const existing = await findRunByWorkerRunId(options.repoRoot, workerRunId);
             if (existing) {
                 progress.task(`task ${index}/${total} ${taskId}: reuse existing run ${workerRunId}`);
+                emit(progress, {
+                    type: "task.reused",
+                    source: "worker",
+                    label: `task ${taskId}: reuse existing run ${workerRunId}`,
+                    batchRunId,
+                    taskId,
+                    workerRunId,
+                    status: "reused",
+                });
                 tasks.push({
                     taskId,
                     workerRunId,
@@ -46,6 +71,15 @@ export async function runReadyTasks(options) {
         }
         const taskStartedAt = Date.now();
         progress.task(`task ${index}/${total} ${taskId} "${taskSpec.title}" (${workerRunId})`);
+        emit(progress, {
+            type: "task.started",
+            source: "worker",
+            label: `task ${index}/${total} ${taskId}`,
+            batchRunId,
+            taskId,
+            workerRunId,
+            status: "running",
+        });
         progress.step(`preflight → materialize → dag-run-task → validate → run-dag → report`);
         let result;
         try {
@@ -54,6 +88,16 @@ export async function runReadyTasks(options) {
                 status: "Running",
                 updatedAt: new Date().toISOString(),
                 workerRunId,
+                ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
+            });
+            emit(progress, {
+                type: "state.updated",
+                source: "worker",
+                label: `task pool state: ${taskId} → Running`,
+                batchRunId,
+                taskId,
+                workerRunId,
+                status: "running",
             });
             result = await runner({
                 repoRoot: options.repoRoot,
@@ -72,7 +116,18 @@ export async function runReadyTasks(options) {
         }
         catch (error) {
             const message = errorMessage(error);
+            const failure = deriveFailureRouteFromError(message, taskId);
             progress.note(`task ${taskId}: ERROR ${message}`);
+            emit(progress, {
+                type: "task.finished",
+                source: "worker",
+                label: `task ${taskId} run-error`,
+                batchRunId,
+                taskId,
+                workerRunId,
+                status: "failed",
+                message,
+            });
             try {
                 await recordTaskPoolRun({
                     repoRoot: options.repoRoot,
@@ -85,6 +140,8 @@ export async function runReadyTasks(options) {
                         status: "run-error",
                         recordedAt: new Date().toISOString(),
                         error: message,
+                        failure,
+                        ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
                     },
                 });
             }
@@ -106,6 +163,29 @@ export async function runReadyTasks(options) {
             continue;
         }
         const failure = deriveFailureRoute(result);
+        emit(progress, {
+            type: "task.finished",
+            source: "worker",
+            label: `task ${taskId} ${result.status}`,
+            batchRunId,
+            taskId,
+            workerRunId: result.workerRunId,
+            status: result.status,
+            durationMs: Date.now() - taskStartedAt,
+        });
+        if (failure) {
+            emit(progress, {
+                type: "failure.routed",
+                source: "worker",
+                label: `failure routed: ${failure.category}`,
+                batchRunId,
+                taskId,
+                workerRunId: result.workerRunId,
+                failureCategory: failure.category,
+                recommendedFollowUp: failure.recommendedFollowUpKind,
+                status: "failed",
+            });
+        }
         if (result.status === "succeeded") {
             progress.step(`✓ ${taskId} succeeded in ${formatDuration(Date.now() - taskStartedAt)} (promoted + closed out)`);
         }
@@ -124,6 +204,7 @@ export async function runReadyTasks(options) {
             dagPath: result.dagPath,
             recordedAt: new Date().toISOString(),
             ...(failure ? { failure } : {}),
+            ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
             ...(result.failureArtifacts ? { failureArtifacts: result.failureArtifacts } : {}),
         };
         try {
@@ -160,8 +241,22 @@ export async function runReadyTasks(options) {
     await mkdir(path.dirname(batchRunPath), { recursive: true });
     await writeFile(batchRunPath, `${JSON.stringify(output, null, 2)}\n`, "utf-8");
     progress.batch(`batch ${batchRunId} ${output.status}: ${summary.succeeded} succeeded, ${summary.failed} failed, ${summary.reused} reused in ${formatDuration(Date.now() - batchStartedAt)} → ${batchRunPath}`);
+    emit(progress, {
+        type: "batch.finished",
+        source: "worker",
+        label: `batch ${batchRunId} ${output.status}`,
+        batchRunId,
+        status: output.status === "completed" ? "succeeded" : "failed",
+        durationMs: Date.now() - batchStartedAt,
+    });
     return output;
 }
+function emit(progress, input) {
+    const structured = progress;
+    if (typeof structured.event !== "function")
+        return;
+    void structured.event(input).catch(() => { });
+}
 export function buildBatchRunId(now) {
     return `batch-${now.toISOString().replace(/[-:.]/g, "").slice(0, 15)}`;
 }
@@ -177,6 +272,19 @@ export function buildStableWorkerRunId(taskId, taskSpec, now) {
         .slice(0, 10);
     return `wr-${date}-${slug}-${hash}`;
 }
+/** A retry is a distinct execution attempt and must not collide with failed evidence. */
+export function buildRetryWorkerRunId(taskId, previousWorkerRunId, now) {
+    const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+    const slug = taskId
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    const hash = createHash("sha256")
+        .update(`${previousWorkerRunId}:${now.toISOString()}`)
+        .digest("hex")
+        .slice(0, 10);
+    return `wr-${date}-${slug}-retry-${hash}`;
+}
 async function loadTaskGraph(featureDir) {
     const graphPath = path.join(featureDir, "tasks", "task-graph.yaml");
     return taskGraphSpecSchema.parse(YAML.parse(await readFile(graphPath, "utf-8")));

package/dist/workflows/dag/event-observer.js

@@ -0,0 +1,132 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
+import { resolveModelForTask, } from "./types.js";
+const DEFAULT_MAX_OUTPUT_PREVIEW_BYTES = 4096;
+/**
+ * Truncate `text` to fit within `maxBytes` (UTF-8), appending a marker suffix
+ * describing the number of elided bytes. Local implementation to avoid importing
+ * worker observability (which would create a circular dependency).
+ */
+export function truncateEventPreview(text, maxBytes = DEFAULT_MAX_OUTPUT_PREVIEW_BYTES) {
+    return truncateUtf8Preview(text, maxBytes);
+}
+function reportError(context, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[dag-event-observer] ${context} failed: ${message}\n`);
+}
+function findTask(spec, state, nodeId) {
+    const node = state.nodes[nodeId];
+    const task = spec?.tasks.find((candidate) => candidate.id === nodeId);
+    return { task, node };
+}
+function rankOf(state, nodeId) {
+    for (let i = 0; i < state.ranks.length; i += 1) {
+        if (state.ranks[i]?.includes(nodeId))
+            return String(i);
+    }
+    return undefined;
+}
+export function createDagEventObserver(options) {
+    const { eventsJsonlPath } = options;
+    const maxOutputPreviewBytes = options.maxOutputPreviewBytes ?? DEFAULT_MAX_OUTPUT_PREVIEW_BYTES;
+    let writeError = null;
+    const append = async (event) => {
+        try {
+            await mkdir(path.dirname(eventsJsonlPath), { recursive: true });
+            const line = `${JSON.stringify(event)}\n`;
+            await appendFile(eventsJsonlPath, line, "utf8");
+        }
+        catch (error) {
+            writeError = error;
+            reportError(`append ${event.type}`, error);
+        }
+    };
+    const buildBase = (type, state) => ({
+        schemaVersion: 1,
+        id: randomUUID(),
+        at: new Date().toISOString(),
+        dagRunId: state.runId || options.dagRunId || "dag",
+    });
+    const observer = {
+        onRunStart: async (state) => {
+            const event = {
+                ...buildBase("dag.run.started", state),
+                type: "dag.run.started",
+                status: state.status,
+                label: state.title,
+            };
+            await append(event);
+        },
+        onNodeStart: async (nodeId, state) => {
+            const { task, node } = findTask(options.spec, state, nodeId);
+            const event = {
+                ...buildBase("dag.node.started", state),
+                type: "dag.node.started",
+                nodeId,
+                status: node?.status,
+                rank: rankOf(state, nodeId),
+                executor: node?.executor,
+                model: task
+                    ? resolveModelForTask(task, options.spec?.executorModels)
+                    : undefined,
+                label: node?.id,
+            };
+            await append(event);
+        },
+        onNodeOutput: async (nodeId, chunk, state) => {
+            const { task, node } = findTask(options.spec, state, nodeId);
+            const event = {
+                ...buildBase("dag.node.output", state),
+                type: "dag.node.output",
+                nodeId,
+                status: node?.status,
+                rank: rankOf(state, nodeId),
+                executor: node?.executor,
+                model: task
+                    ? resolveModelForTask(task, options.spec?.executorModels)
+                    : undefined,
+                label: node?.id,
+                outputPreview: truncateEventPreview(redactSecrets(chunk), maxOutputPreviewBytes),
+            };
+            await append(event);
+        },
+        onNodeFinish: async (nodeId, state) => {
+            const { task, node } = findTask(options.spec, state, nodeId);
+            const event = {
+                ...buildBase("dag.node.finished", state),
+                type: "dag.node.finished",
+                nodeId,
+                status: node?.status,
+                rank: rankOf(state, nodeId),
+                executor: node?.executor,
+                model: task
+                    ? resolveModelForTask(task, options.spec?.executorModels)
+                    : undefined,
+                label: node?.id,
+                durationMs: node?.durationMs,
+            };
+            await append(event);
+        },
+        onRunFinish: async (state) => {
+            const event = {
+                ...buildBase("dag.run.finished", state),
+                type: "dag.run.finished",
+                status: state.status,
+                label: state.title,
+            };
+            await append(event);
+        },
+    };
+    return {
+        observer,
+        flush: async () => {
+            // No buffering: append is immediate. Surface the last write error
+            // (best-effort) only if the caller asks, but never throw.
+            if (writeError) {
+                reportError("flush", writeError);
+            }
+        },
+    };
+}

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

@@ -1,18 +1,22 @@
-import { access, readFile, writeFile } from "node:fs/promises";
+import { access, readdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { assertValidDagSpec } from "./validate.js";
-import { parseDagSpec, } from "./types.js";
+import { DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
+import { materializeTaskReferenceDocs } from "../../task/source-references.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
+import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
+const REFERENCE_DIRECTORY = "references";
 const MAX_SOURCE_EXCERPT_CHARS = 2000;
+const MAX_SOURCE_REFERENCE_DOCUMENTS = 8;
 const HYBRID_DEFAULTS = {
     executor: "pi",
     piBackend: "sdk-first",
@@ -100,27 +104,85 @@ function mapTaskComplexity(complexity) {
         return "HIGH";
     return "MED";
 }
-function excerptMarkdown(content, maxChars = MAX_SOURCE_EXCERPT_CHARS) {
+export function excerptMarkdown(content, options = {}) {
+    const maxChars = options.maxChars ?? MAX_SOURCE_EXCERPT_CHARS;
     const trimmed = content.trim();
-    if (trimmed.length <= maxChars)
-        return trimmed;
-    return `${trimmed.slice(0, maxChars)}\n\n...[truncated for draft prompt]`;
+    if (trimmed.length <= maxChars) {
+        return {
+            text: trimmed,
+            truncated: false,
+            originalChars: trimmed.length,
+            maxChars,
+        };
+    }
+    const omitted = trimmed.length - maxChars;
+    const ref = options.sourceRef?.trim();
+    const pointer = ref
+        ? [
+            `...[truncated for draft prompt: showing first ${maxChars} of ${trimmed.length} chars; omitted ${omitted} chars]`,
+            `Full source (authoritative, do not invent missing content): ${ref}`,
+            "When the omitted tail may affect acceptance/non-goals/constraints, re-read that file before deciding.",
+        ].join("\n")
+        : `...[truncated for draft prompt: showing first ${maxChars} of ${trimmed.length} chars; omitted ${omitted} chars]`;
+    return {
+        text: `${trimmed.slice(0, maxChars)}\n\n${pointer}`,
+        truncated: true,
+        originalChars: trimmed.length,
+        maxChars,
+    };
+}
+function isHeadingLine(line) {
+    return /^#{1,6}\s+/.test(line.trim());
 }
-function extractObjective(requirementMarkdown, title) {
+function isMetadataLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return true;
+    if (/^(TaskSpec business id|Feature id|Task type|Risk level)\s*:/i.test(trimmed)) {
+        return true;
+    }
+    if (/^(权威来源|SHA-256|冲突时以)/.test(trimmed))
+        return true;
+    if (/^>/.test(trimmed) && /(权威来源|SHA-256|原始 PRD|reference)/i.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+export function extractObjective(requirementMarkdown, title) {
+    const sectionMatchers = [
+        /##\s*(目标|Objective|Goals?)\s*\n([\s\S]*?)(?=\n##\s|\n#\s|$)/i,
+        /##\s*Description\s*\n([\s\S]*?)(?=\n##\s|\n#\s|$)/i,
+    ];
+    for (const matcher of sectionMatchers) {
+        const match = requirementMarkdown.match(matcher);
+        if (!match)
+            continue;
+        const body = (match[2] ?? match[1] ?? "").trim();
+        for (const line of body.split("\n")) {
+            const trimmed = line
+                .replace(/^[-*]\s*\[[ xX]\]\s*/, "")
+                .replace(/^[-*]\s*/, "")
+                .trim();
+            if (!trimmed || isHeadingLine(trimmed) || isMetadataLine(trimmed))
+                continue;
+            return trimmed.slice(0, 500);
+        }
+    }
     const lines = requirementMarkdown.split("\n");
     for (const line of lines) {
         const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#"))
+        if (!trimmed || isHeadingLine(trimmed) || isMetadataLine(trimmed))
             continue;
         return trimmed.slice(0, 500);
     }
     return `Implement task: ${title}`;
 }
-function extractSuccessCriteria(requirementMarkdown, taskId) {
+const SUCCESS_CRITERIA_SECTION = /##\s*(验收标准|完成标准|Acceptance(?:\s+References)?|Success Criteria)\s*\n([\s\S]*?)(?=\n##\s|\n#\s|$)/i;
+export function extractSuccessCriteria(requirementMarkdown, taskId) {
     const criteria = [];
-    const sectionMatch = requirementMarkdown.match(/##\s*验收标准\s*\n([\s\S]*?)(?=\n##\s|\n#\s|$)/);
+    const sectionMatch = requirementMarkdown.match(SUCCESS_CRITERIA_SECTION);
     if (sectionMatch) {
-        for (const line of sectionMatch[1].split("\n")) {
+        for (const line of sectionMatch[2].split("\n")) {
             const trimmed = line.replace(/^[-*]\s*\[[ xX]\]\s*/, "").trim();
             if (trimmed.startsWith("-") || trimmed.startsWith("*")) {
                 criteria.push(trimmed.replace(/^[-*]\s*/, "").trim());
@@ -225,20 +287,77 @@ function deriveParallelScoutPaths(taskConfig) {
                 : allowed,
     };
 }
+function toTaskRelativeSourcePath(sources, absolutePath) {
+    return path
+        .relative(sources.taskDir, absolutePath)
+        .replaceAll(path.sep, "/");
+}
 function buildSourceContextBlock(sources) {
+    const requirementRef = toTaskRelativeSourcePath(sources, sources.requirementPath);
+    const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
+        sourceRef: requirementRef,
+    });
     const parts = [
         "## Task source: 需求.md",
-        excerptMarkdown(sources.requirementMarkdown),
+        requirementExcerpt.text,
     ];
     if (sources.constraintMarkdown) {
-        parts.push("## Task source: 执行约束.md", excerptMarkdown(sources.constraintMarkdown));
+        const constraintRef = toTaskRelativeSourcePath(sources, sources.constraintPath);
+        const constraintExcerpt = excerptMarkdown(sources.constraintMarkdown, {
+            sourceRef: constraintRef,
+        });
+        parts.push("## Task source: 执行约束.md", constraintExcerpt.text);
     }
-    parts.push("## Task config summary", `- taskId: ${sources.taskConfig.taskId}`, `- flow: ${sources.taskConfig.flow}`, `- complexity: ${sources.taskConfig.complexity}`, `- contextProfile: ${sources.taskConfig.contextProfile}`, `- allowedPaths: ${sources.taskConfig.allowedPaths.join(", ") || "(none — review before execute)"}`, `- forbiddenPaths: ${sources.taskConfig.forbiddenPaths.join(", ") || "(none)"}`, '- Pi DAG nodes are read-only unless toolProfile="write" is explicitly selected for a bounded writer node.', "- Agent DAG read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.");
+    for (const reference of sources.referenceDocuments ?? []) {
+        const relativePath = path
+            .relative(path.join(sources.taskDir, "source"), reference.path)
+            .replaceAll(path.sep, "/");
+        const referenceRef = toTaskRelativeSourcePath(sources, reference.path);
+        const referenceExcerpt = excerptMarkdown(reference.markdown, {
+            sourceRef: referenceRef,
+        });
+        parts.push(`## Task source reference: ${relativePath}`, referenceExcerpt.text);
+    }
+    parts.push("## Task config summary", `- taskId: ${sources.taskConfig.taskId}`, `- flow: ${sources.taskConfig.flow}`, `- complexity: ${sources.taskConfig.complexity}`, `- contextProfile: ${sources.taskConfig.contextProfile}`, `- allowedPaths: ${sources.taskConfig.allowedPaths.join(", ") || "(none — review before execute)"}`, `- forbiddenPaths: ${sources.taskConfig.forbiddenPaths.join(", ") || "(none)"}`, '- Pi DAG nodes are read-only unless toolProfile="write" is explicitly selected for a bounded writer node.', "- Agent DAG read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.", "- source/references/* are immutable user/source facts; source/需求.md is the derived execution contract.");
     if (sources.taskConfig.hardConstraints.length > 0) {
         parts.push("- hardConstraints:", ...sources.taskConfig.hardConstraints.map((c) => `  - ${c}`));
     }
     return parts.join("\n\n");
 }
+async function loadMaterializedSourceReferences(sourceDir) {
+    const referenceDir = path.join(sourceDir, REFERENCE_DIRECTORY);
+    const referencePaths = [];
+    async function collect(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await collect(entryPath);
+            }
+            else if (entry.isFile()) {
+                // Skip index/manifest sidecars; keep only user/source reference content.
+                if (entry.name === "index.json" || entry.name === "source-manifest.json") {
+                    continue;
+                }
+                referencePaths.push(entryPath);
+            }
+        }
+    }
+    await collect(referenceDir);
+    referencePaths.sort((left, right) => left.localeCompare(right));
+    return Promise.all(referencePaths.slice(0, MAX_SOURCE_REFERENCE_DOCUMENTS).map(async (filePath) => ({
+        path: filePath,
+        markdown: await readFile(filePath, "utf-8"),
+    })));
+}
 export async function loadTaskHybridSources(repoRoot, taskId) {
     const paths = getTaskPaths(repoRoot, taskId);
     const requirementPath = path.join(paths.sourceDir, REQUIREMENT_FILE);
@@ -264,6 +383,12 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         // optional
     }
     const taskConfig = await loadTaskConfig(repoRoot, taskId);
+    await materializeTaskReferenceDocs({
+        repoRoot,
+        taskId,
+        taskConfig,
+    });
+    const referenceDocuments = await loadMaterializedSourceReferences(paths.sourceDir);
     const manifest = await loadHarnessManifest(repoRoot);
     const strategy = resolveDagVerifyStrategy(taskConfig);
     let verifyCommands;
@@ -299,8 +424,10 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         constraintPath,
         requirementMarkdown,
         constraintMarkdown,
+        referenceDocuments,
         taskConfig,
         enabledExecutors: resolveEnabledExecutors(manifest.executors),
+        executorModelMatrix: resolveExecutorModelMatrices(manifest),
         verifyCommands,
     };
 }
@@ -336,18 +463,7 @@ export function buildStandardHybridDagFromTask(sources) {
             contextProfile: taskConfig.contextProfile,
         },
         skillsByRole: HYBRID_SKILLS_BY_ROLE,
-        executorModels: {
-            cursor: {
-                LOW: "composer-2.5",
-                MED: "composer-2.5",
-                HIGH: "composer-2.5",
-            },
-            pi: {
-                LOW: "gpt-5.3-codex-spark",
-                MED: "glm-5.2",
-                HIGH: "gpt-5.5",
-            },
-        },
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
         tasks: [
             {
                 id: "contract-pi",
@@ -518,6 +634,14 @@ function buildReviewNode(sources) {
             "Review upstream implementation and verification evidence.",
             "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
             "List Critical/Important findings when present; any Critical/Important finding must force request-revision. Read-only: do not modify files.",
+            [
+                "Three-way source fidelity check (required):",
+                "1) immutable originals under source/references/ (especially requirement* and acceptance*);",
+                "2) derived source/需求.md execution contract (and source/执行约束.md);",
+                "3) actual implementation/diff + verification evidence.",
+                "If 需求.md conflicts with source/references/*, prefer references and request-revision when the implementation only satisfies the derived summary.",
+                "If prompt excerpts are truncated, re-read the Full source paths before verdict.",
+            ].join(" "),
             buildSourceContextBlock(sources),
         ].join("\n\n"),
     };

package/dist/workflows/dag/observer-compose.js

@@ -0,0 +1,52 @@
+function reportError(context, observerIndex, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[dag-observer-compose] observer#${observerIndex} ${context} failed: ${message}\n`);
+}
+const HOOK_NAMES = [
+    "onRunStart",
+    "onNodeStart",
+    "onNodeOutput",
+    "onNodeFinish",
+    "onRunFinish",
+];
+/**
+ * Compose multiple `DagRunObserver`s into one. Each hook is invoked in order.
+ * A throw in a single observer's hook is reported to stderr and does not stop
+ * subsequent observers — observers are derived views and must not affect
+ * canonical DAG execution. Returns `undefined` when no observers are provided.
+ */
+export function composeDagRunObservers(observers) {
+    const active = observers.filter((observer) => Boolean(observer));
+    if (active.length === 0)
+        return undefined;
+    const observer = {
+        onRunStart: async (state) => {
+            await runHook("onRunStart", active, (obs) => obs.onRunStart?.(state));
+        },
+        onNodeStart: async (nodeId, state) => {
+            await runHook("onNodeStart", active, (obs) => obs.onNodeStart?.(nodeId, state));
+        },
+        onNodeOutput: async (nodeId, chunk, state) => {
+            await runHook("onNodeOutput", active, (obs) => obs.onNodeOutput?.(nodeId, chunk, state));
+        },
+        onNodeFinish: async (nodeId, state) => {
+            await runHook("onNodeFinish", active, (obs) => obs.onNodeFinish?.(nodeId, state));
+        },
+        onRunFinish: async (state) => {
+            await runHook("onRunFinish", active, (obs) => obs.onRunFinish?.(state));
+        },
+    };
+    return observer;
+}
+async function runHook(hookName, active, invoke) {
+    for (let i = 0; i < active.length; i += 1) {
+        try {
+            await invoke(active[i]);
+        }
+        catch (error) {
+            reportError(hookName, i, error);
+        }
+    }
+}
+// Re-exported for tests/inspection of hook coverage.
+export const COMPOSED_HOOK_NAMES = HOOK_NAMES;

package/dist/workflows/dag/skill-instructions.js

@@ -42,6 +42,10 @@ function buildSkillCandidatePaths(input) {
     const piSkillsDir = path.join(input.homeDir, ".pi", "agent", "skills");
     candidates.push(normalizeCandidate(path.join(piSkillsDir, input.name, "SKILL.md")), normalizeCandidate(path.join(piSkillsDir, `${input.name}.md`)));
     candidates.push(normalizeCandidate(path.join(input.cwd, "skills", input.name, "SKILL.md")));
+    // Agent-compatible project path (e.g. OpenCode). `skills/` stays the primary
+    // loop-agent repo-local path; `.agents/skills` is searched after it and before
+    // bundled skills so a project with only the mirror can still resolve.
+    candidates.push(normalizeCandidate(path.join(input.cwd, ".agents", "skills", input.name, "SKILL.md")));
     if (input.name === "loop-agent") {
         candidates.push(normalizeCandidate(path.join(input.cwd, "skill", "SKILL.md")));
     }

package/dist/workflows/dag/types.js

@@ -251,7 +251,7 @@ export const DEFAULT_DAG_EXECUTOR_MODELS = {
     cursor: {
         LOW: "composer-2.5",
         MED: "composer-2.5",
-        HIGH: "composer-2.5",
+        HIGH: "gpt-5.5",
     },
     pi: {
         LOW: "gpt-5.3-codex-spark",