@tea-agent/loop-agent 0.17.1 → 0.17.2

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # 更新日志
 
+## [Unreleased]
+
+## [0.17.2] - 2026-07-22
+
+### 改进
+
+- Operator Console Happy Path 补齐：主导航（任务/恢复/模型与认证/设置）、newTask / importPrd、grill-me Interview（一次一问 + assessment）、SSE 运行跟随；Pi readiness 可刷新。
+- Operator Console 页面交互文案改为中文（导航、向导步骤、按钮与状态说明）；产品名与 CLI 命令仍保留英文术语。
+- Operator Console 界面与交互美化：暖色画布、胶囊导航、步骤进度条、统一按钮层级与状态条，运行面板元信息更清晰。
+- Operator Console Happy Path 增加「流程类型」选择（后端研发 / 前端研发 / 后端测试 / 前端测试），写入 `taskKind`；访谈枚举同步支持 `frontend-implementation` 与 `frontend-test`。
+- Console Happy Path 去掉单独的「创建任务」步骤：导入需求时根据 PRD 标题自动生成任务名称与 canonical taskId，并一键创建任务 + import-prd。
+- Operator Console 需求访谈可跳过：一键按 grill-me 推荐补齐草稿并签发评估，可直接进入契约校验。
+- Operator Console 将「校验契约 / 应用契约 / Spine 审计」合并为「契约落地」：自动确定性校验与差异，人工确认一次应用，成功后自动 Spine。
+- Observe 运行看板视觉对齐 Console：暖色渐变画布、胶囊导航、柔和面板阴影与状态点，减少高饱和色块；进一步统一 badge/表格/风险块/时间线/DAG 图与 inspector、对象关系条与推荐命令等视图组件。
+
+### 修复
+
+- Console Draft 在 validate/diff/apply 前会投影为 CLI 严格 schema：补齐 `constraints.invariants`，并去掉仅 Console 使用的 `updatedAt`，避免误报 draft schema validation failed。
+- 修复访谈完成后绑定 `interviewAssessmentRef` 会立刻让 assessment 过期的问题：`draftSha256` 不再纳入该绑定字段；finalize 时先清空 `openQuestions` 再签发 assessment。
+- 修复 Console `contractApply` 默认传入 `expectedObservedHash=unknown` 导致 OBSERVED_HASH_CONFLICT / 页面只见 `exit 1`：改为先 `task contract show` 再传真实 revision/hash；异步操作失败时展示 CLI 错误信息。
+- 修复应用契约后界面卡住：轮询操作结果时误读 `{ ok, operation }` 响应，一直等到超时且无法进入 Spine。
+- 修复 DAG 确认准备失败：不再提交空 stub DAG；`prepareDagConfirmation` 会经 `dag run-task` 生成真实 DAG；`dag validate` 接受 `--json` 兼容 Console。
+- 修复 Console `runDag` 因 `run-dag --json` 未识别而失败：CLI 现接受该旗标（输出本就为 JSON）。
+- 运行 DAG 不再用短超时阻塞整页：`runDag` 改为后台接受 + SSE 跟随；Observe 按钮与任务 busy 解耦，运行中可打开。
+- Console 打开 Observe 时，若只给 taskId，会解析该任务最新 DAG run 并跳转 `#/dag/<runId>`，不再误开 `#/task/<taskId>`。
+
 ## [0.17.1] - 2026-07-22
 
 ### 修复
@@ -42,6 +68,7 @@
   - Console 与 Observe 仍为独立进程；不 mount、不 proxy、不复制第二套 read model。
 - Phase 1 Console skeleton：`agent-worker console serve|doctor`（默认 loopback `127.0.0.1:8790`、非 loopback fail-closed）、Vite SPA 静态产物 + Node health/static server、boot capability cookie + mutation Host/Origin 门禁、封闭 ResourceLoader 骨架、sibling `loop-agent` identity doctor、`repoFingerprintV1` / Observe 深链 builder、以及 `UPSTREAM.md`（pi-web 源 commit）与预算 report。
 - Phase 0.5 operator surface repair：`buildOperatorCapabilitiesDocument()` 在权威 `src/shared/operator` 上补齐 Console 协商块 `dag`（`generatedSpecVersion: 4`、`requiresTaskContractBinding: true`，与 `dagSpecVersions` 同源常量），并删除冲突的 `src/task/operator` 双实现；CLI `--json` 继续写 `process.stdout`，测试侧改为捕获 stdout。
