@tea-agent/loop-agent 0.26.3 → 0.26.5-beta.0

package/dist/workflows/dag/repair-artifact.js

@@ -9,17 +9,31 @@ export const repairFailureClassSchema = z.enum([
     "governance",
     "unknown",
 ]);
+export const repairDispositionSchema = z.enum([
+    "repairable",
+    "blocked-boundary",
+    "no-op-pass",
+]);
 export const repairArtifactSchema = z.object({
     schemaVersion: z.literal(1),
     verdict: z.enum(["pass", "request-revision"]),
     failureClass: repairFailureClassSchema,
-    rootCause: z
-        .string()
-        .min(1, { message: 'repair artifact field "rootCause" must be a non-empty string' }),
+    rootCause: z.string().min(1, {
+        message: 'repair artifact field "rootCause" must be a non-empty string',
+    }),
     fixScope: z.array(z.string().min(1)).default([]),
     invariant: z.string().min(1),
     evidenceRefs: z.array(z.string().min(1)).default([]),
     rawLogFallbackAllowed: z.boolean().default(false),
+    /**
+     * Optional disposition for convergence routing. Omitted values are treated as
+     * `repairable` for backward compatibility with older artifacts.
+     */
+    disposition: repairDispositionSchema.optional(),
+    /**
+     * Report-only out-of-boundary paths. Never expands write authority.
+     */
+    requiredScope: z.array(z.string().min(1)).optional(),
 });
 /**
  * Canonical rootCause substituted when a `verdict: "pass"` repair artifact
@@ -117,7 +131,23 @@ function scopeWithinPatterns(scope, patterns) {
 }
 export function validateRepairArtifactScope(input) {
     const { artifact, repairTask } = input;
+    const disposition = artifact.disposition ?? "repairable";
+    const requiredScope = artifact.requiredScope ?? [];
+    for (const scope of requiredScope) {
+        if (!isPathLikeScope(scope)) {
+            return {
+                ok: false,
+                reason: `requiredScope "${scope}" must be a concrete path or glob (report-only; does not expand write authority)`,
+            };
+        }
+    }
     if (artifact.verdict === "pass") {
+        if (disposition === "blocked-boundary") {
+            return {
+                ok: false,
+                reason: "pass repair artifact cannot use blocked-boundary disposition",
+            };
+        }
         if (artifact.fixScope.length > 0) {
             return {
                 ok: false,
@@ -126,6 +156,67 @@ export function validateRepairArtifactScope(input) {
         }
         return { ok: true, artifact };
     }
+    if (disposition === "no-op-pass") {
+        return {
+            ok: false,
+            reason: "request-revision repair artifact cannot use no-op-pass disposition",
+        };
+    }
+    // blocked-boundary may report empty fixScope (nothing in-boundary to fix)
+    // while requiredScope describes the out-of-boundary need.
+    if (disposition === "blocked-boundary") {
+        if (requiredScope.length === 0) {
+            return {
+                ok: false,
+                reason: "blocked-boundary request-revision requires non-empty requiredScope (report-only)",
+            };
+        }
+        if (!repairTask) {
+            return {
+                ok: false,
+                reason: "repair artifact gate cannot find downstream repair task",
+            };
+        }
+        const allowed = repairTask.allowedPaths ?? [];
+        const writeSet = repairTask.writeSet ?? [];
+        const forbidden = repairTask.forbiddenPaths ?? [];
+        const hasOutOfBoundaryRequiredScope = requiredScope.some((scope) => {
+            const normalized = normalizePath(scope);
+            return (!scopeWithinPatterns(scope, allowed) ||
+                !scopeWithinPatterns(scope, writeSet) ||
+                forbidden.some((pattern) => pathMatchesPattern(normalized, pattern)));
+        });
+        if (!hasOutOfBoundaryRequiredScope) {
+            return {
+                ok: false,
+                reason: "blocked-boundary requiredScope must include a path outside repair task allowedPaths/writeSet",
+            };
+        }
+        if (artifact.fixScope.length > 0) {
+            for (const scope of artifact.fixScope) {
+                if (!isPathLikeScope(scope)) {
+                    return {
+                        ok: false,
+                        reason: `fixScope "${scope}" must be a concrete path or glob inside repair task allowedPaths/writeSet`,
+                    };
+                }
+                if (!scopeWithinPatterns(scope, allowed) ||
+                    !scopeWithinPatterns(scope, writeSet)) {
+                    return {
+                        ok: false,
+                        reason: `fixScope "${scope}" is outside repair task allowedPaths/writeSet`,
+                    };
+                }
+                if (forbidden.some((pattern) => pathMatchesPattern(normalizePath(scope), pattern))) {
+                    return {
+                        ok: false,
+                        reason: `fixScope "${scope}" matches repair task forbiddenPaths`,
+                    };
+                }
+            }
+        }
+        return { ok: true, artifact };
+    }
     if (artifact.fixScope.length === 0) {
         return {
             ok: false,
@@ -148,7 +239,8 @@ export function validateRepairArtifactScope(input) {
                 reason: `fixScope "${scope}" must be a concrete path or glob inside repair task allowedPaths/writeSet`,
             };
         }
-        if (!scopeWithinPatterns(scope, allowed) || !scopeWithinPatterns(scope, writeSet)) {
+        if (!scopeWithinPatterns(scope, allowed) ||
+            !scopeWithinPatterns(scope, writeSet)) {
             return {
                 ok: false,
                 reason: `fixScope "${scope}" is outside repair task allowedPaths/writeSet`,
@@ -255,12 +347,16 @@ export function resolveRepairTaskForGate(input) {
     };
 }
 export function formatRepairArtifactForPrompt(artifact) {
+    const disposition = artifact.disposition ?? "repairable";
+    const requiredScope = artifact.requiredScope ?? [];
     return [
         "Repair artifact:",
         `- verdict: ${artifact.verdict}`,
         `- failureClass: ${artifact.failureClass}`,
         `- rootCause: ${artifact.rootCause}`,
+        `- disposition: ${disposition}`,
         `- fixScope: ${artifact.fixScope.length > 0 ? artifact.fixScope.join(", ") : "(none)"}`,
+        `- requiredScope: ${requiredScope.length > 0 ? requiredScope.join(", ") : "(none)"}`,
         `- invariant: ${artifact.invariant}`,
         `- evidenceRefs: ${artifact.evidenceRefs.length > 0 ? artifact.evidenceRefs.join(", ") : "(none)"}`,
     ].join("\n");

package/dist/workflows/dag/rerun-plan.js

@@ -254,7 +254,10 @@ export function computeResetClosure(spec, effectiveFromNodeId) {
     if (!tasks.has(effectiveFromNodeId)) {
         return [];
     }
-    return [effectiveFromNodeId, ...collectReachableDescendants(spec, effectiveFromNodeId)].sort();
+    return [
+        effectiveFromNodeId,
+        ...collectReachableDescendants(spec, effectiveFromNodeId),
+    ].sort();
 }
 export function assessResetClosureSafety(spec, resetNodeIds) {
     const tasks = taskById(spec);
@@ -355,7 +358,8 @@ function computeVerificationPolicy(spec, parentRunId, resetNodeIds, importedNode
 function deriveSuggestedAction(input) {
     if (input.eligible)
         return "dag-rerun";
-    if (input.workerManaged || input.reasonCodes.includes("worker-managed-rerun-unsupported")) {
+    if (input.workerManaged ||
+        input.reasonCodes.includes("worker-managed-rerun-unsupported")) {
         return "worker-task-retry";
     }
     if (input.parentLifecycle === "paused")
@@ -449,7 +453,8 @@ export async function evaluateDagRerunPlan(input) {
         input.currentControllerFingerprint === input.parentControllerFingerprint;
     const workspaceMatched = input.parentTerminalWorkspace?.fingerprint !== undefined &&
         input.currentWorkspace?.fingerprint !== undefined &&
-        input.parentTerminalWorkspace.fingerprint === input.currentWorkspace.fingerprint;
+        input.parentTerminalWorkspace.fingerprint ===
+            input.currentWorkspace.fingerprint;
     const skillSnapshotVerified = input.skillSnapshotOk !== false;
     const sourceBindingMatched = input.bindingStatus?.sourceBindingMatched ?? true;
     const taskContractBindingMatched = input.bindingStatus?.taskContractBindingMatched ?? true;
@@ -499,7 +504,8 @@ export async function evaluateDagRerunPlan(input) {
         blockedReasons.push("workspace-checkpoint-missing");
     }
     else if (input.currentWorkspace?.fingerprint &&
-        input.parentTerminalWorkspace.fingerprint !== input.currentWorkspace.fingerprint) {
+        input.parentTerminalWorkspace.fingerprint !==
+            input.currentWorkspace.fingerprint) {
         reasonCodes.push("workspace-drift");
         blockedReasons.push("workspace-drift");
     }
@@ -566,9 +572,10 @@ export async function evaluateDagRerunPlan(input) {
     const totalPi = countExecutorNodes(input.parentSpec, allNodeIds, "pi");
     const resetPi = countExecutorNodes(input.parentSpec, resetNodeIds, "pi");
     const resetShell = countExecutorNodes(input.parentSpec, resetNodeIds, "shell");
-    const workerAssociation = input.workerAssociation ?? (input.workerManaged
-        ? { kind: "worker-managed" }
-        : { kind: "standalone" });
+    const workerAssociation = input.workerAssociation ??
+        (input.workerManaged
+            ? { kind: "worker-managed" }
+            : { kind: "standalone" });
     const planWithoutHash = {
         schemaVersion: 1,
         eligible,

package/dist/workflows/dag/types.js

@@ -391,6 +391,12 @@ export const dagShellConfigSchema = z.object({
     repairArtifactGate: dagRepairArtifactGateSchema.optional(),
     /** fail (default): any nonzero command fails the node. record: finish node FINISHED with failure facts for downstream assess/repair. */
     nonZeroExitPolicy: z.enum(["fail", "record"]).optional(),
