@tea-agent/loop-agent 0.34.1 → 0.34.3

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [0.34.3] - 2026-08-12
+
+### 重点更新
+
+- 修复 PRD 导入时 grill-me 模板占位符路径污染写入集的问题，确保仅处理真实需求路径
+
+### 改进
+
+- 语义化导入现可作为兜底方案推荐工程边界，提升需求解析的准确性
+- 将语义约束与验证信息合并至控制台草稿，避免表单默认值覆盖精确的验证命令
+
+### 修复
+
+- 修复 grill-me 模板占位符路径未被过滤即进入写入集，导致占位内容污染实际工程数据的问题
+
+## [0.34.2] - 2026-08-12
+
+### 重点更新
+
+- 修复控制台 DAG 执行在 120 秒后被强制终止导致状态卡死的问题，默认超时现提升至 4 小时
+
+### 改进
+
+- DAG 挂钟时间常量统一收敛至 src/shared 共享模块管理，移除了 workflows 中不必要的内核导入
+
+### 修复
+
+- 修复控制台任务导航执行 DAG 时因 LoopAgentClient 默认 120 秒超时被强制终止的问题，现已将默认超时提升至 4 小时，并支持通过 --default-timeout-ms 参数覆盖
+- 修正自定义模型合并报告中的文档描述错误
+
 ## [0.34.1] - 2026-08-11
 
 ### 重点更新

package/dist/application/task-lifecycle/advance.js

