@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-beta.1

package/dist/workflows/dag/runner.js

@@ -307,6 +307,19 @@ export async function runDag(spec, opts) {
     }
 }
 export async function runDagContinuation(opts) {
+    assertValidDagSpec(opts.spec);
+    assertFrozenBudget(opts.spec.budget, opts.state.budget, opts.state.runId);
+    if (opts.spec.budget) {
+        const ledger = opts.state.budgetLedger;
+        if (!ledger ||
+            ledger.mode !== opts.spec.budget.mode ||
+            JSON.stringify(ledger.limits) !== JSON.stringify(opts.spec.budget.limits)) {
+            throw new Error(`dag continuation ${opts.state.runId} is missing a matching cumulative budget ledger`);
+        }
+    }
+    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent, } = await import("./task-contract-binding.js");
+    assertDagSpecAllowsNewWriterExecution(opts.spec);
+    await assertTaskContractBindingConsistent({ repoRoot: opts.cwd, spec: opts.spec });
     const { maxConcurrent } = resolveEffectiveMaxConcurrent(Math.max(1, opts.maxConcurrent ?? 4), opts.spec.budget);
     const state = opts.state;
     state.status = "running";
@@ -328,6 +341,7 @@ export async function runDagContinuation(opts) {
         cwd: opts.cwd,
         maxConcurrent,
         executeNode: opts.executeNode,
+        beforeTerminalArchive: opts.beforeTerminalArchive,
         observer: opts.observer,
         abortSignal: opts.abortSignal,
         activeRunDir,
@@ -712,6 +726,10 @@ async function executeDagCheckpoint(input) {
             }
             await notifyRunObserver(input.observer, "onRunFinish", state);
             if (!recoveryPending) {
+                if (input.beforeTerminalArchive) {
+                    await input.beforeTerminalArchive({ runDir, state });
+                    await persistState();
+                }
                 try {
                     const terminalCheckpoint = await captureWorkspaceCheckpoint(cwd);
                     await writeWorkspaceCheckpoint(runDir, WORKSPACE_CHECKPOINT_TERMINAL_REL, terminalCheckpoint);
@@ -942,7 +960,8 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
     // mechanical partial_failed just because prewrite FINISHED while the writer
     // was SKIPPED. Fail closed on retryable-invalid/blocked before aggregation.
     let recoveryPending = false;
-    const skipFrontendRecovery = state.failureCategory === "controller-interrupted";
+    const skipFrontendRecovery = state.failureCategory === "controller-interrupted" ||
+        state.continuation?.writerTransaction !== undefined;
     const hasFrontendWriter = Object.keys(state.nodes).some((id) => FRONTEND_WRITER_NODE_IDS.includes(id));
     if (hasFrontendWriter && !skipFrontendRecovery) {
         const admission = await readFrontendPrewriteResult(runDir);

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

@@ -333,11 +333,27 @@ function parseSnapshot(value) {
 export async function cloneParentSkillSnapshotForContinuation(input) {
     const parentSnapshot = await readSkillSnapshot(input.parentRunDir, input.parentRef, { expectedRunId: input.parentRunId });
     const parentSnapshotSha256 = hashSkillSnapshot(parentSnapshot);
+    const initialTaskIds = input.spec
+        ? input.spec.tasks.map((task) => task.id)
+        : parentSnapshot.initialTaskIds;
+    const bindings = input.spec
+        ? collectDagSkillSnapshotBindings(input.spec, initialTaskIds)
+        : parentSnapshot.bindings;
+    const boundProfileIds = new Set(bindings.map((binding) => binding.profileId));
+    const profiles = parentSnapshot.profiles.filter((profile) => boundProfileIds.has(profile.id));
+    for (const profileId of boundProfileIds) {
+        if (!profiles.some((profile) => profile.id === profileId)) {
+            throw new DagSkillSnapshotIntegrityError(`continuation run spec requires profile missing from parent snapshot: ${profileId}`);
+        }
+    }
     const cloned = {
         ...structuredClone(parentSnapshot),
         runId: input.newRunId,
         createdAt: (input.now ?? new Date()).toISOString(),
         mode: "continuation-from-parent",
+        initialTaskIds,
+        bindings,
+        profiles,
     };
     const ref = await writeSkillSnapshot(input.newRunDir, cloned);
     await writeJsonAtomic(path.join(input.newRunDir, ...SKILL_SNAPSHOT_CONTINUATION_REL_PATH.split("/")), {
@@ -540,6 +556,7 @@ export function buildNodePromptFromSnapshot(input) {
             spec: input.spec,
             task: input.task,
             upstream: input.upstream,
+            runDir: input.runDir,
             resolvedSkills: skillNames,
             resolvedSkillInstructions,
             maxUpstreamChars: policy.resolveMaxUpstreamChars(input.task),

package/dist/workflows/dag/types.js

@@ -80,7 +80,10 @@ export const dagShellVerifyEvidenceSchema = z.object({
     selectionReasons: z.array(z.string()).default([]),
     /** Non-executing generation-time cwd/local-script validation evidence. */
     preflight: z
-        .array(z.object({ label: z.string(), status: z.enum(["ok", "future-delivery-script"]) }))
+        .array(z.object({
+        label: z.string(),
+        status: z.enum(["ok", "future-delivery-script"]),
+    }))
         .default([]),
     /** Effective timeout applied independently to each shell command. */
     commandTimeoutMs: z.number().int().positive().optional(),
@@ -734,7 +737,58 @@ export const structuredContractOutputSchemaIds = [
     "frontend-implementation-contract-plan-patch-v1",
     "frontend-implementation-contract-revision-patch-v1",
 ];
-export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/, "task id must be kebab-case"),
+export const dagArtifactIdentitySchema = z
+    .string()
+    .regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/, "artifact id must be stable lower-case dot/kebab syntax");
+const dagArtifactRelativePathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.includes("\0"), "artifact path must not contain NUL")
+    .refine((value) => !value.includes("\\"), "artifact path must use POSIX separators")
+    .refine((value) => !value.startsWith("/") && !/^[A-Za-z]:/.test(value), "artifact path must be run-relative")
+    .refine((value) => value.split("/").every((segment) => segment !== "" && segment !== ".."), "artifact path must not escape the run");
+export const dagProducedArtifactSchema = z
+    .object({
+    artifactId: dagArtifactIdentitySchema,
+    kind: z.enum(["structured", "assistant", "stdout"]),
+    path: dagArtifactRelativePathSchema,
+    mediaType: z.string().min(1),
+    schemaId: z.string().min(1).optional(),
+    revisionPolicy: z.enum(["immutable", "replace-file"]),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.kind === "structured" && !value.schemaId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["schemaId"],
+            message: "structured artifact requires schemaId",
+        });
+    }
+    if (value.kind !== "structured" && value.schemaId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["schemaId"],
+            message: "only structured artifacts may declare schemaId",
+        });
+    }
+    if (value.revisionPolicy === "replace-file" &&
+        value.kind !== "structured") {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["revisionPolicy"],
+            message: "MVP revisions are limited to structured artifacts",
+        });
+    }
+});
+export const dagConsumedArtifactSchema = z
+    .object({
+    artifactId: dagArtifactIdentitySchema,
+    required: z.boolean().default(true),
+})
+    .strict();
+export const dagTaskSchema = z.object({
+    id: z.string().regex(/^[a-z][a-z0-9-]*$/, "task id must be kebab-case"),
     depends_on: z.array(z.string()).default([]),
     /**
      * How SKIPPED upstreams affect readiness.
@@ -797,6 +851,15 @@ export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/
     shell: dagShellConfigSchema.optional(),
     static: dagStaticConfigSchema.optional(),
     outputContract: z.string().optional(),
+    /**
+     * Frozen producer declarations for run-owned artifacts. These declarations,
+     * together with consumesArtifacts, are the only authority for artifact
+     * lineage and impact analysis. Prompt/outputContract/path heuristics are
+     * intentionally forbidden.
+     */
+    producesArtifacts: z.array(dagProducedArtifactSchema).optional(),
+    /** Frozen logical artifact inputs consumed by this node. */
+    consumesArtifacts: z.array(dagConsumedArtifactSchema).optional(),
     outputMode: dagOutputModeSchema.optional(),
     firstProtocolLine: z.string().min(1).optional(),
     /**
@@ -825,8 +888,7 @@ export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/
     })
         .strict()
         .superRefine((value, ctx) => {
-        if (value.schemaId ===
-            "frontend-implementation-contract-plan-patch-v1" &&
+        if (value.schemaId === "frontend-implementation-contract-plan-patch-v1" &&
             !value.skeleton) {
             ctx.addIssue({
                 code: "custom",
@@ -881,6 +943,121 @@ export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/
     dynamicCondition: dagDynamicConditionSchema.optional(),
     dynamicLoopUntil: dagDynamicLoopUntilSchema.optional(),
 });
+function hasTransitiveDependency(tasksById, consumerNodeId, producerNodeId) {
+    const queue = [...(tasksById.get(consumerNodeId)?.depends_on ?? [])];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        if (nodeId === producerNodeId)
+            return true;
+        if (seen.has(nodeId))
+            continue;
+        seen.add(nodeId);
+        queue.push(...(tasksById.get(nodeId)?.depends_on ?? []));
+    }
+    return false;
+}
+function validateFrozenArtifactBindings(tasks, ctx) {
+    const tasksById = new Map(tasks.map((task) => [task.id, task]));
+    const producers = new Map();
+    const paths = new Map();
+    for (const [taskIndex, task] of tasks.entries()) {
+        const localIds = new Set();
+        for (const [artifactIndex, artifact] of (task.producesArtifacts ?? []).entries()) {
+            if (localIds.has(artifact.artifactId) ||
+                producers.has(artifact.artifactId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [
+                        "tasks",
+                        taskIndex,
+                        "producesArtifacts",
+                        artifactIndex,
+                        "artifactId",
+                    ],
+                    message: `artifact ${artifact.artifactId} must have exactly one producer`,
+                });
+            }
+            else {
+                producers.set(artifact.artifactId, {
+                    nodeId: task.id,
+                    taskIndex,
+                    artifactIndex,
+                    path: artifact.path,
+                });
+            }
+            localIds.add(artifact.artifactId);
+            const foldedPath = artifact.path
+                .normalize("NFC")
+                .toLocaleLowerCase("en-US");
+            const existingArtifactId = paths.get(foldedPath);
+            if (existingArtifactId && existingArtifactId !== artifact.artifactId) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [
+                        "tasks",
+                        taskIndex,
+                        "producesArtifacts",
+                        artifactIndex,
+                        "path",
+                    ],
+                    message: `artifact path collides with ${existingArtifactId} under case folding`,
+                });
+            }
+            else {
+                paths.set(foldedPath, artifact.artifactId);
+            }
+        }
+    }
+    for (const [taskIndex, task] of tasks.entries()) {
+        const consumed = new Set();
+        for (const [artifactIndex, binding] of (task.consumesArtifacts ?? []).entries()) {
+            if (consumed.has(binding.artifactId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [
+                        "tasks",
+                        taskIndex,
+                        "consumesArtifacts",
+                        artifactIndex,
+                        "artifactId",
+                    ],
+                    message: `artifact ${binding.artifactId} is consumed more than once by ${task.id}`,
+                });
+            }
+            consumed.add(binding.artifactId);
+            const producer = producers.get(binding.artifactId);
+            if (!producer) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [
+                        "tasks",
+                        taskIndex,
+                        "consumesArtifacts",
+                        artifactIndex,
+                        "artifactId",
+                    ],
+                    message: `artifact ${binding.artifactId} has no declared producer`,
+                });
+                continue;
+            }
+            if (producer.nodeId === task.id ||
+                !hasTransitiveDependency(tasksById, task.id, producer.nodeId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [
+                        "tasks",
+                        taskIndex,
+                        "consumesArtifacts",
+                        artifactIndex,
+                        "artifactId",
+                    ],
+                    message: `consumer ${task.id} must be downstream of producer ${producer.nodeId}`,
+                });
+            }
+        }
+    }
+}
 export const dagModelsSchema = z
     .object({
     HIGH: z.string().optional(),
@@ -910,9 +1087,7 @@ export const dagBudgetSchema = campaignBudgetSchema;
 export const dagSourceBindingSourceSchema = z.object({
     kind: z.enum(["requirement", "constraint", "reference"]),
     path: z.string().min(1),
-    sha256: z
-        .string()
-        .regex(/^[a-f0-9]{64}$/, "sha256 must be lowercase hex"),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/, "sha256 must be lowercase hex"),
 });
 /**
  * DagSourceBinding v1：无 ledger 字段（schemaVersion=1，.strict() 拒绝 ledger
@@ -1063,6 +1238,7 @@ export const dagSpecSchema = z
 })
     .superRefine((spec, ctx) => {
     const supportsV3Fields = spec.version === 3 || spec.version === 4;
+    validateFrozenArtifactBindings(spec.tasks, ctx);
     if (spec.evaluation && !supportsV3Fields) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,

package/docs/architecture/runtime-boundaries.md

@@ -160,18 +160,18 @@ Runner / Loop         ──(迁移中)──>  逐步改为仅经 Store / Appli
 
 | From | May import | Must not import |
 | ------ | ------------ | ----------------- |
-| `src/commands/**` | application, workflows, infrastructure, task, records, executors, shared | — |
-| `src/workflows/**` | executors, task, records, shared, application（目标） | `src/commands/**` |
+| `src/commands/**` | application, workflows, infrastructure, task, records, executors, shared | `src/worker/**` |
+| `src/workflows/**` | executors, task, records, shared, infrastructure, application（目标） | `src/commands/**` |
 | `src/executors/**` | shared, 外部 SDK | `src/commands/**`, `src/cli/**` |
-| `src/worker/**` | worker-local modules, task contracts, shared, Node APIs | `src/commands/**`, `src/cli/**`, `src/application/**` |
-| `src/cli/**` | commands, adapters, shared, application（目标） | — |
+| `src/worker/**` | worker-local modules, task contracts, shared, infrastructure, Node APIs | `src/commands/**`, `src/cli/**`, `src/application/**` |
+| `src/cli/**` | commands, adapters, shared, infrastructure, application（目标） | — |
 | `.agents/skills/**` | （Markdown 引用，非 TS import） | 运行时 TS 模块 |
 
 ## 已知过渡耦合
 
-当前没有允许的 `src/workflows/**` / `src/executors/**` forbidden import，也没有允许的 `src/worker/**` → `src/{cli,commands,application}/**` TypeScript import。
+当前没有允许的 `src/workflows/**` / `src/executors/**` forbidden import，也没有允许的 `src/worker/**` → `src/{cli,commands,application}/**` 或 `src/commands/**` → `src/worker/**` TypeScript import。Console app-data 存储（operations、context exports、artifact revisions、app-data path helpers）位于 `src/infrastructure/console/**`，由 Console（worker 层）与 CLI 命令共同向下依赖；Console 专属的 route/action 编排仍留在 `src/worker/console/**`。
 
-`scripts/check-architecture-boundaries.sh` 的 transitional allowlist 保持为空。任何新增的 `workflows/executors/worker` forbidden import 必须导致检查 **exit 1**；如果未来确有临时例外，必须先写入 active exec plan，说明移除时间和验证门禁。
+`scripts/check-architecture-boundaries.sh` 的 transitional allowlist 保持为空。任何新增的 `workflows/executors/worker/commands` forbidden import 必须导致检查 **exit 1**；如果未来确有临时例外，必须先写入 active exec plan，说明移除时间和验证门禁。
 
 ## Governance 钩子
 
@@ -207,7 +207,8 @@ Runtime 变更另需 `npm run typecheck` 及对应 targeted Vitest（见 exec pl
 | --- | --- | --- |
 | OpenCode transient-retry | `.opencode/plugins/loop-agent-transient-retry.js`（init surface `generated`） | 仅瞬态 UnknownError resume；busy/retry 门控 + backoff；overflow/401/配额/取消/业务标 permanent（`plugin-ignore-permanent-error`），**不** compact |
 | OpenCode overflow-compact | `.opencode/plugins/loop-agent-context-overflow-compact.js`（init surface `generated`） | 仅 context overflow → `session.compact`（无则 `summarize`）+ 有限 `promptAsync` 续接；`MAX_OVERFLOW_RECOVERIES ≤ 2`；session 锁；非 overflow 不动作 |
-| Pi project extension | `.pi/extensions/loop-agent-context-overflow.js`（init surface `generated`） | `message_end` 上将 overflow `errorMessage` 幂等改写为 `context_length_exceeded:` 前缀，触发 Pi 原生 compact/retry；**不**写 `~/.pi` settings / compaction / 模型窗口 |
+| Pi project extension | `.pi/extensions/loop-agent-context-overflow.js`（init surface `generated`） | `message_end` 上将 overflow `errorMessage` 幂等改写为 `context_length_exceeded:` 前缀，触发 Pi 原生 compact/retry；分类器与控制器共享 P1–P10 / N1–N5 语料（含嵌套 JSON）；**不**写 `~/.pi` settings / compaction / 模型窗口，**不**投影 sift native |
+| Console / DAG 运行时 | npm 内置 inline extension + 可选 `@agent-context/sift` | 默认开启 L0/L1/L2；`HARNESS_CONTEXT_PRESSURE_MODE=off` 关 L0/L2；`HARNESS_CONSOLE_SIFT` / `HARNESS_DAG_SIFT` 的 `0\|false\|off` 关 L1。DAG 不做 streaming 主动 compact。不进入目标项目 init 文件 |
 | Pi 用户配置 | `~/.pi/agent/settings.json` | **不**进入项目 `.harness/init-surface.json` hash；仅 `--client-recovery=user` 可字段级补缺并原子写；`auto`/`project`/`off` 与 `check-update` 默认零写 home；读取时只有 `ENOENT` 视为缺文件，其他 I/O 错误 fail closed |
 | CLI mode | `--client-recovery=auto\|project\|user\|off`（默认 `auto`） | `auto`/`project` 安装上述三份项目产物；`user` = 三产物 + 显式 Pi retry 合并；`off` 全跳过 |
 | Ownership | recorded sha256 + apply-safe | 三份 generated 缺失可补、与 recorded hash 一致可升级；用户改过 → model merge / human decision，禁止静默覆盖 |

package/docs/architecture/worker-and-feature.md

@@ -61,7 +61,7 @@ controller identity 与 DAG skill snapshot 是两个不同冻结层（前者跨
 
 - schema/validate：`src/worker/task-spec/{schema,validate}.ts`。
 - 校验验收条件、依赖、验证命令；`agent-worker task validate-feature` 等用之。
-- **0.16.0+**：可选 `execution.workflow` 映射到 loop-agent `taskKind`（如 agent-dag / frontend-implementation / backend-test / frontend-test）；typed Task Outcome 与 artifact-aware Ready 门禁见 completed `2026-07-19-taskspec-workflow-routing.md`。
+- **0.16.0+**：可选 `execution.workflow` 映射到 loop-agent `taskKind`（agent-dag / frontend-implementation / backend-test-analysis / backend-test / frontend-test）；`backend-test-analysis` 只读生成严格 analysis artifact，不执行测试；typed Task Outcome 与 artifact-aware Ready 门禁见 completed `2026-07-19-taskspec-workflow-routing.md`。
 - 文档映射镜像：`docs/architecture/taskspec-to-loop-agent-mapping.md`（runtime 真源仍在 `src/worker/` 与 materialize 路径）。
 
 ### Task Pool

package/docs/templates/agent-dag.schema.json

@@ -483,6 +483,28 @@
         "sha256": { "type": "string", "minLength": 1 }
       }
     },
+    "producedArtifact": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["artifactId", "kind", "path", "mediaType", "revisionPolicy"],
+      "properties": {
+        "artifactId": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" },
+        "kind": { "enum": ["structured", "assistant", "stdout"] },
+        "path": { "type": "string", "pattern": "^(?!/)(?![A-Za-z]:)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\).+$" },
+        "mediaType": { "type": "string", "minLength": 1 },
+        "schemaId": { "type": "string", "minLength": 1 },
+        "revisionPolicy": { "enum": ["immutable", "replace-file"] }
+      }
+    },
+    "consumedArtifact": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["artifactId"],
+      "properties": {
+        "artifactId": { "type": "string", "pattern": "^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$" },
+        "required": { "type": "boolean", "default": true }
+      }
+    },
     "task": {
       "type": "object",
       "additionalProperties": false,
@@ -570,6 +592,16 @@
           "type": "string",
           "minLength": 1
         },
+        "producesArtifacts": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/producedArtifact" },
+          "description": "Frozen producer declarations. Artifact lineage and impact analysis must use these declarations, never prompt/outputContract/path heuristics."
+        },
+        "consumesArtifacts": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/consumedArtifact" },
+          "description": "Frozen logical artifact inputs consumed by this node."
+        },
         "outputMode": {
           "enum": ["default", "structured-required"],
           "description": "Optional output semantics for Pi nodes. structured-required means oversized assistant output must not be accepted as a truncated success; eligible read-only nodes may compact-retry and downstream gates should rely on canonical structured artifacts."