+    /**
+     * When true/omitted, stop after the first failed command (runtime default true).
+     * When false, continue executing remaining commands and aggregate failures.
+     * Optional on the schema so existing shell literals stay valid; executor applies default.
+     */
+    failFast: z.boolean().optional(),
     envAllowlist: z.array(z.string()).optional(),
     timeoutMs: z.number().optional(),
     cwd: z.string().optional(),

package/dist/workflows/dag/workspace-checkpoint.js

@@ -94,11 +94,47 @@ function computeFingerprint(input) {
         gitHeadSha: input.gitHeadSha,
         statusPorcelainSha256: input.statusPorcelainSha256,
         changedPaths: input.changedPaths,
+        stableGovernanceInputs: input.stableGovernanceInputs,
     });
     return sha256Hex(payload);
 }
+/**
+ * Stable Task Contract governance inputs for same-run hard-verify reuse.
+ * Explicitly excludes `.harness/dag-runs/**` and other runner-owned volatile facts.
+ */
+export function listStableGovernanceInputPaths(taskId) {
+    const safeTaskId = String(taskId ?? "").trim();
+    if (!safeTaskId ||
+        safeTaskId.includes("..") ||
+        safeTaskId.includes("/") ||
+        safeTaskId.includes("\\")) {
+        return [];
+    }
+    const base = `.harness/tasks/${safeTaskId}`;
+    return [
+        `${base}/task.json`,
+        `${base}/dag.json`,
+        `${base}/source/需求.md`,
+        `${base}/source/执行约束.md`,
+        `${base}/source/source-manifest.json`,
+    ];
+}
+async function hashStableGovernanceInputs(repoRoot, taskId) {
+    const paths = listStableGovernanceInputPaths(taskId);
+    const entries = [];
+    for (const relPath of paths) {
+        const hashed = await hashWorkspacePath(repoRoot, relPath, "modified");
+        entries.push({
+            path: relPath,
+            contentSha256: hashed.contentSha256 ?? sha256Hex(`missing:${relPath}`),
+        });
+    }
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+    return entries;
+}
 /**
  * Capture a workspace checkpoint for the current working tree.
+ * When `taskId` is provided, fingerprint includes stable ignored Task Contract inputs.
  */
 export async function captureWorkspaceCheckpoint(repoRoot, options) {
     const capturedAt = (options?.now ?? new Date()).toISOString();
@@ -127,10 +163,15 @@ export async function captureWorkspaceCheckpoint(repoRoot, options) {
         });
     }
     changedPaths.sort((a, b) => a.path.localeCompare(b.path));
