@tea-agent/loop-agent 0.8.0 → 0.10.0

package/dist/worker/pool/run-store.js

@@ -1,4 +1,5 @@
-import { appendFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 export const TASK_POOL_RELATIVE_ROOT = ".harness/task-pool";
 export function getTaskPoolRoot(repoRoot) {
@@ -19,6 +20,10 @@ export async function recordTaskPoolRun(input) {
     await writeTaskPoolState(input.repoRoot, stateFromRun(input.run));
     await appendJsonlFile(getEventsJsonlPath(input.repoRoot), eventFromRun(input.run));
 }
+export async function appendTaskPoolEvent(repoRoot, event) {
+    await ensurePoolDirs(repoRoot);
+    await appendJsonlFile(getEventsJsonlPath(repoRoot), event);
+}
 export async function findRunByWorkerRunId(repoRoot, workerRunId) {
     const runs = await readJsonlFile(getRunsJsonlPath(repoRoot));
     return runs.find((run) => run.workerRunId === workerRunId);
@@ -99,7 +104,14 @@ export async function readAllTaskPoolStates(repoRoot) {
 export async function writeTaskPoolState(repoRoot, state) {
     const statePath = getTaskStatePath(repoRoot, state.taskId);
     await mkdir(path.dirname(statePath), { recursive: true });
-    await writeFile(statePath, `${JSON.stringify({ schemaVersion: 1, ...state }, null, 2)}\n`, "utf-8");
+    const tempPath = path.join(path.dirname(statePath), `.${path.basename(statePath)}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(tempPath, `${JSON.stringify({ schemaVersion: 1, ...state }, null, 2)}\n`, "utf-8");
+        await rename(tempPath, statePath);
+    }
+    finally {
+        await unlink(tempPath).catch(() => { });
+    }
 }
 export async function readJsonlFile(filePath) {
     try {

package/dist/worker/pool/validation.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { getRunsJsonlPath, getTaskPoolRoot } from "./run-store.js";
+export const taskPoolRunFactSchema = z.object({
+    schemaVersion: z.literal(1), batchRunId: z.string().min(1), workerRunId: z.string().min(1), taskId: z.string().min(1), featureId: z.string().min(1),
+    status: z.enum(["succeeded", "failed", "run-error"]), recordedAt: z.string().datetime(),
+}).passthrough();
+export const taskPoolStateFactSchema = z.object({
+    taskId: z.string().min(1), status: z.enum(["Draft", "Ready", "Queued", "Running", "AgentCompleted", "VerificationRunning", "HumanReview", "Done", "Failed", "Blocked", "Abandoned"]), updatedAt: z.string().datetime(),
+}).passthrough();
+export async function readValidTaskPoolRuns(repoRoot) {
+    const records = [];
+    const warnings = [];
+    try {
+        const raw = await readFile(getRunsJsonlPath(repoRoot), "utf-8");
+        for (const [index, line] of raw.split(/\r?\n/).filter(Boolean).entries())
+            try {
+                const parsed = taskPoolRunFactSchema.safeParse(JSON.parse(line));
+                if (parsed.success)
+                    records.push(parsed.data);
+                else
+                    warnings.push(`Task Pool runs.jsonl line ${index + 1} is semantically invalid`);
+            }
+            catch {
+                warnings.push(`Task Pool runs.jsonl line ${index + 1} is corrupt`);
+            }
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            warnings.push("Task Pool runs.jsonl is unreadable");
+    }
+    return { records, warnings };
+}
+export async function readValidTaskPoolStates(repoRoot) {
+    const records = {};
+    const warnings = [];
+    const stateDir = path.join(getTaskPoolRoot(repoRoot), "states");
+    try {
+        for (const entry of await readdir(stateDir))
+            if (entry.endsWith(".json"))
+                try {
+                    const parsed = taskPoolStateFactSchema.safeParse(JSON.parse(await readFile(path.join(stateDir, entry), "utf-8")));
+                    if (parsed.success && parsed.data.taskId === entry.slice(0, -5))
+                        records[parsed.data.taskId] = parsed.data;
+                    else
+                        warnings.push(`Task Pool state is semantically invalid: ${entry}`);
+                }
+                catch {
+                    warnings.push(`Task Pool state is corrupt: ${entry}`);
+                }
+    }
+    catch (error) {
+        if (!isNotFound(error))
+            warnings.push("Task Pool states are unreadable");
+    }
+    return { records, warnings };
+}
+function isNotFound(error) { return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT"); }

package/dist/worker/report/morning-report.js

@@ -1,17 +1,30 @@
-import { access, writeFile, mkdir } from "node:fs/promises";
+import { access, writeFile, mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
-import { getRunsJsonlPath, readAllTaskPoolStates, readJsonlFile, } from "../pool/run-store.js";
+import YAML from "yaml";
+import { followUpActionCardSchema } from "../follow-up/schema.js";
+import { readFollowUpIndex, resolveRepoFile } from "../follow-up/store.js";
+import { loadFeatureDecisionModels } from "../feature/decision-loader.js";
+import { readValidTaskPoolRuns, readValidTaskPoolStates } from "../pool/validation.js";
 export async function renderMorningReport(options) {
-    const runs = (await readJsonlFile(getRunsJsonlPath(options.repoRoot))).filter((run) => !options.batchRunId || run.batchRunId === options.batchRunId);
+    const { features } = await loadFeatureDecisionModels(options.repoRoot);
+    const allRuns = (await readValidTaskPoolRuns(options.repoRoot)).records;
+    const runs = allRuns.filter((run) => !options.batchRunId || run.batchRunId === options.batchRunId);
     const total = runs.length;
     const succeeded = runs.filter((run) => run.status === "succeeded").length;
     const failed = runs.filter((run) => run.status === "failed").length;
     const followUps = runs.filter((run) => run.failure).length;
-    const states = await readAllTaskPoolStates(options.repoRoot);
+    const states = (await readValidTaskPoolStates(options.repoRoot)).records;
     const blocked = Object.values(states).filter((state) => state.status === "Blocked").length;
     const lines = [
         "# Nightly Worker Report",
         "",
+        "## Feature Decision Summary",
+        "",
+        ...(features.length === 0 ? ["- Status: no Feature Packet discovered", "- Next Action: add or locate a Feature Packet", "- Why: no shared Feature read model is available", "- Evidence: none"] : features.flatMap((feature) => {
+            const why = feature.blockingItems[0]?.message ?? `${feature.summary.tasksSucceeded}/${feature.summary.tasksTotal} tasks; ${feature.summary.requiredAcCovered}/${feature.summary.requiredAcTotal} required AC`;
+            const evidence = [feature.evidence.delivery, feature.evidence.closeout, feature.evidence.morningReport, feature.evidence.observeSnapshot, ...feature.blockingItems.flatMap((item) => item.evidence)].find(Boolean) ?? "none";
+            return [`### ${feature.featureId}`, "", `- Status: ${feature.status}`, `- Next Action: ${feature.nextAction?.command ?? feature.nextAction?.label ?? "none"}`, `- Why: ${why}`, `- Evidence: ${evidence}`, ""];
+        })),
         "## Summary",
         "",
         `- Total: ${total}`,
@@ -26,16 +39,38 @@ export async function renderMorningReport(options) {
         "|---|---|---|---|---|---|",
     ];
     for (const run of runs) {
-        lines.push(`| ${run.taskId} | ${run.status} | ${run.workerRunId} | ${run.failure?.category ?? "-"} | ${run.failure?.derivedFollowUpTaskId ?? "-"} | ${await artifactSummary(run)} |`);
+        const followUp = await followUpSummary(run, options.repoRoot);
+        lines.push(`| ${run.taskId} | ${run.status} | ${run.workerRunId} | ${run.failure?.category ?? "-"} | ${followUp ?? run.failure?.derivedFollowUpTaskId ?? "-"} | ${await artifactSummary(run)} |`);
     }
     if (followUps > 0) {
         lines.push("", "## Human Actions", "");
         for (const run of runs.filter((candidate) => candidate.failure)) {
-            lines.push(`- ${run.failure?.derivedFollowUpTaskId}: ${run.failure?.recommendedFollowUpKind} for ${run.taskId}`);
+            const followUp = await followUpSummary(run, options.repoRoot);
+            lines.push(`- ${followUp ?? `${run.failure?.derivedFollowUpTaskId}: ${run.failure?.recommendedFollowUpKind} for ${run.taskId}`}`);
         }
     }
     return `${lines.join("\n")}\n`;
 }
+async function followUpSummary(run, repoRoot) {
+    if (!run.failure)
+        return undefined;
+    try {
+        const index = await readFollowUpIndex(repoRoot, run.featureId);
+        const entry = index.entries.find((candidate) => candidate.workerRunId === run.workerRunId && candidate.status !== "Superseded" && candidate.status !== "Rejected");
+        if (!entry)
+            return undefined;
+        if (entry.kind === "TaskDraft") {
+            return entry.status === "Approved"
+                ? `${entry.followUpId}: approved as ${entry.proposedTaskId}`
+                : `${entry.followUpId}: approve ${entry.proposedTaskId}`;
+        }
+        const card = followUpActionCardSchema.parse(YAML.parse(await readFile(await resolveRepoFile(repoRoot, entry.draftPath), "utf-8")));
+        return `${entry.followUpId}: ${card.command ?? card.label}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function writeMorningReport(input) {
     const markdown = await renderMorningReport(input);
     await mkdir(path.dirname(input.outputPath), { recursive: true });

package/dist/worker/run-task/run-task.js

@@ -156,7 +156,7 @@ export async function runTaskSpec(options) {
             taskArtifactsDir,
             eventCtx,
         });
-    if (reportDecision.succeeded) {
+    if (reportDecision.succeeded && !options.skipSuccessFinalization) {
         await runObservedStep(eventCtx, "promote-run", async () => {
             progress.step("promote run");
             await runRequiredCommand(options.repoRoot, client, "promote-run", ["promote-run", materializeManifest.harnessTaskId, "--run-id", workerRunId], true, undefined, eventCtx);

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

@@ -66,6 +66,7 @@ export async function runReadyTasks(options) {
                     status: "reused",
                     runRecordPath: existing.runRecordPath,
                 });
+                await options.onTaskFinalized?.({ status: "reused", taskSpec, workerRunId, ...(existing.runRecordPath ? { runRecordPath: existing.runRecordPath } : {}) });
                 continue;
             }
         }
@@ -106,10 +107,12 @@ export async function runReadyTasks(options) {
                 client: options.client,
                 now,
                 workerRunId,
-                preflight: {
-                    runCheckRepo: options.runCheckRepo,
-                    ...(options.checkRepoCommand ? { checkRepoCommand: options.checkRepoCommand } : {}),
-                },
+                preflight: options.skipTaskPreflight
+                    ? false
+                    : {
+                        runCheckRepo: options.runCheckRepo,
+                        ...(options.checkRepoCommand ? { checkRepoCommand: options.checkRepoCommand } : {}),
+                    },
                 progress,
                 ...(options.piModel ? { piModel: options.piModel } : {}),
             });
@@ -128,6 +131,7 @@ export async function runReadyTasks(options) {
                 status: "failed",
                 message,
             });
+            let recorded = false;
             try {
                 await recordTaskPoolRun({
                     repoRoot: options.repoRoot,
@@ -144,16 +148,20 @@ export async function runReadyTasks(options) {
                         ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
                     },
                 });
+                recorded = true;
             }
             catch (recordError) {
+                await options.onTaskFinalized?.({ status: "run-error", taskSpec, workerRunId });
                 tasks.push({
                     taskId,
                     workerRunId,
                     status: "record-error",
                     error: errorMessage(recordError),
                 });
-                continue;
+                break;
             }
+            if (recorded)
+                await options.onTaskFinalized?.({ status: "run-error", taskSpec, workerRunId });
             tasks.push({
                 taskId,
                 workerRunId,
@@ -207,8 +215,10 @@ export async function runReadyTasks(options) {
             ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
             ...(result.failureArtifacts ? { failureArtifacts: result.failureArtifacts } : {}),
         };
+        let recorded = false;
         try {
             await recordTaskPoolRun({ repoRoot: options.repoRoot, run });
+            recorded = true;
             tasks.push({
                 taskId,
                 workerRunId: result.workerRunId,
@@ -217,6 +227,7 @@ export async function runReadyTasks(options) {
             });
         }
         catch (error) {
+            await options.onTaskFinalized?.({ status: result.status, taskSpec, workerRunId: result.workerRunId, runRecordPath: result.runRecordPath });
             tasks.push({
                 taskId,
                 workerRunId: result.workerRunId,
@@ -224,7 +235,10 @@ export async function runReadyTasks(options) {
                 error: errorMessage(error),
                 runRecordPath: result.runRecordPath,
             });
+            break;
         }
+        if (recorded)
+            await options.onTaskFinalized?.({ status: result.status, taskSpec, workerRunId: result.workerRunId, runRecordPath: result.runRecordPath });
     }
     const summary = summarize(tasks);
     const batchRunPath = path.join(getTaskPoolRoot(options.repoRoot), "artifacts", batchRunId, "batch-run.json");

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

@@ -2,7 +2,7 @@ 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 { DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
+import { DEFAULT_DAG_OUTPUT_LANGUAGE, 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";
@@ -448,6 +448,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         constraintPath,
         requirementMarkdown,
         constraintMarkdown,
+        outputLanguage: manifest.workflowPolicy.dag.outputLanguage,
         referenceDocuments,
         taskConfig,
         enabledExecutors: resolveEnabledExecutors(manifest.executors),
@@ -524,6 +525,7 @@ export function buildStandardHybridDagFromTask(sources) {
     const spec = {
         version: 2,
         title: `Hybrid DAG: ${taskConfig.title}`,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
         objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
         successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
         globalConstraints,

package/dist/workflows/dag/lifecycle.js

@@ -1,5 +1,6 @@
 import { access, mkdir, readFile, readdir, rename, } from "node:fs/promises";
 import path from "node:path";
+import { hostname as localHostname } from "node:os";
 import { writeJsonAtomic, } from "../../infrastructure/harness/atomic-write.js";
 import { parseDagSpec } from "./types.js";
 import { normalizeDagFailureCategory, } from "./failure-category.js";
@@ -161,10 +162,98 @@ export async function humanApprovalArtifactExists(runDir, nodeId) {
         return false;
     }
 }
+export function assessDagRunLiveness(input) {
+    if (input.state.status !== "running")
+        return { status: "unknown" };
+    const runner = input.state.runner;
+    if (!runner)
+        return { status: "unknown" };
+    if (runner.hostname !== (input.hostname ?? localHostname()))
+        return { status: "unknown-host" };
+    const isAlive = input.isProcessAlive ?? ((pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!isAlive(runner.pid))
+        return { status: "orphaned", runnerAlive: false };
+    const heartbeatMs = Date.parse(runner.heartbeatAt);
+    const nowMs = (input.now ?? new Date()).getTime();
+    if (!Number.isNaN(heartbeatMs) && nowMs - heartbeatMs > (input.staleThresholdMs ?? 90_000)) {
+        return { status: "stale", runnerAlive: true };
+    }
+    const activeNode = Object.values(input.state.nodes).find((node) => node.status === "RUNNING");
+    const nodeActivityMs = Date.parse(activeNode?.lastActivityAt ?? activeNode?.startedAt ?? "");
+    if (!Number.isNaN(nodeActivityMs) && nowMs - nodeActivityMs > (input.nodeQuietThresholdMs ?? 300_000)) {
+        return { status: "node-quiet", runnerAlive: true };
+    }
+    return { status: "active", runnerAlive: true };
+}
+export function deriveDagRunEffectiveStatus(input) {
+    if (input.state.status === "superseded")
+        return "superseded";
+    if (input.state.status === "abandoned")
+        return "abandoned";
+    if (input.lifecycle === "paused")
+        return "paused";
+    if (input.lifecycle === "completed") {
+        return input.state.status === "finished" ? "finished" : "failed";
+    }
+    if (input.state.status === "pending")
+        return "pending";
+    if (isTerminalDagRunStatus(input.state.status)) {
+        return input.state.status === "finished" ? "finished" : "failed";
+    }
+    if (input.liveness === "orphaned" || input.liveness === "stale")
+        return "interrupted";
+    if (input.liveness === "node-quiet")
+        return "running-quiet";
+    if (input.liveness === "unknown-host")
+        return "remote-unknown";
+    if (input.liveness === "active")
+        return "running";
+    return "unknown";
+}
+export function assessDagRunRecoveryEligibility(input) {
+    const reasons = [];
+    const canResume = input.lifecycle === "active"
+        && input.state.status === "running"
+        && Boolean(input.state.humanDecisionNodeId)
+        && Boolean(input.hasHumanApproval);
+    if (!canResume)
+        reasons.push("standard-resume-preconditions-not-met");
+    let canReconcile = true;
+    if (input.lifecycle === "completed" || isTerminalDagRunStatus(input.state.status)) {
+        canReconcile = false;
+        reasons.push("run-already-terminal");
+    }
+    if (input.lifecycle === "active"
+        && ["active", "node-quiet", "stale", "unknown-host", "unknown"].includes(input.liveness)) {
+        canReconcile = false;
+        reasons.push("runner-not-proven-dead-or-stopped");
+    }
+    if (input.lifecycle === "paused" && input.state.status !== "paused") {
+        reasons.push("lifecycle-status-mismatch");
+    }
+    if (!input.state.runner)
+        reasons.push("missing-runner-metadata");
+    return {
+        canResume,
+        canReconcile,
+        allowedActions: canReconcile ? ["supersede", "abandon"] : [],
+        reasons: [...new Set(reasons)],
+    };
+}
 export const TERMINAL_RUN_STATUSES = new Set([
     "finished",
     "failed",
     "partial_failed",
+    "superseded",
+    "abandoned",
 ]);
 export function isTerminalDagRunStatus(status) {
     return TERMINAL_RUN_STATUSES.has(status);
@@ -248,6 +337,31 @@ export async function detectDagRunHealthIssues(input) {
             advisoryAction: "Use dag doctor; approve/reject/resume may fail until lifecycle facts are consistent.",
         });
     }
+    const liveness = assessDagRunLiveness({ state });
+    if (liveness.status === "orphaned") {
+        issues.push({
+            code: "runner-process-missing",
+            severity: "error",
+            message: `Runner PID ${state.runner?.pid} is not alive on host ${state.runner?.hostname}`,
+            advisoryAction: "Treat this run as orphaned; inspect artifacts and start a new run instead of resuming it.",
+        });
+    }
+    else if (liveness.status === "stale") {
+        issues.push({
+            code: "runner-heartbeat-stale",
+            severity: "warning",
+            message: `Runner heartbeat is stale since ${state.runner?.heartbeatAt}`,
+            advisoryAction: "Inspect node artifacts and process liveness before stopping or retrying.",
+        });
+    }
+    else if (liveness.status === "node-quiet") {
+        issues.push({
+            code: "node-activity-quiet",
+            severity: "warning",
+            message: "Runner heartbeat is fresh but the current RUNNING node has produced no state activity for more than 5 minutes",
+            advisoryAction: "Inspect the node session events and executor logs before deciding whether to wait or abort.",
+        });
+    }
     if (lifecycle === "active" &&
         state.status === "running" &&
         state.humanDecisionNodeId) {
@@ -340,6 +454,14 @@ export async function buildDagOperatorRunSummary(entry) {
             pendingNodes: [],
             finishedNodes: [],
             healthIssues,
+            effectiveStatus: entry.lifecycle === "paused" ? "paused" : "unknown",
+            stateConsistent: false,
+            recoveryEligibility: {
+                canResume: false,
+                canReconcile: false,
+                allowedActions: [],
+                reasons: ["missing-state-json"],
+            },
             nextRecommendedAction: deriveOperatorNextAction({
                 lifecycle: entry.lifecycle,
                 state: {
@@ -363,9 +485,22 @@ export async function buildDagOperatorRunSummary(entry) {
         runDir: entry.runDir,
         state,
     });
+    const liveness = assessDagRunLiveness({ state });
     const hasHumanApproval = state.humanDecisionNodeId
         ? await humanApprovalArtifactExists(entry.runDir, state.humanDecisionNodeId)
         : false;
+    const effectiveStatus = deriveDagRunEffectiveStatus({
+        lifecycle: entry.lifecycle,
+        state,
+        liveness: liveness.status,
+    });
+    const stateConsistent = !healthIssues.some((issue) => ["lifecycle-status-mismatch", "non-terminal-in-completed"].includes(issue.code));
+    const recoveryEligibility = assessDagRunRecoveryEligibility({
+        lifecycle: entry.lifecycle,
+        state,
+        liveness: liveness.status,
+        hasHumanApproval,
+    });
     return {
         runId: state.runId,
         title: state.title,
@@ -380,6 +515,10 @@ export async function buildDagOperatorRunSummary(entry) {
         pendingNodes: listPendingNodeIds(state),
         finishedNodes: listFinishedNodeIds(state),
         healthIssues,
+        liveness: liveness.status,
+        effectiveStatus,
+        stateConsistent,
+        recoveryEligibility,
         nextRecommendedAction: deriveOperatorNextAction({
             lifecycle: entry.lifecycle,
             state,
@@ -552,6 +691,13 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
         "",
         `- run id: ${runId}`,
         `- lifecycle: ${located.lifecycle}`,
+        `- effective status: ${summary.effectiveStatus}`,
+        `- raw status: ${summary.status}`,
+        `- state consistent: ${summary.stateConsistent ? "yes" : "no"}`,
+        `- liveness: ${summary.liveness ?? "unknown"}`,
+        `- can resume: ${summary.recoveryEligibility.canResume ? "yes" : "no"}`,
+        `- can reconcile: ${summary.recoveryEligibility.canReconcile ? "yes" : "no"}`,
+        `- health issues: ${summary.healthIssues.length > 0 ? summary.healthIssues.map((issue) => `${issue.code}: ${issue.message}`).join("; ") : "none"}`,
         `- failed node: ${failure.nodeId ?? "-"}`,
         `- raw failure: ${rawFailureCategory ?? "-"}`,
         `- normalized category: ${normalizedCategory}`,

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

@@ -113,6 +113,7 @@ export async function executeDagNode(input) {
     const node = state.nodes[nodeId];
     node.status = "RUNNING";
     node.startedAt = new Date().toISOString();
+    node.lastActivityAt = node.startedAt;
     if (task.shell?.verifyEvidence) {
         node.verifyEvidence = task.shell.verifyEvidence;
     }
@@ -140,6 +141,7 @@ export async function executeDagNode(input) {
             node.stderr = result.stderr;
             node.failureCategory = result.failureCategory;
             node.finishedAt = new Date().toISOString();
+            node.lastActivityAt = node.finishedAt;
             node.status = result.ok ? "FINISHED" : "ERROR";
         }
         catch (error) {
@@ -202,6 +204,7 @@ export async function executeDagNode(input) {
             await notifyNodeObserver(input.observer, "onNodeOutput", nodeId, state, outputChunk);
         }
         node.finishedAt = new Date().toISOString();
+        node.lastActivityAt = node.finishedAt;
         node.status = result.ok ? "FINISHED" : "ERROR";
         if (result.ok) {
             const decisionRecord = await recordDecisionEnvelopeForNode({

package/dist/workflows/dag/prompt.js

@@ -1,3 +1,4 @@
+import { DEFAULT_DAG_OUTPUT_LANGUAGE, } from "./types.js";
 import { formatStdoutPreview, formatUpstreamArtifactPointerMap, } from "./upstream-artifacts.js";
 export const MAX_UPSTREAM_CHARS = 2_000;
 /** Shared bullets for DAG authoring templates, docs, and planner-node envelopes. */
@@ -41,6 +42,20 @@ function formatResolvedSkillInstructions(instructions) {
         .map((instruction) => instruction.promptText)
         .join("\n\n---\n\n");
 }
+export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE) {
+    if (language === "en") {
+        return [
+            "Write prose, analysis, reports, summaries, and documentation in English.",
+            "Keep code, commands, paths, identifiers, JSON keys, exact protocol tokens, verdict lines, and output-contract literals unchanged.",
+            "If the node task explicitly requires another language, follow the explicit task requirement.",
+        ].join("\n");
+    }
+    return [
+        "使用简体中文撰写说明、分析、报告、总结和文档正文。",
+        "代码、命令、路径、标识符、JSON 字段、精确协议 token、VERDICT 行以及 output contract 中要求的字面量保持原样，不要翻译。",
+        "如果当前节点任务明确要求其他语言，以节点的明确要求为准。",
+    ].join("\n");
+}
 export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS) {
     const sections = [];
     for (const depId of task.depends_on) {
@@ -91,6 +106,7 @@ export function buildDagNodePromptEnvelope(input) {
         `<dag_objective>\n${objective}\n</dag_objective>`,
         `<success_criteria>\n${successCriteria}\n</success_criteria>`,
         `<global_constraints>\n${globalConstraints}\n</global_constraints>`,
+        `<output_language>\n${formatOutputLanguageBlock(spec.outputLanguage)}\n</output_language>`,
         [
             "<node_contract>",
             `Role: ${role}`,

package/dist/workflows/dag/report.js

@@ -20,6 +20,8 @@ const dagRunStatusSchema = z.enum([
     "partial_failed",
     "failed",
     "paused",
+    "superseded",
+    "abandoned",
 ]);
 const dagRecoveryActionSchema = z.enum(DAG_RECOVERY_ACTIONS);
 const dagProductLineFailureCategorySchema = z.enum(dagProductLineFailureCategoryValues);