@@ -4,6 +4,7 @@ import { createTask, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js
 import { importPrdDocument } from "../../task/source-references.js";
 import { prepareTaskSource } from "../../task/source-prepare/index.js";
 import { isIntakeSoftGapCode, resolvePrdImportRole, } from "../../task/source-prepare/artifact-meta.js";
+import { sanitizeDraftPlaceholders } from "../../task/source-prepare/placeholder-paths.js";
 import { evaluateSemanticIntakeEligibility, isSemanticIntakeDisabled, readSemanticIntakeAttempted, runSemanticIntake, } from "../../task/source-prepare/semantic-intake.js";
 import { validateImportedPrdReferences } from "../../task/source-prepare/reference-integrity.js";
 import { logicalRevisionForState, observeTaskContractState, recoverTaskContract, } from "../../task/contract/index.js";
@@ -587,9 +588,12 @@ export async function advanceTaskLifecycle(input) {
             if (input.fromDraftPath) {
                 try {
                     const draftRaw = await readFile(path.resolve(input.fromDraftPath), "utf-8");
+                    const parsedDraft = JSON.parse(draftRaw);
+                    // Strip Console grill-me placeholder strings so they never become
+                    // writeSet globs / projected 需求.md bullets.
                     draftIntent = {
                         kind: "draft",
-                        draft: JSON.parse(draftRaw),
+                        draft: sanitizeDraftPlaceholders(parsedDraft),
                         sourcePath: input.fromDraftPath,
                     };
                 }

package/dist/shared/timeout-policy.js

@@ -1,5 +1,10 @@
 import { DEFAULT_TIMEOUT_MS, MAX_ALLOWED_TIMEOUT_MS } from "../executors/pi-executor.js";
 export { MAX_ALLOWED_TIMEOUT_MS };
+/**
+ * DAG runner 绝对最大墙钟（4h）。不可被空心跳续期；
+ * 是 DEFAULT_LIVENESS_POLICY 与 Console LoopAgentClient 默认超时的单一真源。
+ */
+export const DAG_ABSOLUTE_MAX_WALL_CLOCK_MS = 14_400_000;
 /**
  * Clamp timeout values for Pi steps. Undefined or non-positive values fall back to
  * DEFAULT_TIMEOUT_MS so task-level invalid values do not disable Pi execution timeouts.

package/dist/task/source-prepare/index.js

@@ -2,6 +2,7 @@ export * from "./types.js";
 export * from "./path-policy.js";
 export * from "./parse-intent.js";
 export * from "./artifact-meta.js";
+export * from "./placeholder-paths.js";
 export * from "./semantic-intake.js";
 export * from "./reference-integrity.js";
 export * from "./completeness.js";

package/dist/task/source-prepare/placeholder-paths.js

@@ -0,0 +1,77 @@
+/**
+ * Shared filters for Console / grill-me placeholder text that must never
+ * become writeSet paths or contract scope bullets.
+ *
+ * Placeholders are Chinese cue-words + fullwidth brackets from interview
+ * recommendations (e.g. "（工程边界须人类确认；示例：src/**, test/**）").
+ * Do not require glob syntax — legitimate paths like `package.json` must pass.
+ */
+export const PLACEHOLDER_PATH_RE = /请|示例|模板|（|）|须人类确认|勿套用|暂无|填写|确认|按.*结构/;
+export function isNonPlaceholderPath(value) {
+    return (typeof value === "string" &&
+        value.trim().length > 0 &&
+        !PLACEHOLDER_PATH_RE.test(value));
+}
+export function filterPlaceholderPaths(values) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .map((item) => (typeof item === "string" ? item.trim() : ""))
+        .filter(isNonPlaceholderPath);
+}
+function isPlaceholderText(value) {
+    return typeof value === "string" && PLACEHOLDER_PATH_RE.test(value);
+}
+/**
+ * Strip grill-me / form placeholder strings from a draft before prepare.
+ * Keeps real defaults like `npm run typecheck` and `.harness/**`.
+ */
+export function sanitizeDraftPlaceholders(draft) {
+    if (!draft || typeof draft !== "object")
+        return draft;
+    const root = draft;
+    const next = { ...root };
+    if (root.constraints && typeof root.constraints === "object") {
+        const constraints = root.constraints;
+        next.constraints = {
+            ...constraints,
+            allowedPaths: filterPlaceholderPaths(constraints.allowedPaths),
+            forbiddenPaths: filterPlaceholderPaths(constraints.forbiddenPaths),
+        };
+    }
+    if (root.requirement && typeof root.requirement === "object") {
+        const requirement = root.requirement;
+        let scope = requirement.scope;
+        if (Array.isArray(requirement.scope)) {
+            scope = requirement.scope
+                .map((item) => (typeof item === "string" ? item.trim() : ""))
+                .filter((item) => item.length > 0 && !isPlaceholderText(item));
+        }
+        let nonGoals = requirement.nonGoals;
+        if (Array.isArray(requirement.nonGoals)) {
+            nonGoals = requirement.nonGoals
+                .map((item) => (typeof item === "string" ? item.trim() : ""))
+                .filter((item) => item.length > 0 && !isPlaceholderText(item));
+        }
+        let acceptanceCriteria = requirement.acceptanceCriteria;
+        if (Array.isArray(requirement.acceptanceCriteria)) {
+            acceptanceCriteria = requirement.acceptanceCriteria.filter((item) => {
+                if (typeof item === "string") {
+                    return item.trim().length > 0 && !isPlaceholderText(item);
+                }
+                if (item && typeof item === "object") {
+                    const text = item.text;
+                    return typeof text === "string" && !isPlaceholderText(text);
+                }
+                return true;
+            });
+        }
+        next.requirement = {
+            ...requirement,
+            scope,
+            nonGoals,
+            acceptanceCriteria,
+        };
+    }
+    return next;
+}

package/dist/task/source-prepare/semantic-intake.js

@@ -1,10 +1,13 @@
 /**
  * P2 Semantic Intake: one-shot, read-only Pi structuring of imported PRDs
  * into TaskContractDraftV1. Does not write source/需求.md directly — caller
- * re-enters prepare with kind:"draft". Engineering paths/verify never come
- * from the model; only from flags / existing task config.
+ * re-enters prepare with kind:"draft".
+ *
+ * Engineering boundary priority: explicit flags > existing task config >
+ * optional model recommendation (repo-layout-aware fallback for Console
+ * web-wizard flows that never collect human paths).
  */
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { executePiStep } from "../../executors/pi-executor.js";
@@ -14,6 +17,7 @@ import { loadHarnessManifest } from "../../governance/harness.js";
 import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
 import { getTaskPaths } from "../runtime.js";
 import { detectProductArtifactMeta } from "./artifact-meta.js";
+import { filterPlaceholderPaths } from "./placeholder-paths.js";
 export const SEMANTIC_INTAKE_ARTIFACT_REL = "artifacts/intake/semantic-draft.json";
 export const SEMANTIC_INTAKE_ATTEMPT_MARKER = "artifacts/intake/semantic-intake-attempted.json";
 const productArtifactBlockers = new Set([
@@ -22,6 +26,20 @@ const productArtifactBlockers = new Set([
     "PRODUCT_REQUIREMENT_PENDING",
     "PRODUCT_ARTIFACT_NOT_EXECUTABLE",
 ]);
+const engineeringRecommendationSchema = z
+    .object({
+    taskKind: z.string().min(1).optional(),
+    allowedPaths: z.array(z.string()).optional(),
+    forbiddenPaths: z.array(z.string()).optional(),
+    verifyCommands: z
+        .array(z.object({
+        label: z.string().min(1),
+        command: z.string().min(1),
+        timeoutMs: z.number().int().positive().optional(),
+    }))
+        .optional(),
+})
+    .optional();
 const requirementDraftSchema = z.object({
     objective: z.string().min(1),
     scope: z.array(z.string()).default([]),
@@ -39,6 +57,8 @@ const requirementDraftSchema = z.object({
     openQuestions: z.array(z.string()).optional(),
     assumptions: z.array(z.string()).optional(),
     title: z.string().optional(),
+    /** Optional model engineering recommendation (flags/existing still win). */
+    engineering: engineeringRecommendationSchema,
 });
 export function isSemanticIntakeDisabled(env = process.env) {
     const raw = (env.LOOP_AGENT_SEMANTIC_INTAKE ?? "").trim().toLowerCase();
@@ -130,26 +150,62 @@ export function assertSemanticDraftAcceptable(draft) {
     }
 }
 export function buildDraftFromSemanticIntake(input) {
-    const allowedPaths = input.flags.allowedPaths?.length
-        ? [
-            ...(input.existingAllowedPaths ?? []),
-            ...input.flags.allowedPaths,
-        ]
-        : (input.existingAllowedPaths ?? input.flags.allowedPaths ?? []);
-    const forbiddenPaths = input.flags.forbiddenPaths?.length
-        ? [
-            ...(input.existingForbiddenPaths ?? []),
-            ...input.flags.forbiddenPaths,
-        ]
-        : (input.existingForbiddenPaths ?? input.flags.forbiddenPaths ?? []);
-    const verifyCommands = input.flags.verifyCommands?.length
-        ? input.flags.verifyCommands
-        : (input.existingVerify ?? []);
+    const modelEng = input.semantic.engineering ?? {};
+    const modelAllowed = filterPlaceholderPaths(modelEng.allowedPaths);
+    const modelForbidden = filterPlaceholderPaths(modelEng.forbiddenPaths);
+    const modelVerify = (modelEng.verifyCommands ?? []).filter((c) => c.label?.trim() && c.command?.trim());
+    // Priority: explicit flags > existing task config > model recommendation.
+    const flagAllowed = input.flags.allowedPaths ?? [];
+    const existingAllowed = input.existingAllowedPaths ?? [];
+    let allowedPaths;
+    if (flagAllowed.length > 0) {
+        allowedPaths = [...existingAllowed, ...flagAllowed];
+    }
+    else if (existingAllowed.length > 0) {
+        allowedPaths = existingAllowed;
+    }
+    else {
+        allowedPaths = modelAllowed;
+    }
+    const flagForbidden = input.flags.forbiddenPaths ?? [];
+    const existingForbidden = input.existingForbiddenPaths ?? [];
+    let forbiddenPaths;
+    if (flagForbidden.length > 0) {
+        forbiddenPaths = [...existingForbidden, ...flagForbidden];
+    }
+    else if (existingForbidden.length > 0) {
+        forbiddenPaths = existingForbidden;
+    }
+    else {
+        forbiddenPaths = modelForbidden;
+    }
+    let verifyCommands;
+    if (input.flags.verifyCommands?.length) {
+        verifyCommands = input.flags.verifyCommands;
+    }
+    else if (input.existingVerify?.length) {
+        verifyCommands = input.existingVerify;
+    }
+    else {
+        verifyCommands = modelVerify;
+    }
+    // flags.taskKind is hard; bare caller "standard" is a soft default and must
+    // not block a model recommendation for Console web-wizard flows.
+    const explicitTaskKind = input.flags.taskKind?.trim();
+    const callerTaskKind = input.taskKind?.trim();
+    const modelTaskKind = modelEng.taskKind?.trim();
+    const taskKind = explicitTaskKind ||
+        (callerTaskKind && callerTaskKind !== "standard"
+            ? callerTaskKind
+            : undefined) ||
+        modelTaskKind ||
+        callerTaskKind ||
+        "standard";
     const draft = {
         schemaVersion: TASK_CONTRACT_DRAFT_SCHEMA_VERSION,
         taskId: input.taskId,
         title: input.semantic.title?.trim() || input.title,
-        taskKind: input.flags.taskKind || input.taskKind || "standard",
+        taskKind,
         requirement: {
             objective: input.semantic.objective.trim(),
             scope: input.semantic.scope.map((s) => s.trim()).filter(Boolean),
@@ -161,7 +217,9 @@ export function buildDraftFromSemanticIntake(input) {
         },
         constraints: {
             invariants: input.flags.invariants ?? [],
-            allowedPaths: [...new Set(allowedPaths.map((p) => p.trim()).filter(Boolean))],
+            allowedPaths: [
+                ...new Set(allowedPaths.map((p) => p.trim()).filter(Boolean)),
+            ],
             forbiddenPaths: [
                 ...new Set(forbiddenPaths.map((p) => p.trim()).filter(Boolean)),
             ],
@@ -192,7 +250,96 @@ export function buildDraftFromSemanticIntake(input) {
     }
     return draft;
 }
-function buildPrompt(input) {
+/**
+ * Cheap repo-layout hint injected into the semantic intake prompt so the model
+ * can recommend minimal write boundaries and real verify commands when humans
+ * never fill Console form engineering fields.
+ */
+export async function buildRepoHint(repoRoot) {
+    const lines = ["Repo layout hint (best-effort, may be incomplete):"];
+    try {
+        const top = await readdir(repoRoot, { withFileTypes: true });
+        const dirs = top
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map((entry) => entry.name)
+            .slice(0, 24);
+        const files = top
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name)
+            .slice(0, 24);
+        lines.push(`top-level dirs: ${dirs.join(", ") || "(none)"}`);
+        lines.push(`top-level files: ${files.join(", ") || "(none)"}`);
+        const packageCandidates = [
+            "package.json",
+            path.join("source", "package.json"),
+            path.join("packages", "package.json"),
+        ];
+        for (const rel of packageCandidates) {
+            const abs = path.join(repoRoot, rel);
+            try {
+                const raw = await readFile(abs, "utf-8");
+                const pkg = JSON.parse(raw);
+                const scripts = Object.keys(pkg.scripts ?? {}).slice(0, 20);
+                lines.push(`${rel} scripts: ${scripts.join(", ") || "(none)"}`);
+                if (pkg.workspaces !== undefined) {
+                    lines.push(`${rel} workspaces: ${JSON.stringify(pkg.workspaces).slice(0, 200)}`);
+                }
+            }
+            catch {
+                // optional
+            }
+        }
+        // Sample test-like files under common roots (bounded).
+        const testRoots = ["src", "source", "packages", "test", "tests"].filter((name) => dirs.includes(name));
+        const samples = [];
+        const counts = new Map();
+        const walk = async (dir, depth) => {
+            if (depth > 3 || samples.length >= 15)
+                return;
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith(".") || entry.name === "node_modules")
+                    continue;
+                const abs = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await walk(abs, depth + 1);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                if (!/\.(test|spec)\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(entry.name))
+                    continue;
+                const rel = path.relative(repoRoot, abs).replace(/\\/g, "/");
+                const top = rel.split("/")[0] ?? rel;
+                counts.set(top, (counts.get(top) ?? 0) + 1);
+                if (samples.length < 15)
+                    samples.push(rel);
+            }
+        };
+        for (const root of testRoots) {
+            await walk(path.join(repoRoot, root), 0);
+        }
+        const total = [...counts.values()].reduce((sum, n) => sum + n, 0);
+        if (total > 0) {
+            const byTop = [...counts.entries()]
+                .map(([name, n]) => `${name}:${n}`)
+                .join(", ");
+            lines.push(`test-like files: total=${total} byTop=${byTop}`);
+            lines.push(`test samples: ${samples.join(", ")}`);
+        }
+    }
+    catch {
+        lines.push("(repo scan failed)");
+    }
+    return lines.join("\n");
+}
+async function buildPrompt(input) {
     const bodies = input.documents
         .map((doc, index) => {
         const meta = detectProductArtifactMeta(doc.content);
@@ -213,11 +360,18 @@ function buildPrompt(input) {
         ].join("\n");
     })
         .join("\n\n");
+    const repoHint = input.repoRoot
+        ? await buildRepoHint(input.repoRoot)
+        : "(no repo layout hint)";
     return [
         "You are a read-only requirement structurer for loop-agent task intake.",
         "Convert imported product documents into a thin requirement draft JSON.",
         "Do NOT invent product behavior that is not supported by the documents.",
-        "Do NOT emit engineering fields (allowedPaths, forbiddenPaths, verifyCommands, taskKind).",
+        "You MAY recommend an optional engineering block when the repo layout hint supports it:",
+        "- allowedPaths / forbiddenPaths as minimal precise globs (e.g. source/packages/**/*.test.ts)",
+        "- verifyCommands as real package scripts (e.g. pnpm -C source test)",
+        "- taskKind when clearly implied (backend-test / frontend-test / standard / …)",
+        "Prefer smallest correct write boundary; do not invent product paths that are not in the layout hint.",
         "Do NOT rewrite or suggest editing the original PRD files.",
         "Prefer explicit text; use provenance derived for rephrasing; use inferred only when clearly implied — if you must invent ACs, leave acceptanceCriteria empty so the system can stop for clarification.",
         "Return exactly one JSON object, no markdown prose outside optional fence:",
@@ -235,9 +389,18 @@ function buildPrompt(input) {
             ],
             openQuestions: ["optional"],
             assumptions: ["optional"],
+            engineering: {
+                taskKind: "optional string",
+                allowedPaths: ["optional globs"],
+                forbiddenPaths: ["optional globs"],
+                verifyCommands: [
+                    { label: "test", command: "pnpm -C source test" },
+                ],
+            },
         }, null, 2),
         `taskId: ${input.taskId}`,
         `fallbackTitle: ${input.title}`,
+        repoHint,
         "Documents:",
         bodies,
     ].join("\n\n");
@@ -314,14 +477,16 @@ export async function runSemanticIntake(input) {
         const attached = usableDocs
             .map((d) => d.absolutePath)
             .filter((p) => Boolean(p));
+        const prompt = await buildPrompt({
+            taskId: input.taskId,
+            title: input.title,
+            documents: usableDocs,
+            repoRoot: input.repoRoot,
+        });
         const result = await execute({
             attachedFiles: attached,
             modelConfig: resolveDagPiModelConfig(model),
-            prompt: buildPrompt({
-                taskId: input.taskId,
-                title: input.title,
-                documents: usableDocs,
-            }),
+            prompt,
             repoRoot: input.repoRoot,
             step: "analyze",
             toolNames: ["read", "grep", "find", "ls"],

package/dist/worker/cli.js

@@ -720,6 +720,7 @@ export function buildAgentWorkerProgram() {
         .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no network auth)", "127.0.0.1")
         .option("--debug", "Log request source/method/path/status to stderr")
         .option("--app-data <path>", "Override Console application-data root (Draft/Operation/confirmation)")
+        .option("--default-timeout-ms <ms>", "LoopAgentClient hard timeout for Console operations (ms; default 14400000 / 4h; 0 disables)")
         .action(async (options) => {
         await runConsoleServe({
             repoRoot: path.resolve(options.repo),
@@ -729,6 +730,7 @@ export function buildAgentWorkerProgram() {
             appDataRoot: options.appData
                 ? path.resolve(options.appData)
                 : undefined,
+            defaultTimeoutMsRaw: options.defaultTimeoutMs,
         });
     });
     consoleCmd
@@ -738,6 +740,7 @@ export function buildAgentWorkerProgram() {
         .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no network auth)", "127.0.0.1")
         .option("--debug", "Log request source/method/path/status to stderr")
         .option("--app-data <path>", "Override Console application-data root (Draft/Operation/confirmation)")
+        .option("--default-timeout-ms <ms>", "LoopAgentClient hard timeout for Console operations (ms; default 14400000 / 4h; 0 disables)")
         .description("Start Loop Operator Console HTTP server (compat entry; equivalent to bare `agent-worker console`)")
         .action(async (options) => {
         await runConsoleServe({
@@ -748,6 +751,7 @@ export function buildAgentWorkerProgram() {
             appDataRoot: options.appData
                 ? path.resolve(options.appData)
                 : undefined,
+            defaultTimeoutMsRaw: options.defaultTimeoutMs,
         });
     });
     consoleCmd
@@ -835,6 +839,17 @@ export async function main(argv = process.argv) {
 async function readTaskYaml(taskSpecPath) {
     return YAML.parse(await readFile(taskSpecPath, "utf-8"));
 }
+/** Parse optional `--default-timeout-ms`; undefined keeps Console default. */
+function parseOptionalTimeoutMs(raw) {
+    if (raw === undefined || raw.trim() === "") {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+        throw new Error(`--default-timeout-ms must be a non-negative integer (ms); got ${JSON.stringify(raw)}`);
+    }
+    return value;
+}
 /** Shared console serve entry used by both bare `console` and `console serve`. */
 async function runConsoleServe(options) {
     const { createConsoleServer } = await import("./console/server.js");
@@ -845,6 +860,7 @@ async function runConsoleServe(options) {
             port: options.port,
             debug: options.debug === true,
             appDataRoot: options.appDataRoot,
+            defaultTimeoutMs: parseOptionalTimeoutMs(options.defaultTimeoutMsRaw),
         });
         process.stdout.write(`${server.url}\n`);
         await new Promise((resolve) => {

package/dist/worker/console/prd-intake-bridge.js

@@ -8,6 +8,7 @@ import path from "node:path";
 import { getTaskPaths } from "../../task/runtime.js";
 import { SEMANTIC_INTAKE_ARTIFACT_REL, } from "../../task/source-prepare/semantic-intake.js";
 import { extractRequirementFactsFromMarkdown } from "../../task/source-prepare/parse-intent.js";
+import { filterPlaceholderPaths, isNonPlaceholderPath, } from "../../task/source-prepare/placeholder-paths.js";
 import { emptyDraft } from "./interview/grill-me.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 function asStringList(value) {
@@ -105,13 +106,13 @@ export function parseEngineeringBoundaryFromParams(p) {
         if (Array.isArray(value)) {
             return value
                 .map((item) => (typeof item === "string" ? item.trim() : ""))
-                .filter(Boolean);
+                .filter(isNonPlaceholderPath);
         }
         if (typeof value === "string") {
             return value
                 .split(/[\n,;，；]+/)
                 .map((s) => s.trim())
-                .filter(Boolean);
+                .filter(isNonPlaceholderPath);
         }
         return [];
     };
@@ -176,10 +177,10 @@ export function parseEngineeringBoundaryFromParams(p) {
     };
 }
 export function appendEngineeringCliArgs(args, boundary) {
-    for (const pathGlob of boundary.allowedPaths ?? []) {
+    for (const pathGlob of filterPlaceholderPaths(boundary.allowedPaths)) {
         args.push("--allowed-path", pathGlob);
     }
-    for (const pathGlob of boundary.forbiddenPaths ?? []) {
+    for (const pathGlob of filterPlaceholderPaths(boundary.forbiddenPaths)) {
         args.push("--forbidden-path", pathGlob);
     }
     for (const cmd of boundary.verifyCommands ?? []) {
@@ -187,8 +188,10 @@ export function appendEngineeringCliArgs(args, boundary) {
     }
 }
 export function applyEngineeringBoundaryToDraft(draft, boundary) {
-    if (!(boundary.allowedPaths?.length) &&
-        !(boundary.forbiddenPaths?.length) &&
+    const allowedPaths = filterPlaceholderPaths(boundary.allowedPaths);
+    const forbiddenPaths = filterPlaceholderPaths(boundary.forbiddenPaths);
+    if (allowedPaths.length === 0 &&
+        forbiddenPaths.length === 0 &&
         !(boundary.verifyCommands?.length)) {
         return draft;
     }
@@ -196,11 +199,11 @@ export function applyEngineeringBoundaryToDraft(draft, boundary) {
         ...draft,
         constraints: {
             invariants: draft.constraints?.invariants ?? [],
-            allowedPaths: boundary.allowedPaths?.length
-                ? boundary.allowedPaths
+            allowedPaths: allowedPaths.length > 0
+                ? allowedPaths
                 : (draft.constraints?.allowedPaths ?? []),
-            forbiddenPaths: boundary.forbiddenPaths?.length
-                ? boundary.forbiddenPaths
+            forbiddenPaths: forbiddenPaths.length > 0
+                ? forbiddenPaths
                 : (draft.constraints?.forbiddenPaths ?? []),
         },
         verification: {
@@ -253,15 +256,53 @@ export async function buildDraftFromTaskIntake(input) {
         const title = artifact?.draft?.title?.trim() ||
             artifact?.semantic?.title?.trim() ||
             input.title;
+        // Preserve semantic engineering boundary (paths/verify/taskKind) so the
+        // Console draft does not fall back to interview defaults and overwrite
+        // TX1 precise values on contractApply --from-draft.
+        const semDraftConstraints = artifact?.draft?.constraints;
+        const semDraftVerification = artifact?.draft?.verification;
+        const semTaskKind = artifact?.draft?.taskKind?.trim();
+        const mergedAllowed = filterPlaceholderPaths(semDraftConstraints?.allowedPaths);
+        const mergedForbidden = filterPlaceholderPaths(semDraftConstraints?.forbiddenPaths);
+        const mergedVerify = Array.isArray(semDraftVerification?.commands)
+            ? semDraftVerification.commands
+                .filter((cmd) => typeof cmd?.command === "string" && cmd.command.trim().length > 0)
+                .map((cmd) => ({
+                label: typeof cmd.label === "string" && cmd.label.trim()
+                    ? cmd.label.trim()
+                    : "verify",
+                command: cmd.command.trim(),
+                ...(typeof cmd.timeoutMs === "number"
+                    ? { timeoutMs: cmd.timeoutMs }
+                    : {}),
+            }))
+            : [];
         draft = {
             ...draft,
             title,
+            ...(semTaskKind
+                ? { taskKind: normalizeConsoleWorkflowKind(semTaskKind, taskKind) }
+                : {}),
             requirement: {
                 objective: semanticReq.objective.trim(),
                 scope: asStringList(semanticReq.scope),
                 nonGoals: asStringList(semanticReq.nonGoals),
                 acceptanceCriteria: asAcceptance(semanticReq.acceptanceCriteria),
             },
+            ...(mergedAllowed.length > 0 ||
+                mergedForbidden.length > 0 ||
+                Array.isArray(semDraftConstraints?.invariants)
+                ? {
+                    constraints: {
+                        invariants: asStringList(semDraftConstraints?.invariants),
+                        allowedPaths: mergedAllowed,
+                        forbiddenPaths: mergedForbidden,
+                    },
+                }
+                : {}),
+            ...(mergedVerify.length > 0
+                ? { verification: { commands: mergedVerify } }
+                : {}),
             openQuestions: asStringList(artifact?.draft?.openQuestions ?? artifact?.semantic?.openQuestions) || undefined,
             assumptions: asStringList(artifact?.draft?.assumptions ?? artifact?.semantic?.assumptions) || undefined,
             references: artifact?.draft?.references,

package/dist/worker/console/server.js

@@ -4,6 +4,7 @@ import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
 import { openConsoleAppData } from "./app-data.js";
 import { DagConfirmationStore } from "./dag-confirmation.js";
 import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
@@ -24,6 +25,30 @@ import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { NightAuxTicker } from "./night-aux-ticker.js";
 import { deriveObserveRouteCapabilities } from "../observe/health.js";
 import { createObserveRouteContext, defaultObserveStaticDir, handleMatchedObserveRoute, matchObserveGetRoute, ROUTES, serveObserveStatic, } from "../observe/routes.js";
+/**
+ * Default hard timeout for the Console-owned LoopAgentClient.
+ *
+ * Console task-nav operations (`dag execute`, `task advance --approve-gate`,
+ * etc.) spawn a long-lived sibling runner via the operation runner. The
+ * worker client hard-kills children after `defaultTimeoutMs` (default 120s),
+ * which is far below multi-node DAG wall clocks and leaves `state.json`
+ * stuck in `running` with no error. Align with shared `DAG_ABSOLUTE_MAX_WALL_CLOCK_MS`
+ * (4h) so the client is a safety net, not a false deadline.
+ */
+export const DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS = DAG_ABSOLUTE_MAX_WALL_CLOCK_MS;
+/**
+ * Resolve the Console LoopAgentClient default timeout.
+ * `0` disables the client hard timeout (DAG kernel owns wall clock).
+ */
+export function resolveConsoleDefaultTimeoutMs(override) {
+    if (override === undefined) {
+        return DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS;
+    }
+    if (!Number.isFinite(override) || override < 0) {
+        throw new Error(`console serve: invalid defaultTimeoutMs ${String(override)} (expected >= 0)`);
+    }
+    return override;
+}
 /** Built static assets live next to the compiled server under dist/worker/console/static. */
 export function defaultConsoleStaticDir(fromFileUrl = import.meta.url) {
     return path.join(path.dirname(fileURLToPath(fromFileUrl)), "static");
@@ -74,6 +99,9 @@ export async function createConsoleServer(options) {
             loopAgentBin: resolveSiblingLoopAgentBin(),
             artifactRoot,
             resolveIdentity: true,
+            // See DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS: dag execute / task advance
+            // must not inherit the 120s worker-command default.
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(options.defaultTimeoutMs),
         });
     if (!options.skipReconcile) {
         await operations.reconcileOnBoot();

package/dist/workflows/dag/liveness-policy.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
 /**
  * Adaptive liveness policy for DAG/Pi supervision.
  *
@@ -15,7 +16,7 @@ export const DEFAULT_LIVENESS_POLICY = {
     stallProbeMs: 900_000,
     abortGraceMs: 30_000,
     /** 4h absolute max wall clock — cannot be renewed by empty heartbeats. */
-    absoluteMaxWallClockMs: 14_400_000,
+    absoluteMaxWallClockMs: DAG_ABSOLUTE_MAX_WALL_CLOCK_MS,
 };
 export const dagLivenessPolicySchema = z
     .object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.34.1",
+  "version": "0.34.3",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",