+    const taskId = options?.taskId?.trim();
+    const stableGovernanceInputs = taskId
+        ? await hashStableGovernanceInputs(repoRoot, taskId)
+        : undefined;
     const fingerprint = computeFingerprint({
         gitHeadSha,
         statusPorcelainSha256,
         changedPaths,
+        stableGovernanceInputs,
     });
     return {
         schemaVersion: 1,
@@ -138,6 +179,7 @@ export async function captureWorkspaceCheckpoint(repoRoot, options) {
         gitHeadSha,
         statusPorcelainSha256,
         changedPaths,
+        ...(stableGovernanceInputs ? { stableGovernanceInputs } : {}),
         fingerprint,
     };
 }

package/docs/templates/init-managed-agents.md

@@ -29,7 +29,7 @@
 主会话（含 openCode、Cursor Chat、其他宿主 agent）= **operator-only**；skills 与本文件是纪律文档，**不能**替代 `task.json` / DAG `writeSet` / runtime 执法。
 
 | 类别 | 规则 |
-|---|---|
+| --- | --- |
 | **允许** | 已发布 `loop-agent` / `agent-worker` CLI；只读 status/doctor/report/inspect/observe；准备 `source/*` 与 `task.json` 边界；human gate；shell 验证与 handoff。 |
 | **禁止** | 绕过 CLI 用宿主 Edit/Write/ApplyPatch 直接改业务实现；CLI/DAG 失败后「救火改文件」；用聊天自述代替 shell 验证。 |
 | **失败时** | `dag doctor` / `dag report` / `dag reconcile-run`（及适用 worker reconcile）；修正任务源/`task.json`/DAG 后经 CLI 重跑。 |
