@tea-agent/loop-agent 0.9.0 → 0.10.0

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);

package/dist/workflows/dag/runner.js

@@ -1,4 +1,5 @@
 import { readdir, readFile } from "node:fs/promises";
+import { hostname } from "node:os";
 import path from "node:path";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalCompactDate, } from "../../task/runtime.js";
 import { getDagRunDir, isTerminalDagRunStatus, locateDagRun, readHumanApprovalArtifact, requireActiveDagRun, } from "./lifecycle.js";
@@ -12,7 +13,7 @@ import { buildNodePrompt, buildNodePromptWithResolvedSkillInstructions, executeD
 import { runConvergencePassController, shouldEnableDagConvergence, } from "./convergence/controller.js";
 import { executeDagRanksOnce, isConditionSkippedReason, } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
-import { parseDagSpec, } from "./types.js";
+import { parseDagSpec, resolveModelForTask, } from "./types.js";
 import { executeDynamicCondition } from "./dynamic-runtime/condition.js";
 import { executeDynamicLoopUntil } from "./dynamic-runtime/loop-until.js";
 import { executeDynamicMapExpansion } from "./dynamic-runtime/map.js";
@@ -109,6 +110,9 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
             status: "PENDING",
             executor: task.executor,
             complexity: task.complexity,
+            ...(resolveModelForTask(task, spec.executorModels)
+                ? { model: resolveModelForTask(task, spec.executorModels) }
+                : {}),
         };
     }
     return {
@@ -117,6 +121,12 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
         runId,
         cwd: opts.cwd,
         startedAt: new Date().toISOString(),
+        runner: {
+            pid: process.pid,
+            hostname: hostname(),
+            startedAt: new Date().toISOString(),
+            heartbeatAt: new Date().toISOString(),
+        },
         status: opts.initOnly || opts.dryRun ? "pending" : "running",
         ranks,
         nodes,
@@ -213,6 +223,13 @@ export async function resumeDagRun(opts) {
     }
     const maxConcurrent = Math.max(1, opts.maxConcurrent ?? 4);
     state.status = "running";
+    const resumedAt = new Date().toISOString();
+    state.runner = {
+        pid: process.pid,
+        hostname: hostname(),
+        startedAt: resumedAt,
+        heartbeatAt: resumedAt,
+    };
     const activeRunDir = getDagRunDir(opts.cwd, "active", state.runId);
     const completedRunDir = getDagRunDir(opts.cwd, "completed", state.runId);
     const pausedRunDir = getDagRunDir(opts.cwd, "paused", state.runId);
@@ -243,124 +260,136 @@ async function executeDagCheckpoint(input) {
         stateWriteQueue = stateWriteQueue.then(() => writeRunState(runDir, state, options));
         await stateWriteQueue;
     };
-    const tasksById = new Map(spec.tasks.map((task) => [task.id, task]));
-    const baseExecuteNode = input.executeNode ??
-        createDagNodeExecutor({
-            runDir,
-            runId: state.runId,
-            spec,
-        });
-    const executeDynamicNode = async (dynamicInput) => {
-        const { task } = dynamicInput;
-        if (task.dynamicExpansion) {
-            return executeDynamicMapExpansion({
-                ...dynamicInput,
-                expansion: task.dynamicExpansion,
-                executeDynamicNode,
+    const heartbeatTimer = setInterval(() => {
+        if (!state.runner)
+            return;
+        state.runner.heartbeatAt = new Date().toISOString();
+        void persistState().catch(() => { });
+    }, 15_000);
+    heartbeatTimer.unref();
+    try {
+        const tasksById = new Map(spec.tasks.map((task) => [task.id, task]));
+        const baseExecuteNode = input.executeNode ??
+            createDagNodeExecutor({
+                runDir,
+                runId: state.runId,
+                spec,
             });
-        }
-        if (task.dynamicCondition) {
-            return executeDynamicCondition({
+        const executeDynamicNode = async (dynamicInput) => {
+            const { task } = dynamicInput;
+            if (task.dynamicExpansion) {
+                return executeDynamicMapExpansion({
+                    ...dynamicInput,
+                    expansion: task.dynamicExpansion,
+                    executeDynamicNode,
+                });
+            }
+            if (task.dynamicCondition) {
+                return executeDynamicCondition({
+                    task,
+                    condition: task.dynamicCondition,
+                    tasksById: dynamicInput.tasksById,
+                    state: dynamicInput.state,
+                });
+            }
+            if (task.dynamicLoopUntil) {
+                return executeDynamicLoopUntil({
+                    ...dynamicInput,
+                    loop: task.dynamicLoopUntil,
+                    executeDynamicNode,
+                });
+            }
+            return executeDynamicReduction({
                 task,
-                condition: task.dynamicCondition,
-                tasksById: dynamicInput.tasksById,
+                reduction: task.dynamicReduction,
                 state: dynamicInput.state,
+                runDir: dynamicInput.runDir,
             });
-        }
-        if (task.dynamicLoopUntil) {
-            return executeDynamicLoopUntil({
-                ...dynamicInput,
-                loop: task.dynamicLoopUntil,
-                executeDynamicNode,
-            });
-        }
-        return executeDynamicReduction({
-            task,
-            reduction: task.dynamicReduction,
-            state: dynamicInput.state,
-            runDir: dynamicInput.runDir,
-        });
-    };
-    let pausedByNodeId;
-    while (true) {
-        pausedByNodeId = await executeDagRanksOnce({
-            state,
-            ranks,
-            tasksById,
-            maxConcurrent,
-            persistState,
-            createExecuteNodeForRank: (rankCursorNodeIds) => buildRankAwareExecuteNode({
-                baseExecuteNode,
-                customExecuteNode: input.executeNode,
-                rankCursorNodeIds,
-                tasksById,
-                meta: { runDir, runId: state.runId, spec },
-            }),
-            executeScheduledNode: (nodeId, executeNode, onPause) => executeDagNode({
-                nodeId,
-                tasksById,
+        };
+        let pausedByNodeId;
+        while (true) {
+            pausedByNodeId = await executeDagRanksOnce({
                 state,
+                ranks,
+                tasksById,
+                maxConcurrent,
+                persistState,
+                createExecuteNodeForRank: (rankCursorNodeIds) => buildRankAwareExecuteNode({
+                    baseExecuteNode,
+                    customExecuteNode: input.executeNode,
+                    rankCursorNodeIds,
+                    tasksById,
+                    meta: { runDir, runId: state.runId, spec },
+                }),
+                executeScheduledNode: (nodeId, executeNode, onPause) => executeDagNode({
+                    nodeId,
+                    tasksById,
+                    state,
+                    spec,
+                    cwd,
+                    runDir,
+                    executeNode,
+                    executeDynamicNode,
+                    observer: input.observer,
+                    persistState,
+                    onPause,
+                }),
+            });
+            if (pausedByNodeId) {
+                break;
+            }
+            const convergenceDecision = await runConvergencePassController({
                 spec,
-                cwd,
+                state,
+                tasksById,
                 runDir,
-                executeNode,
-                executeDynamicNode,
-                observer: input.observer,
+                cwd,
                 persistState,
-                onPause,
-            }),
-        });
-        if (pausedByNodeId) {
+            });
+            if (convergenceDecision.pausedByNodeId) {
+                pausedByNodeId = convergenceDecision.pausedByNodeId;
+                break;
+            }
+            if (convergenceDecision.retry) {
+                continue;
+            }
             break;
         }
-        const convergenceDecision = await runConvergencePassController({
-            spec,
-            state,
-            tasksById,
+        state.finishedAt = new Date().toISOString();
+        const runDirBeforeTransfer = runDir;
+        if (pausedByNodeId) {
+            state.status = "paused";
+            await persistState();
+            await notifyRunObserver(input.observer, "onRunFinish", state);
+            runDir = await moveToPausedRunDir(runDir, pausedRunDir);
+        }
+        else {
+            finalizeTerminalRunStatus(state, spec.tasks.length);
+            await persistState();
+            await notifyRunObserver(input.observer, "onRunFinish", state);
+            runDir = await moveToCompletedRunDir(runDir, completedRunDir);
+        }
+        await relocateRunArtifactPaths({
             runDir,
-            cwd,
-            persistState,
+            oldRunDir: runDirBeforeTransfer,
+            nodes: state.nodes,
         });
-        if (convergenceDecision.pausedByNodeId) {
-            pausedByNodeId = convergenceDecision.pausedByNodeId;
-            break;
-        }
-        if (convergenceDecision.retry) {
-            continue;
+        if (state.convergence) {
+            relocateConvergenceArtifactPaths(state.convergence, runDirBeforeTransfer, runDir);
         }
-        break;
-    }
-    state.finishedAt = new Date().toISOString();
-    const runDirBeforeTransfer = runDir;
-    if (pausedByNodeId) {
-        state.status = "paused";
-        await persistState();
-        await notifyRunObserver(input.observer, "onRunFinish", state);
-        runDir = await moveToPausedRunDir(runDir, pausedRunDir);
-    }
-    else {
-        finalizeTerminalRunStatus(state, spec.tasks.length);
-        await persistState();
-        await notifyRunObserver(input.observer, "onRunFinish", state);
-        runDir = await moveToCompletedRunDir(runDir, completedRunDir);
+        await persistState({ allowCompletedFactsWrite: true });
+        return {
+            title: spec.title,
+            runId: state.runId,
+            status: state.status,
+            ranks,
+            nodes: state.nodes,
+            runDir,
+        };
     }
-    await relocateRunArtifactPaths({
-        runDir,
-        oldRunDir: runDirBeforeTransfer,
-        nodes: state.nodes,
-    });
-    if (state.convergence) {
-        relocateConvergenceArtifactPaths(state.convergence, runDirBeforeTransfer, runDir);
+    finally {
+        clearInterval(heartbeatTimer);
     }
-    await persistState({ allowCompletedFactsWrite: true });
-    return {
-        title: spec.title,
-        runId: state.runId,
-        status: state.status,
-        ranks,
-        nodes: state.nodes,
-        runDir,
-    };
 }
 async function notifyRunObserver(observer, event, state) {
     try {

package/dist/workflows/dag/types.js

@@ -234,9 +234,12 @@ export const dagExecutorModelsSchema = z
     pi: dagModelsSchema.optional(),
 })
     .partial();
+export const dagOutputLanguageSchema = z.enum(["zh-CN", "en"]);
+export const DEFAULT_DAG_OUTPUT_LANGUAGE = "zh-CN";
 export const dagSpecSchema = z.object({
     version: dagVersionSchema,
     title: z.string().min(1),
+    outputLanguage: dagOutputLanguageSchema.optional(),
     objective: z.string().optional(),
     successCriteria: z.array(z.string()).optional(),
     globalConstraints: z.array(z.string()).optional(),

package/docs/README.md

@@ -12,6 +12,14 @@
 - `verification-matrix.md` — 验证命令选择
 - `production-readiness.md` — Production Readiness v0.1 范围、证据与 DAG hardening 标准
 - `loop-agent-harness.md` — runtime 与 command surface 概览
+- `exec-plans/completed/2026-07-11-m2-01-feature-review-model.md` — 第二月 Feature read model 与 `feature review` 已完成实施合同
+- `exec-plans/completed/2026-07-12-m2-02-feature-run-orchestration.md` — 第二月 Feature run 薄编排已完成实施合同
+- `exec-plans/completed/2026-07-12-m2-03-follow-up-tracer-bullet.md` — 第二月 ProductBug Follow-up tracer bullet 已完成合同
+- `exec-plans/completed/2026-07-12-m2-04-follow-up-hardening.md` — 第二月 Follow-up 全分类与事务故障注入已完成合同
+- `exec-plans/completed/2026-07-12-m2-05-git-transaction.md` — 第二月显式授权 Git checkpoint 与失败恢复已完成合同
+- `exec-plans/completed/2026-07-12-m2-06-delivery-closeout-preview.md` — 第二月 Delivery、Acceptance Coverage 与 Closeout preview 已完成合同
+- `exec-plans/completed/2026-07-12-m2-07-feature-decision-metrics.md` — 第二月 Feature 决策体验与 metrics 已完成合同
+- `exec-plans/completed/2026-07-12-m2-08-closeout-dogfood-release.md` — 第二月 Closeout apply、真实 dogfood 与发布证据已完成合同
 - `agent-dag-runner.md` — Agent DAG runner 指南
 - `cursor-executor-usage.md` — Cursor executor 用法
 - `dynamic-workflow-dag-engine-roadmap.md` — Dynamic Workflow DAG Engine 路线图与适配分析
@@ -41,6 +49,15 @@
 - `reports/2026-07-11-command-performance-followups.md` — Observe 快照复用、输出缓冲和 reference index 遍历优化的验证记录
 - `reports/2026-07-11-observe-terminal-dag-kpi.md` — 终态 DAG 被误计为活跃数的修复记录
 - `reports/2026-07-12-observe-warm-console-redesign.md` — 暖白运行控制台视觉重构与桌面验证记录
+- `reports/2026-07-12-dag-state-reconciliation.md` — DAG 实际状态判定、安全收口命令与历史失联运行处理记录
+- `reports/2026-07-12-dag-state-reconciliation-init-evolution-review.md` — DAG 状态收口能力对初始化 surface 的影响审查
+- `reports/2026-07-12-observe-dag-node-model.md` — Dashboard DAG 节点模型显示与历史运行兼容修复记录
+- `reports/2026-07-12-observe-dag-node-model-init-evolution-review.md` — 节点模型持久化与 Observe 投影对初始化 surface 的影响审查
+- `reports/2026-07-12-dag-output-language.md` — Agent DAG 默认中文输出与可配置语言规则实现记录
+- `reports/2026-07-12-dag-output-language-init-evolution-review.md` — DAG 输出语言配置对初始化 surface 的影响审查
+- `reports/2026-07-12-init-evolution-strict-report-range.md` — 严格 init 演化校验拒绝无关历史报告的修复与验证证据
+- `reports/2026-07-12-dag-liveness-recovery.md` — DAG runner 心跳、孤儿运行诊断与 Observe 活跃筛选的修复记录
+- `reports/2026-07-12-dag-liveness-init-evolution-review.md` — DAG 活性元数据对初始化投影和旧项目兼容性的审查
 - `decisions/README.md` — 架构决策
 - `skills/README.md` — repo-local skill registry and vetting notes
 - `templates/` — 可复用的规划、报告与 DAG 模板

package/docs/agent-dag-recovery-playbook.md

@@ -15,7 +15,7 @@ product_line_failure_category
 recommended_follow_up
 ```
 
-Product-line taxonomy 定义见 `design/state-and-failure-taxonomy.md`。
+Product-line taxonomy 定义见 `docs/design/state-and-failure-taxonomy.md`。
 
 **非目标（本 playbook 不覆盖、runner 不实现）：**
 

package/docs/architecture/runtime-boundaries.md

@@ -77,8 +77,9 @@ Governance (scripts/check-*.sh, src/governance/)
 ### Infrastructure / Store
 
 - **位置**：`src/infrastructure/harness/**`（按计划逐步引入）；过渡期部分逻辑仍在 `src/workflows/dag/lifecycle.ts`、`src/records/**`。
-- **职责**：`.harness/tasks`、`.harness/dag-runs`、`.harness/runs`、loop state 的集中读写；completed run facts 只读约束。
-- **禁止**：把 raw path mutation 扩散给 runner、loop action 或 command handler。
+- **职责**：`.harness/tasks`、`.harness/dag-runs`、`.harness/runs`、loop state 的集中读写；completed run facts 只读约束。
+- **DAG recovery mutation**：`dag reconcile-run` 是显式 operator 边界；默认仅检查，只有给出 action + reason 且 runner 已证明停止时才能保存原始快照、写 terminal reconciliation facts 并迁移 lifecycle。Observe、status 和 doctor 始终只读。
+- **禁止**：把 raw path mutation 扩散给 runner、loop action 或 command handler。
 
 ### Governance
 

package/docs/design/README.md

@@ -4,18 +4,24 @@
 
 ## 文档
 
-| 文档 | 用途 |
-|---|---|
-| `产品线共享知识库.md` | 产品线文档仓库作为上游事实源 |
+| 文档 | 用途 |
+|---|---|
+| `DESIGN-cursor.md` | Observe 暖白运行控制台采用的 Cursor 风格视觉参考与设计 token |
+| `DESIGN-lovable.md` | Lovable 风格的暖色视觉系统参考 |
+| `产品线共享知识库.md` | 产品线文档仓库作为上游事实源 |
 | `研发模式.md` | 10 个工作日 Feature 团队工作流 |
 | `六个月规划.md` | 六个月路线图与目标架构 |
 | `taskspec-to-loop-agent-mapping.md` | 将产品线 TaskSpec 适配为 `loop-agent` task 的契约 |
 | `state-and-failure-taxonomy.md` | 文档、Task Pool、DAG、Loop 共用的 canonical status 与 failure taxonomy |
-| `observe-ui.md` | 已实现的 agent-worker 本地只读可观测 UI（事件流 / SSE / stale 诊断）设计、事件契约与验收边界 |
-| `observe-ui-optimization.md` | 2026-07-10：**已实现** Observe UI 中文化、DAG-first 总览、进行中 DAG 置顶、read-model enrichment、Pi `session-events.jsonl` 落盘与过程时间线（UI-1～UI-9） |
+| `archive/2026-07-07-agent-worker-plan.md` | 已归档：Worker 落地计划（基线 0.3.0，M1-M7 物化/调用/Task Pool/batch/morning report 路线图；已随 0.8.0 发布实现于 `src/worker/`） |
+| `archive/2026-07-07-taskspec-plan.md` | 已归档：TaskSpec v0.1 schema 设计（基线 0.3.0，TaskSpec/AcceptanceSpec/TaskGraphSpec schema 与 materialize 规则；已实现于 `src/worker/task-spec/`） |
 | `archive/2026-07-10-下一阶段任务-功能开发完成.md` | 已归档：真实样本、失败硬化与 QA 闭环的功能性开发完成记录 |
+| `archive/2026-07-10-observe-ui.md` | 已归档：agent-worker 本地只读可观测 UI v0 设计（事件流 / SSE / stale 诊断、事件契约与验收边界；OBS-001～010 已完成，0.9.0 暖白重设计在其上演进） |
+| `archive/2026-07-10-observe-ui-optimization.md` | 已归档：Observe UI 中文化、DAG-first 总览、进行中 DAG 置顶、read-model enrichment、Pi `session-events.jsonl` 落盘与过程时间线（UI-1～UI-9 已实现） |
+| `archive/2026-07-10-observe-ui-goal.md` | 已归档：OBS-001～010 逐任务进度看板（全部 ✅ done） |
 | `archive/2026-07-11-第一月规划.md` | 已归档：首月落地计划（0.8.0 发布 + Round 1/2/3 累计 20 runs / 10 success / 50% / 两次 owner morning decision，第一个月闭环目标全部达成） |
 | `archive/2026-07-11-第一月wbs.md` | 已归档：首月 WBS 与分工（与第一月规划配套，任务编号与估算为历史记录） |
+| `archive/2026-07-12-第二月规划.md` | 已归档：第二月本地 Feature 交付闭环计划（M2-01～08 全部完成；F-2026-002 完整 Closeout、F-2026-003 真实失败恢复闭环、月末硬指标全达成；完成审计见 `docs/reports/2026-07-12-m2-completion-audit.md`） |
 
 ## 命名约定（2026-07-09 起）