+- Nightly 自动发布改为双基线：`lastTag`（最新稳定 `vX.Y.Z`）只负责未发布增量、breaking 检测与 release notes；当前 minor 的 `vX.Y.0`（缺失则回退 `lastTag`）只累计严格 Conventional Commit `feat:` 以决定 minor/patch。手动 patch 不再抹掉同 minor 周期的 feature 信号；历史 minor 窗口中的 breaking 不再永久阻断后续自动发布。`Publish npm` 手动入口未改。
 
 - `frontend-implementation` 绿色路径由固定全链改为按需分支：删除重复的首轮 design shell gate，初审通过直接复用原计划，只有 `request-revision` 才执行计划修订与终审；只有可修复失败才执行 repair/reverify/retrace。常规全绿路径因此少执行 3 个 Pi 与 4 个 shell 节点，同时保留 pass-only 写入门禁、验证/评审证据和只读 `frontend-closeout-pi`。原计划/修订计划的结构化合同与需求覆盖使用同一有效来源，且只有主分支产物缺失时才回退；已存在但 malformed/schema-invalid 的产物继续 fail-closed。
 - Observe 节点检查器“规范证据”页签新增安全文件预览：已绑定任务源和已读取规范文件条目现以可聚焦按钮呈现，点击后在检查器内下钻查看内容（不新增弹窗），提供“返回规范证据”按钮并恢复触发行焦点。新增只读接口 `GET /api/dag-runs/:runId/nodes/:nodeId/spec-evidence/file?source=binding|read&path=...`，服务端重新校验证据成员身份（binding 必须在 `sourceBinding.sources`，read 必须有成功配对 read），拒 `..`/绝对/目录/二进制/仓库外符号链接；正文上限 64KB 并返回截断标志，统一走 Observe 脱敏规则；binding 返回 `sha256`/`currentSha256`/`hashMatch`，read 返回 session event 中实际读取正文与 `readAt`（不以当前工作区文件替代）。
@@ -65,6 +92,8 @@
 ### 修复
 
 - Windows DAG Shell/verification 的 clean environment 现在保留 `APPDATA`，使 Python 3.12/pip 可按系统规则发现用户级 `site-packages` 与其中的 pytest；仍不会继承完整宿主环境或透传未授权 token/credential，backend-test 无需硬编码用户路径。
+- Observe 节点检查器的“规范证据”现在会按任务目录解析 `sourceBinding` 中的相对路径，`source/需求.md` 等已绑定文件可正常打开；路径成员校验、目录穿越、绝对路径、二进制文件和符号链接逃逸防护保持不变。
+- Decision Gate 的 Pi 执行指令不再与输出合同冲突：启用 `decisionGate` 的只读节点会明确输出唯一的 `DECISION_ENVELOPE_JSON` fenced block，普通只读节点仍保持原有无代码围栏约束，严格解析规则不放宽。
 
 - Backend-test Analysis v2 intake 现在可确定性归一化模型常见的外部依赖 `type` / `target` 与风险 `type` 字段：dependency `target` 映射为 canonical `name`，扩展字段不落盘；dependency/risk 仍使用类别化白名单，未知字段和 `risks[].target` 继续 fail-closed，避免节点 02 因合法近似形态过早中断。
 

package/dist/application/dag/args.js