@@ -40,7 +40,7 @@
 ### 自然语言入口路由
 
 | 用户表达 | 入口 | 执行动作 |
-|---|---|---|
+| --- | --- | --- |
 | loop-agent 初始化 / loop agent 初始化 / loop agent初始化 / 初始化 loop-agent | 初始化 | 完成确定性初始化闭环 |
 | 初始化更新校验 / 检查初始化更新 / loop-agent 初始化更新校验 / loop agent初始化更新校验 | 更新校验 | 只读报告，不写入 |
 | 初始化对齐 / 升级后对齐 / reconcile 初始化 / loop-agent 初始化对齐 | 升级对齐 | 自动应用确定性安全动作；surface 缺失、人工决策、活跃 DAG/Worker 或 Worker 状态无法确认时零写入 |
@@ -127,7 +127,7 @@ agent-worker console serve --repo . --port 8790   # 兼容入口，等价于上
 
 live run 先用 `loop-agent dag status --run-id <run-id>` 看 lifecycle 与 liveness；用 `loop-agent dag report --run-id <run-id> --markdown` 读 facts；失败/paused 用 `loop-agent dag doctor --run-id <run-id> --markdown`。生命周期对齐先只读运行 `loop-agent dag reconcile-run --run-id <run-id>`；只有 runner 已停止且 operator 明确提供 `--action supersede|abandon --reason "..."` 时才允许变更。失败 run 用 `loop-agent dag closeout-draft --run-id <run-id>` 生成 failure handoff，不要写成成功 closeout。
 
-Runner heartbeat 只证明 lease；Provider/tool/output 活动才代表 meaningful progress，不得仅凭运行时长结束节点。恢复：status/doctor/report → classify → reconcile/replan → CLI 重跑 → shell verify。**禁止**把主会话直接 Edit 业务代码当作恢复手段。
+Operator 须持续监控 live run，直到 controller 报告 run 已结束（节点/流程终态如 `FINISHED`、`FAILED` 或 `partial_failed`），或 Decision Gate **需要 approve**；不要在节点仍运行时假定完成。判活须组合 runner heartbeat、session events 与 `dag doctor` liveness/provider meaningful progress；Runner heartbeat 只证明 lease，alone ≠ progress，不得仅凭运行时长结束节点。exclusive writer（如 `implement-pi` / `repair-pi`）运行期间：主会话与其他 writer **不得并发修改工作区**，以免 write-guard 错误归因；只读 status/doctor/report/observe 与 approve/reject/resume CLI 仍允许。恢复：status/doctor/report → classify → reconcile/replan → CLI 重跑 → shell verify。**禁止**把主会话直接 Edit 业务代码当作恢复手段。
 
 ### 运行态与验证
 

package/harness.json

