@tea-agent/loop-agent 0.34.2 → 0.34.4

package/AGENTS.md

@@ -74,7 +74,9 @@ DAG 执行期间，主 agent 不得修改 writeSet 外的任何工作区文件
 
 权威源：`docs/governance/verification-matrix.md`。
 
-默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 跑 `bash scripts/ci.sh`（全量 typecheck + `npm test`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
+默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 经 `node scripts/pre-push-verify.mjs` 在 receipt 命中时复用、miss 时跑 full `bash scripts/ci.sh`（全量 typecheck + `npm test`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
+
+连续 source→target 交付遵循**单一最终树全量验证**：同一 Git tree、相同环境与命令合同在 receipt TTL 内只选一个本地 full authority（有效 receipt / target pre-push / 可选 `npm run verify:tree`），不按分支名策略化，也不机械双跑 full CI。细节见 verification-matrix 与 branch-merge-guideline。
 
 常用：
 
@@ -83,7 +85,10 @@ DAG 执行期间，主 agent 不得修改 writeSet 外的任何工作区文件
 npm run typecheck
 npx vitest run <相关测试路径>
 
-# push / 交付前（或依赖 pre-push）
+# 可选：提前验证当前 clean HEAD 并写 receipt（随后同 tree push 可复用）
+npm run verify:tree
+
+# push / 交付前（或依赖 pre-push；receipt miss 时安全回退 full）
 bash scripts/ci.sh
 npm run build
 node bin/loop-agent.js --help

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 ## [Unreleased]
 
+## [0.34.4] - 2026-08-12
+
+### 重点更新
+
+- 本地连续交付改为按精确 Git tree 复用验证结果，避免提交、推送和分支合并之间机械重复全量测试，同时保持不同 tree、不同环境和远程 CI 的独立质量门槛
+- 全面加固 Operator Chat 的 Turn 所有权、停止与异常恢复流程，解决浏览器与服务端状态错位时的重复提交、停止失效和错误提示问题
+- Operator Chat 新增按仓库保存的 Skills 自动使用偏好，用户可控制技能是否进入模型自动发现范围，同时保留手动调用能力
+- 修复控制台任务导航无法自主执行后端测试与前端测试 DAG 的问题，现可正确识别 pytest、playwright 等多种测试框架的验证命令
+
+### 新增
+
+- 新增可选的 `npm run verify:tree`，对当前严格 clean HEAD 执行完整验证并写入 receipt，随后推送同一 tree 时可直接复用
+- 新增只读的当前 tree receipt 诊断，可区分匹配、缺失、过期、损坏和工作区不合格等状态，不执行测试或写入 receipt
+- Operator Chat 引入完整的 Turn ownership 协议和服务端真实中止接口，并在状态接口中提供 active/latest Turn 与 runtime busy 事实
+- Operator Chat Skills 新增「允许自动使用」开关，偏好按仓库持久化；关闭后仍可通过 `/skill:<name>` 手动调用
+
+### 改进
+
+- source→target 连续交付统一选择一个本地全量验证权威；默认 commit/push 不增加步骤，远程 CI 与发布环境不复用本地 receipt
+- pre-push receipt 诊断和执行日志改用有界命令摘要，并严格校验 tree、环境、命令合同、有效期及 receipt 内容一致性
+- Skills 运行时快照改为使用服务端资源标识和独立的自动调用状态，资源变更仅接受当前 inventory 中的合法条目
+- Turn 已占用时返回可恢复的中文状态提示和真实 active Turn，不再向用户暴露裸露的 `chat turn already active` 错误
+
+### 修复
+
+- 修复浏览器已认为对话结束、服务端却仍持有 active Turn 时的重复提交竞态；提交现在支持幂等请求标识、boot epoch orphan 隔离和 durable Turn/runtime busy 联合对账
+- 修复创建 Turn 的响应不确定时状态被过早释放的问题；客户端会保留 ambiguous 状态，通过 `/state` 绑定或释放真实 ownership，不会重新生成请求标识
+- 修复停止请求在 Turn 尚未绑定时丢失的问题；绑定成功后只发送一次真实 abort，且服务端缺少 abort 能力时不会通过 dispose 会话伪造停止
+- 修复 active bind、terminal SSE 与 React streaming 状态交错时提交锁未释放的问题，并统一 adopt、停止中和 abort-pending 为非致命提示
+- 修复控制台任务导航执行 backend-test 和 frontend-test DAG 时，因结构化验证门禁未识别 pytest/playwright 等命令而始终被阻断的问题
+
+## [0.34.3] - 2026-08-12
+
+### 重点更新
+
+- 修复 PRD 导入时 grill-me 模板占位符路径污染写入集的问题，确保仅处理真实需求路径
+
+### 改进
+
+- 语义化导入现可作为兜底方案推荐工程边界，提升需求解析的准确性
+- 将语义约束与验证信息合并至控制台草稿，避免表单默认值覆盖精确的验证命令
+
+### 修复
+
+- 修复 grill-me 模板占位符路径未被过滤即进入写入集，导致占位内容污染实际工程数据的问题
+
 ## [0.34.2] - 2026-08-12
 
 ### 重点更新