@@ -155,7 +155,7 @@ function parseDagRunTaskProfile(value) {
 }
 export function parseDagValidateArgs(args) {
     if (args.length === 0) {
-        throw new Error("usage: dag validate --dag <path> [--strict-models] [--strict-governance]");
+        throw new Error("usage: dag validate --dag <path> [--strict-models] [--strict-governance] [--json]");
     }
     let dagPath;
     let strictModelMatrix = false;
@@ -191,6 +191,10 @@ export function parseDagValidateArgs(args) {
             strictSkills = true;
             continue;
         }
+        if (arg === "--json") {
+            // Accepted for operator/console callers; validate always emits JSON stdout.
+            continue;
+        }
         if (arg === "--forbid-executor") {
             const executor = args[++i];
             if (!executor) {
@@ -243,7 +247,7 @@ export function parseDagValidateArgs(args) {
 }
 export function parseRunDagArgs(args, defaultCwd) {
     if (args.length === 0) {
-        throw new Error("usage: run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>]");
+        throw new Error("usage: run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--json]");
     }
     let dagPath;
     let cwd;
@@ -305,6 +309,9 @@ export function parseRunDagArgs(args, defaultCwd) {
         else if (arg.startsWith("--events-jsonl=")) {
             eventsJsonlPath = arg.slice("--events-jsonl=".length);
         }
+        else if (arg === "--json") {
+            // Accepted for operator/console callers; run-dag always emits JSON stdout.
+        }
         else if (!arg.startsWith("-")) {
             if (!dagPath)
                 dagPath = arg;

package/dist/executors/dag-pi-executor.js

@@ -140,6 +140,17 @@ export function buildDagPiUserMessage(task, persona, step) {
             "Do not wrap the output in code fences and do not add conversational preamble.",
         ].join(" ");
     }
+    // Decision Gate nodes must emit a mandatory DECISION_ENVELOPE_JSON fenced block;
+    // do not inject the global no-fence instruction that would conflict with outputContract.
+    if (task.decisionGate?.enabled === true) {
+        return [
+            `You are executing hybrid DAG node "${task.id}" (role=${role}, piPersona=${persona}, piStep=${step}, writePolicy=${writePolicy}).`,
+            "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",
+            "Use read-only tools only. Do not edit, write, or commit repository files.",
+            "Return your conclusion as Markdown that includes exactly one ```DECISION_ENVELOPE_JSON fenced block (info string DECISION_ENVELOPE_JSON, not json) matching the Decision Envelope schema, plus a short evidence/risk summary.",
+            "Follow the node outputContract for the mandatory fenced block. Do not add conversational preamble outside the required Markdown structure.",
+        ].join(" ");
+    }
     return [
         `You are executing hybrid DAG node "${task.id}" (role=${role}, piPersona=${persona}, piStep=${step}, writePolicy=${writePolicy}).`,
         "The system prompt contains the full DAG envelope: objective, constraints, upstream context, and task.",

package/dist/worker/console/draft-store.js

@@ -5,11 +5,89 @@ function draftPath(appData, taskId) {
     return path.join(appData.drafts, `${safe}.json`);
 }
 export function computeDraftSha256(draft) {
-    // Hash a stable projection excluding updatedAt so pure timestamp churn
-    // does not invalidate assessments — still any field change does.
-    const { updatedAt: _u, ...rest } = draft;
+    // Hash a stable projection excluding bookkeeping fields so binding a
+    // fresh assessment (interviewAssessmentRef) or timestamp churn does not
+    // invalidate the assessment that just certified this Draft content.
+    const { updatedAt: _u, interviewAssessmentRef: _ref, ...rest } = draft;
     return sha256Json(rest);
 }
+function asStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (typeof item === "string")
+            return item.trim();
+        if (item && typeof item === "object") {
+            try {
+                return JSON.stringify(item);
+            }
+            catch {
+                return String(item);
+            }
+        }
+        return String(item ?? "").trim();
+    })
+        .filter(Boolean);
+}
+/**
+ * Project Console application-data Draft into the strict CLI
+ * `taskContractDraftSchema` shape (no updatedAt; invariants required).
+ */
+export function toCanonicalDraftForCli(draft) {
+    const requirement = draft.requirement ?? {};
+    const constraints = draft.constraints ?? {};
+    const verification = draft.verification ?? {};
+    const canonical = {
+        schemaVersion: 1,
+        taskId: draft.taskId,
+        title: draft.title?.trim() || draft.taskId,
+        taskKind: draft.taskKind?.trim() || "standard",
+        requirement: {
+            objective: (requirement.objective ?? "").trim() || draft.title || draft.taskId,
+            scope: Array.isArray(requirement.scope) ? requirement.scope : [],
+            nonGoals: Array.isArray(requirement.nonGoals) ? requirement.nonGoals : [],
+            acceptanceCriteria: Array.isArray(requirement.acceptanceCriteria)
+                ? requirement.acceptanceCriteria
+                : [],
+        },
+        constraints: {
+            invariants: Array.isArray(constraints.invariants)
+                ? constraints.invariants
+                : [],
+            allowedPaths: Array.isArray(constraints.allowedPaths)
+                ? constraints.allowedPaths
+                : [],
+            forbiddenPaths: Array.isArray(constraints.forbiddenPaths)
+                ? constraints.forbiddenPaths
+                : [],
+        },
+        verification: {
+            commands: Array.isArray(verification.commands)
+                ? verification.commands
+                : [],
+        },
+    };
+    if (draft.featureId?.trim())
+        canonical.featureId = draft.featureId.trim();
+    if (Array.isArray(draft.references) && draft.references.length > 0) {
+        canonical.references = draft.references;
+    }
+    if (Array.isArray(draft.sourceResolutions) &&
+        draft.sourceResolutions.length > 0) {
+        canonical.sourceResolutions = draft.sourceResolutions;
+    }
+    const openQuestions = asStringList(draft.openQuestions);
+    if (openQuestions.length > 0)
+        canonical.openQuestions = openQuestions;
+    const assumptions = asStringList(draft.assumptions);
+    if (assumptions.length > 0)
+        canonical.assumptions = assumptions;
+    if (draft.interviewAssessmentRef) {
+        canonical.interviewAssessmentRef = draft.interviewAssessmentRef;
+    }
+    return canonical;
+}
 export class DraftStore {
     appData;
     constructor(appData) {

package/dist/worker/console/interview/grill-me.js

@@ -0,0 +1,253 @@
+/**
+ * Deterministic grill-me Requirement Interview engine (design §7.8).
+ * One open question at a time; Draft updates from answers; integrity
+ * assessment when required fields are present.
+ */
+import { consoleWorkflowKindPromptList, normalizeConsoleWorkflowKind, } from "../workflow-kinds.js";
+const GAP_ORDER = [
+    "objective",
+    "scope",
+    "nonGoals",
+    "acceptanceCriteria",
+    "taskKind",
+    "allowedPaths",
+    "forbiddenPaths",
+    "verifyCommands",
+];
+function hasText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hasItems(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+export function listDraftGaps(draft) {
+    const gaps = [];
+    const req = draft.requirement ?? {};
+    if (!hasText(req.objective))
+        gaps.push("objective");
+    if (!hasItems(req.scope))
+        gaps.push("scope");
+    if (!hasItems(req.nonGoals))
+        gaps.push("nonGoals");
+    if (!hasItems(req.acceptanceCriteria))
+        gaps.push("acceptanceCriteria");
+    if (!hasText(draft.taskKind))
+        gaps.push("taskKind");
+    if (!hasItems(draft.constraints?.allowedPaths))
+        gaps.push("allowedPaths");
+    if (!hasItems(draft.constraints?.forbiddenPaths))
+        gaps.push("forbiddenPaths");
+    if (!hasItems(draft.verification?.commands))
+        gaps.push("verifyCommands");
+    return gaps;
+}
+export function isDraftStructurallyComplete(draft) {
+    return listDraftGaps(draft).length === 0;
+}
+export function buildQuestionForGap(gapId, draft) {
+    const taskId = draft.taskId;
+    const questions = {
+        objective: {
+            id: `q-${gapId}`,
+            gapId,
+            text: `任务 ${taskId} 的核心目标（objective）是什么？请用一句话说明要交付什么。`,
+            recommendation: `实现并验证 ${taskId} 的明确、可验收交付物`,
+            affectsFields: ["requirement.objective"],
+            risk: "high",
+        },
+        scope: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "本轮允许改动的范围（scope）是哪些路径/模块？用逗号或换行列出。",
+            recommendation: "src/worker/console/**",
+            affectsFields: ["requirement.scope"],
+            risk: "high",
+        },
+        nonGoals: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "明确非目标（non-goals）是什么？本轮刻意不做哪些事？",
+            recommendation: "Phase 4 General Operator Chat；合并 Console/Observe",
+            affectsFields: ["requirement.nonGoals"],
+            risk: "medium",
+        },
+        acceptanceCriteria: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "验收标准有哪些？可用分号或换行列出（将编号为 AC-1…）。",
+            recommendation: "Happy Path 可走通 Interview→validate→apply；无 Cancel；无直接改代码 CTA",
+            affectsFields: ["requirement.acceptanceCriteria"],
+            risk: "high",
+        },
+        taskKind: {
+            id: `q-${gapId}`,
+            gapId,
+            text: `流程类型（taskKind）应设为？(${consoleWorkflowKindPromptList()})`,
+            recommendation: "standard",
+            affectsFields: ["taskKind"],
+            risk: "medium",
+        },
+        allowedPaths: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "结构化 allowedPaths（写入白名单）？逗号/换行分隔 glob。",
+            recommendation: "src/worker/console/**, test/worker/console/**",
+            affectsFields: ["constraints.allowedPaths"],
+            risk: "high",
+        },
+        forbiddenPaths: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "forbiddenPaths（禁止写入）？逗号/换行分隔。",
+            recommendation: "src/cli/**, bin/**, package.json",
+            affectsFields: ["constraints.forbiddenPaths"],
+            risk: "high",
+        },
+        verifyCommands: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "验证命令（verifyCommands）？可给一条或多条 shell（换行分隔）。",
+            recommendation: "npx vitest run test/worker/console",
+            affectsFields: ["verification.commands"],
+            risk: "medium",
+        },
+    };
+    return questions[gapId];
+}
+export function nextGrillMeQuestion(draft) {
+    const gaps = listDraftGaps(draft);
+    for (const gapId of GAP_ORDER) {
+        if (gaps.includes(gapId))
+            return buildQuestionForGap(gapId, draft);
+    }
+    return undefined;
+}
+function splitList(text) {
+    return text
+        .split(/[\n,;，；]+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function resolveAnswerText(response, recommendation, text) {
+    if (response === "accept-recommendation")
+        return recommendation;
+    if (response === "defer")
+        return text?.trim() || recommendation;
+    return (text ?? "").trim() || recommendation;
+}
+/**
+ * Apply one grill-me answer onto Draft. Returns updated draft (immutable merge).
+ */
+export function applyGrillMeAnswer(draft, question, answer) {
+    const value = resolveAnswerText(answer.response, question.recommendation, answer.text);
+    const next = {
+        ...draft,
+        requirement: { ...draft.requirement },
+        constraints: {
+            invariants: draft.constraints?.invariants ?? [],
+            allowedPaths: draft.constraints?.allowedPaths ?? [],
+            forbiddenPaths: draft.constraints?.forbiddenPaths ?? [],
+            ...draft.constraints,
+        },
+        verification: {
+            commands: draft.verification?.commands ?? [],
+            ...draft.verification,
+        },
+    };
+    switch (question.gapId) {
+        case "objective":
+            next.requirement = { ...next.requirement, objective: value };
+            break;
+        case "scope":
+            next.requirement = { ...next.requirement, scope: splitList(value) };
+            break;
+        case "nonGoals":
+            next.requirement = { ...next.requirement, nonGoals: splitList(value) };
+            break;
+        case "acceptanceCriteria":
+            next.requirement = {
+                ...next.requirement,
+                acceptanceCriteria: splitList(value).map((text, i) => ({
+                    id: `AC-${i + 1}`,
+                    text,
+                })),
+            };
+            break;
+        case "taskKind":
+            next.taskKind = normalizeConsoleWorkflowKind(value, "standard");
+            break;
+        case "allowedPaths":
+            next.constraints = {
+                ...next.constraints,
+                allowedPaths: splitList(value),
+            };
+            break;
+        case "forbiddenPaths":
+            next.constraints = {
+                ...next.constraints,
+                forbiddenPaths: splitList(value),
+            };
+            break;
+        case "verifyCommands":
+            next.verification = {
+                ...next.verification,
+                commands: splitList(value).map((command, i) => ({
+                    label: `verify-${i + 1}`,
+                    command,
+                    timeoutMs: 120_000,
+                })),
+            };
+            break;
+    }
+    if (answer.response === "defer" && question.risk !== "high") {
+        const assumptions = Array.isArray(draft.assumptions)
+            ? [...draft.assumptions]
+            : [];
+        assumptions.push({
+            questionId: question.id,
+            gapId: question.gapId,
+            assumed: value,
+            at: new Date().toISOString(),
+        });
+        next.assumptions = assumptions;
+    }
+    return next;
+}
+export function emptyDraft(taskId, title, options) {
+    const taskKind = options?.taskKind?.trim()
+        ? normalizeConsoleWorkflowKind(options.taskKind, "standard")
+        : undefined;
+    return {
+        schemaVersion: 1,
+        taskId,
+        title: title?.trim() || taskId,
+        taskKind,
+        requirement: {},
+        constraints: {
+            invariants: [],
+            allowedPaths: [],
+            forbiddenPaths: [],
+        },
+        verification: {
+            commands: [],
+        },
+        openQuestions: [],
+        assumptions: [],
+    };
+}
+export function draftSummary(draft) {
+    return {
+        taskId: draft.taskId,
+        title: draft.title,
+        taskKind: draft.taskKind ?? null,
+        objective: draft.requirement?.objective ?? null,
+        scope: draft.requirement?.scope ?? [],
+        nonGoals: draft.requirement?.nonGoals ?? [],
+        acceptanceCriteria: draft.requirement?.acceptanceCriteria ?? [],
+        allowedPaths: draft.constraints?.allowedPaths ?? [],
+        forbiddenPaths: draft.constraints?.forbiddenPaths ?? [],
+        verifyCommands: draft.verification?.commands ?? [],
+        gaps: listDraftGaps(draft),
+        structurallyComplete: isDraftStructurallyComplete(draft),
+    };
+}

package/dist/worker/console/operation-runner.js

@@ -128,7 +128,8 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
         errorMessage: ok
             ? undefined
             : (envelope?.error?.message ??
-                `command failed with exit ${result.exitCode}`),
+                (previewStderr.trim() ||
+                    `command failed with exit ${result.exitCode}`)),
     });
     stateEvent(deps.events, updated, state);
     deps.events.append(operationId, {