@@ -59,7 +59,7 @@
     "pi": {
       "description": "Pi planning, review, diagnosis, and bounded writing when DAG toolProfile=write",
       "LOW": "minimax-m3",
-      "MED": {"model": "deepseek/deepseek-v4-flash","thinking": "max"},
+      "MED": "grok-4.5",
       "HIGH": "gpt-5.6-sol"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.26.3",
+  "version": "0.26.5-beta.0",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/loop-agent/references/orchestrator-and-interventions.md

@@ -15,7 +15,7 @@ main session 是 decision-maker 与 scheduler，**不是** implementer。稀缺
 ## 默认执行模型
 
 | Actor | 主角色 | 避免 |
-|---|---|---|
+| --- | --- | --- |
 | Main session (Operator Assist) | Objective、contract、**CLI 编排**、DAG review、routing、failure triage（doctor/reconcile）、approve/reject/resume、shell verify、handoff | 成为 coder；绕过 CLI 写业务树；失败后直接 Edit |
 | Agent DAG runner | 可恢复 multi-node orchestration、write policy、run artifacts | 不更新 DAG/source 的 ad-hoc replanning |
 | Cursor one-shot prompt | 显式有界诊断/介入；非默认 | 当 DAG executor、自动写入、无 path scope 宽写、失败默认恢复 |
@@ -48,7 +48,7 @@ sidecar intervention 是一次性 Pi 或 Cursor prompt，用于 unblock 主 work
 典型 routing：
 
 | 情况 | 使用 |
-|---|---|
+| --- | --- |
 | 需 quick root-cause analysis、plan critique、log 解读 | one-shot Pi prompt，read-only |
 | 需 codebase-indexed multi-file 诊断或 bounded patch | one-shot Cursor prompt |
 | 需确定性 evidence | shell command / shell DAG node |
@@ -94,14 +94,20 @@ P5 验证：future agent 可从 practice report + completed node artifacts 继
 main session 编排；不是默认 implementer。in-flight run 期间：
 
 | Action | 何时 | 记录位置 |
-|--------|------|----------|
+| -------- | ------ | ---------- |
 | Inspect status / node artifacts | 始终允许 | progress 或 sidecar output 中的 notes |
 | Sidecar read-only Pi/Cursor prompt | 诊断、plan critique、log 解读 | resume 前的 findings |
-| Surgical patch | small、obvious、可 verify；无 active `writeSet` 冲突 | `ai_workspace/loop-agent/reports/` 或 exec plan，含 scope + verification |
-| DAG/source repair | topology、writeSet 或 prompt contract 错误 | 编辑平台临时目录中的 DAG 或 plan；re-validate；rerun |
+| Surgical patch | **不适用于** exclusive writer（如 `implement-pi` / `repair-pi`）active 期间的工作区写；仅当无 active exclusive writer、变更极窄且可 verify 的治理元数据时才可考虑 | `ai_workspace/loop-agent/reports/` 或 exec plan，含 scope + verification |
+| DAG/source repair | topology、writeSet 或 prompt contract 错误；writer 非 active 时修正元数据 | 编辑平台临时目录中的 DAG 或 plan；re-validate；rerun |
 | Approve/reject/resume | Decision Gate `pause-on-human` | 仅 CLI artifacts |
 | Post-DAG closeout | promotion、report、plan archive、indexes | `promote-run`、`closeout task`、`ai_workspace/loop-agent/reports/`、`ai_workspace/loop-agent/progress`、exec-plan indexes — 非 root `artifacts/`，除非 explicit narrow writeSet |
 
+**Live-run 纪律（与目标项目 AGENTS managed block 同口径）**：
+
+- Operator 须持续监控 run，直到 controller 报告 run 已结束（节点/流程终态如 `FINISHED`、`FAILED` 或 `partial_failed`），或 Decision Gate **需要 approve**；不要在节点仍运行时假定完成。
+- 判活须组合 runner heartbeat、session events 与 `dag doctor` liveness/provider meaningful progress；Runner heartbeat 只证明 lease，alone ≠ progress。
+- exclusive writer 运行期间：主会话与其他 writer **不得并发修改工作区**，以免 write-guard 错误归因；只读 status/doctor/report/observe/console 与 approve/reject/resume CLI 仍允许。
+
 **Verdict 与 Decision Gate 提醒**（authoring guidance，非 runtime 变更）：
 
 - `shell.verdictGate` 后的 review/supervisor node：首条非空行须精确为 `VERDICT: pass` 或 `VERDICT: request-revision`（P2/P4）。
@@ -117,7 +123,7 @@ main session 编排；不是默认 implementer。in-flight run 期间：
 1. 变更不触及业务功能逻辑；通常是 task source、DAG JSON typo、doc index、或删除 scratch。
 2. 原因已知；不需要 broad system understanding。
 3. 不改变 product requirement 语义、architecture、public API、data model 或 cross-platform contract。
-4. 不与 active DAG exclusive `writeSet` 冲突。
+4. 不与 active DAG exclusive `writeSet` 冲突；且 exclusive writer 运行期间**一律禁止**主会话/其他 writer 并发改工作区（不仅是路径重叠判断），以免 write-guard 错误归因。
 5. 可立即 shell verify。
 6. 记录 scope + verification；且**下一步仍是 CLI re-validate / rerun**，不是「主会话继续实现」。
 
@@ -134,6 +140,7 @@ main session 编排；不是默认 implementer。in-flight run 期间：
 - 手工按计划实现功能或修测试失败。
 - 改 API/contract 语义或 refactor 子系统。
 - 编辑 in-flight exclusive DAG node 拥有的实现文件。
+- exclusive writer active 时主会话或其他 writer 并发修改工作区（即使自认无 writeSet 冲突）。
 - 用 `cursor-prompt` / 宿主 Write 代替 `implement-pi` / `repair-pi`。
 
 失败默认序列（替代旧 surgical-patch 心智）：