@@ -70,36 +116,33 @@
 
 ## [0.33.6] - 2026-08-11
 
+### 重点更新
+
+- 加固 PRD 导入与 Semantic Intake，在结构化解析不足时提供安全回退，并增强 writeSet 审查与运行结果摘要
+- Operator Chat 接入单一事件流、启动 epoch 隔离、实时运行时控制与开放资源加载，提升长会话恢复和自主 DAG 监督能力
+- 统一 Windows 等环境下只读 Git 命令的有界恢复机制，同时保留用户自有的 Pi 模型路由配置
+
 ### 新增
 
-- stabilize PRD intake + add Semantic Intake fallback
-- Operator Chat 单事件流 + boot epoch fence（Task C）
-- gate writeSet delta + run summary（操作面增强）
-- supervise DAG runs autonomously
-- ChatEventStore 事件持久化压缩（coalescing + maxBytes 双限制）
-- reconcile(cursor_expired) 自动恢复而非全局致命错误
-- 接入 Operator Chat 实时运行时控制
-- open operator chat resource loading
-- enrich execution report and URL resolution
+- task advance 新增 writeSet delta 与 run summary，直接展示边界扩张来源、节点结果和下一步操作
+- Operator Chat 引入单一事件流与 boot epoch fence，支持 cursor 过期后的自动对账恢复，避免将可恢复问题升级为全局错误
+- ChatEventStore 增加事件合并与容量上限双重压缩，控制长期会话持久化体积
+- Operator Chat 新增实时模型、thinking 和运行时资源控制，并按开放资源加载规则解析 Skills、Extensions 与 Packages
+- Operator Chat 可对安全的 bounded DAG 进行持续监督和恢复，执行报告同步补充运行细节与目标 URL 来源
 
 ### 改进
 
-- style(task-advance): biome autoformat 对齐（无功能变化）
-- style(console): apply biome formatting from pi-lens autoformat
+- 只读 Git 查询统一使用共享韧性执行器，在 Windows 启动型故障下有界恢复，不扩大 mutation 命令权限
+- 初始化与升级流程保留用户自行配置的 Pi 模型路由，不再因默认配置变化机械覆盖
+- Packages 面板区分配置状态与真实安装元数据，并统一使用品牌图标
 
 ### 修复
 
-- unify resilient read-only command execution
-- preserve user-owned Pi model routing
-- show installed package metadata
-- escape preflight backtick matcher
-- align chat streaming reliability with pi-web
-- split rerun defaults and repair selector escaping
-- ignore delimiters inside pytest strings
-- resolve target URL from runtime context
-- reject priority-only module stems
-- stop desiredSha256 mechanical checks from blocking generated-content upgrades
-- use mobius header brand icon
+- 修复 Operator Chat 流式状态与 pi-web 可靠性机制未完全对齐的问题，提升重连和终态收敛稳定性
+- 修复前端测试环境预检中的反引号转义错误，以及重跑默认值和 repair 选择器转义不一致的问题
+- 修复后端测试完整性检查误判字符串内部未配对分隔符，以及按优先级生成非法单模块文件的问题
+- 修复前端测试目标 URL 未从运行时上下文解析的问题，执行时现使用可审计的真实地址来源
+- 修复 generated init 内容因 `desiredSha256` 机械比较而阻断安全升级的问题
 
 ## [0.33.5] - 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/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/console/app-data.js

@@ -43,6 +43,7 @@ export function openConsoleAppData(options) {
         chats: path.join(repoNamespace, "chats"),
         chatSessions: path.join(repoNamespace, "chat-sessions"),
         chatEvents: path.join(repoNamespace, "chat-events"),
+        resourcePreferences: path.join(repoNamespace, "resource-preferences.json"),
     };
     for (const dir of [
         paths.drafts,
@@ -55,6 +56,7 @@ export function openConsoleAppData(options) {
         paths.chats,
         paths.chatSessions,
         paths.chatEvents,
+        path.dirname(paths.resourcePreferences),
     ]) {
         ensureSecureDir(dir);
     }