sdd-flow-kit 1.3.12 → 1.3.14

package/README.md

@@ -63,7 +63,7 @@ node ./node_modules/sdd-flow-kit/dist/postinstall.js
 #### 当前自动化边界
 
 - 已支持：跨工具统一目录结构、提示词、报告模板、**NEXT.md 脚本清单**
-- 已支持：**gate / phase / propose / deliver** 命令（exit code 机械门禁）
+- 已支持：**gate / phase / propose / deliver / chain / session mode** 命令（exit code 机械门禁）
 - 已支持：`ensure-opsx` + `openspec status` 校验 apply-ready
 - 未支持：在 Cursor 内全自动跑完全流程（Cursor adapter 仍为 manual）；可选 `SDD_FLOW_KIT_ENABLE_CLAUDE_AUTORUN=1` 给 Claude Code
 
@@ -80,6 +80,13 @@ node ./node_modules/sdd-flow-kit/dist/postinstall.js
 
 #### 变更记录
 
+**1.3.13** — 执行模式拆分 + 回合结束约束 + chain 机械串联
+
+- 新增 `executionMode`：`full-chain`（默认）与 `staged-confirm`（分阶段确认），正交于 `strictCommands`
+- 兼容「严格SOP，不可替代」→ `staged-confirm` + `strictCommands`
+- 模板写入回合结束条件，禁止待办清单式提前收尾
+- 新增 `chain`、`session mode` CLI；`invoke` 自动解析执行模式
+
 **1.3.11** — PRD 自动修复改为「每项最多 3 次」
 
 - 每轮只修 `prd-diff` 仍失败的剩余项；8 项已修好则下轮只盯剩下 2 项

package/dist/adapters/index.js

@@ -43,8 +43,9 @@ async function runClaudeFlow(args) {
         "1) 01-获取需求文档指引：回填 source/PRD.md（及接口文档，如有）。",
         "2) 02-需求分析：若矛盾点未闭合，仅更新 03-待确认问题清单.md 并停止；用户确认后生成 05→04→01/02/闭环03。",
         "3) 用户确认后从 source/PRD.md 填写 05-验收清单.md（定义状态：已定义），再补全 04-技术文档草稿.md（引用 AC-ID）。",
-        "4) 03 闭环后默认同一回合：/opsx-propose（05+04+02+UI）→ gate ac-ready → /opsx-apply → gate ac-signed → delivery-pipeline exit 0（见 07-opsx-自动串联指引.md）。",
+        "4) 03 闭环后：读 .session-state.json 的 executionMode；full-chain（默认）同一回合 C→D→E 直至 deliver exit 0；staged-confirm 每阶段等人确认。",
         "5) 仅当用户说「只提案」或 autoChainOpsx=false 时，在 propose 后暂停等待 apply。",
+        "6) full-chain 时禁止以待办清单结束；唯一出口 deliver exit 0。",
         "完成后输出一句：SDD flow completed",
         "",
         "以下是第2步提示词：",
@@ -92,12 +93,14 @@ async function runCursorFlow(args) {
         "强约束：",
         "1) 在 docs 阶段（docModeOnly=true）只允许改 openspec/PRD/**，禁止改 src/。",
         "2) 若矛盾点池未闭合：仅更新 03-待确认问题清单.md 并停止，等待用户确认点。",
-        "3) 若矛盾点池已闭合：同一回合生成 05→04→01/02，并自动衔接 openspec+superpowers（autoChainOpsx=true 时）。",
+        "3) 若矛盾点池已闭合：同一回合生成 05→04→01/02；executionMode=full-chain 时继续 C→D→E 直至 deliver exit 0。",
+        "4) executionMode=staged-confirm 时：每阶段输出门禁结果后暂停等人确认。",
+        "5) 禁止用「后续待办」「骨架已完成」结束回合（full-chain 时）。",
         "",
         "执行顺序：",
         "A) 先按 01-获取需求文档指引.md 执行 confluence-doc.py，把 PRD 回填到 source/PRD.md。",
         "B) 再执行 02-需求分析提示词.md（如下）生成/更新 03（必要时）或生成 05/04/01/02。",
-        "C) 若满足自动串联条件（autoChainOpsx!==false 且用户未说只提案）：继续按 07-opsx-自动串联指引.md 走 propose→ac-ready→apply→ac-signed→delivery-pipeline。",
+        "C) full-chain：按 07-opsx-自动串联指引.md 走 propose→ac-ready→apply→validate→deliver；可用 chain 命令机械串联 gate。",
         "",
         "完成判定：",
         "- 若停在澄清：输出一句 `SDD_STATUS=AWAIT_CONFIRMATION`。",

package/dist/cli.js

@@ -20,6 +20,8 @@ const runDeliver_1 = require("./steps/runDeliver");
 const runPrdReview_1 = require("./steps/runPrdReview");
 const runPrdDiff_1 = require("./steps/runPrdDiff");
 const runPrdRemediate_1 = require("./steps/runPrdRemediate");
+const runChain_1 = require("./steps/runChain");
+const runSessionMode_1 = require("./steps/runSessionMode");
 const bootstrap_1 = require("./core/bootstrap");
 const projectRoots_1 = require("./core/projectRoots");
 const ALLOWED_AGENTS = ["cursor", "claude-code", "codex", "openclaw", "custom"];
@@ -85,6 +87,14 @@ function printHelp() {
         "   npx sdd-flow-kit phase advance --project-root . --run-id <runId> --to validate-done --change <name>",
         "   npx sdd-flow-kit deliver --project-root . --run-id <runId> --change <name>",
         "",
+        "11) 机械串联 gate→phase→validate→deliver（AI 步骤须先完成）：",
+        "   npx sdd-flow-kit chain --project-root . --run-id <runId> --change <name> --from docs-done",
+        "   # --from: docs-done | propose-done | impl | validate-done",
+        "",
+        "12) 设置执行模式：",
+        "   npx sdd-flow-kit session mode --run-id <runId> --execution-mode full-chain",
+        "   npx sdd-flow-kit session mode --run-id <runId> --execution-mode staged-confirm --strict-commands",
+        "",
         "可选参数：",
         "   --projectRoot <path>   目标项目根目录（默认当前目录 = 安装根，cd 到哪装到哪）",
         "   环境变量 SDD_FLOW_KIT_INSTALL_ROOT 可覆盖安装根（绝对路径）",
@@ -101,7 +111,7 @@ function printHelp() {
     ].join("\n"));
 }
 async function main() {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const cmd = process_1.default.argv[2];
     if (!cmd || cmd === "--help" || cmd === "-h") {
         printHelp();
@@ -127,6 +137,7 @@ async function main() {
         "validate-done",
         "shipped",
     ];
+    const CHAIN_FROM = ["docs-done", "propose-done", "impl", "validate-done"];
     if (cmd !== "start" &&
         cmd !== "run" &&
         cmd !== "setup" &&
@@ -141,7 +152,9 @@ async function main() {
         cmd !== "prd-review" &&
         cmd !== "prd-diff" &&
         cmd !== "prd-remediate" &&
-        cmd !== "deliver") {
+        cmd !== "deliver" &&
+        cmd !== "chain" &&
+        cmd !== "session") {
         printHelp();
         process_1.default.exitCode = 1;
         return;
@@ -188,6 +201,8 @@ async function main() {
         "prd-diff",
         "prd-remediate",
         "deliver",
+        "chain",
+        "session",
     ]);
     if (!skipBootstrap && !dryRun && bootstrapCommands.has(cmd)) {
         await (0, bootstrap_1.bootstrapProjectIfNeeded)({
@@ -354,6 +369,59 @@ async function main() {
             process_1.default.exitCode = 1;
         return;
     }
+    if (cmd === "chain") {
+        if (!changeName) {
+            // eslint-disable-next-line no-console
+            console.error("chain 需要 --change <kebab-name>");
+            process_1.default.exitCode = 1;
+            return;
+        }
+        const from = ((_j = getArgValue("--from")) !== null && _j !== void 0 ? _j : "docs-done");
+        if (!CHAIN_FROM.includes(from)) {
+            // eslint-disable-next-line no-console
+            console.error(`chain 需要 --from ${CHAIN_FROM.join("|")}`);
+            process_1.default.exitCode = 1;
+            return;
+        }
+        const result = await (0, runChain_1.runChain)({
+            projectRoot,
+            runId,
+            change: changeName,
+            from,
+            agent,
+            dryRun,
+        });
+        // eslint-disable-next-line no-console
+        console.log(result.ok ? `✅ ${result.detail}` : `❌ ${result.detail}`);
+        if (!result.ok)
+            process_1.default.exitCode = 1;
+        return;
+    }
+    if (cmd === "session") {
+        const sub = process_1.default.argv[3];
+        if (sub !== "mode") {
+            // eslint-disable-next-line no-console
+            console.error("用法: sdd-flow-kit session mode --execution-mode full-chain|staged-confirm [--strict-commands]");
+            process_1.default.exitCode = 1;
+            return;
+        }
+        const modeArg = (_k = getArgValue("--execution-mode")) !== null && _k !== void 0 ? _k : getArgValue("--executionMode");
+        const textArg = getArgValue("--text");
+        const strictCommands = process_1.default.argv.includes("--strict-commands");
+        const result = await (0, runSessionMode_1.runSessionMode)({
+            projectRoot,
+            runId,
+            executionMode: modeArg === "full-chain" || modeArg === "staged-confirm" ? modeArg : null,
+            strictCommands: strictCommands || undefined,
+            text: textArg,
+            dryRun,
+        });
+        // eslint-disable-next-line no-console
+        console.log(result.ok ? `✅ ${result.detail}` : `❌ ${result.detail}`);
+        if (!result.ok)
+            process_1.default.exitCode = 1;
+        return;
+    }
     if (cmd === "doctor" || cmd === "ensure-opsx") {
         const fix = cmd === "ensure-opsx" || process_1.default.argv.includes("--fix");
         const doctor = await (0, doctor_1.runDoctor)({
@@ -426,6 +494,9 @@ async function main() {
                 agent,
             });
             const result = await (0, runFlow_1.runFlow)(options);
+            if (!dryRun) {
+                await (0, runSessionMode_1.applyInvokeTextToSession)(projectRoot, result.runId, text);
+            }
             // eslint-disable-next-line no-console
             console.log(`invoke 成功：${parsed.product} ${parsed.version} -> runId=${result.runId}`);
             if (planJson) {

package/dist/core/executionMode.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExecutionModeFromText = parseExecutionModeFromText;
+exports.applyExecutionModeToSession = applyExecutionModeToSession;
+exports.shouldAutoChainAfterConfirm = shouldAutoChainAfterConfirm;
+exports.shouldPauseBetweenPhases = shouldPauseBetweenPhases;
+exports.requiresStrictCommands = requiresStrictCommands;
+exports.normalizeExecutionModeFields = normalizeExecutionModeFields;
+const DEFAULT_MODE = {
+    executionMode: "full-chain",
+    strictCommands: false,
+    legacyStrictSop: false,
+};
+/**
+ * 从用户自然语言解析执行模式（invoke / 确认点粘贴均可调用）。
+ */
+function parseExecutionModeFromText(text) {
+    const t = text.trim();
+    if (!t)
+        return { ...DEFAULT_MODE };
+    const legacyStrictSop = /严格\s*SOP|不可替代/.test(t);
+    let executionMode = "full-chain";
+    if (/分阶段确认|staged-confirm|阶段确认制/.test(t) ||
+        legacyStrictSop) {
+        executionMode = "staged-confirm";
+    }
+    if (/确认后全链路|full-chain|禁止中途停止|全链路/.test(t)) {
+        executionMode = "full-chain";
+    }
+    const strictCommands = legacyStrictSop ||
+        /严格命令|strict-commands|禁止.*等价/.test(t);
+    return { executionMode, strictCommands, legacyStrictSop };
+}
+/**
+ * 将解析结果写入 session；force=true 时无条件覆盖。
+ */
+function applyExecutionModeToSession(session, parsed, force = false) {
+    const isDefault = parsed.executionMode === "full-chain" &&
+        !parsed.strictCommands &&
+        !parsed.legacyStrictSop;
+    if (!force && isDefault)
+        return session;
+    return {
+        ...session,
+        executionMode: parsed.executionMode,
+        strictCommands: parsed.strictCommands || session.strictCommands === true,
+    };
+}
+/** 矛盾点闭合后是否同一回合自动 propose→apply（不看 staged-confirm，那是阶段间暂停） */
+function shouldAutoChainAfterConfirm(session) {
+    if (session.autoChainOpsx === false)
+        return false;
+    return true;
+}
+/** 完成一个阶段（C/D/E）后是否必须等待用户确认再进下一阶段 */
+function shouldPauseBetweenPhases(session) {
+    if (session.executionMode === "staged-confirm")
+        return true;
+    return false;
+}
+/** 是否禁止用「等价命令」替代 NEXT.md / gate 链路 */
+function requiresStrictCommands(session) {
+    return session.strictCommands === true;
+}
+function normalizeExecutionModeFields(raw) {
+    const modeRaw = raw.executionMode;
+    let executionMode = "full-chain";
+    if (modeRaw === "staged-confirm" || modeRaw === "full-chain") {
+        executionMode = modeRaw;
+    }
+    else if (raw.legacyStrictSop === true || raw.strictSop === true) {
+        executionMode = "staged-confirm";
+    }
+    return {
+        executionMode,
+        strictCommands: raw.strictCommands === true,
+    };
+}

package/dist/core/prdArtifacts.js

@@ -16,6 +16,31 @@ const PRD_PLACEHOLDER_MARKERS = [
     "占位",
     "placeholder",
 ];
+const PRD_TECHNICAL_TITLE_MARKERS = [
+    "技术文档",
+    "技术方案",
+    "详细设计",
+    "接口文档",
+    "后端",
+    "数据库",
+    "实现文档",
+    "设计文档",
+    "开发文档",
+];
+/**
+ * 判断 PRD 标题是否属于技术/后端/设计类文档，避免错误进入需求分析链路。
+ */
+function hasForbiddenPrdTitle(title) {
+    const upper = (title || "").toUpperCase();
+    return PRD_TECHNICAL_TITLE_MARKERS.some((marker) => upper.includes(marker.toUpperCase()));
+}
+/**
+ * 从 Markdown 主标题读取 Confluence 页面标题，作为 prd-fetched 的类型校验入口。
+ */
+function extractPrdTitle(content) {
+    var _a, _b;
+    return (_b = (_a = content.split("\n").find((line) => line.trim().startsWith("# "))) === null || _a === void 0 ? void 0 : _a.replace(/^#\s*/, "").trim()) !== null && _b !== void 0 ? _b : "";
+}
 async function isPrdFetched(outputRoot) {
     const prdPath = path_1.default.join(outputRoot, "source", "PRD.md");
     const content = await (0, fs_1.readFileIfExists)(prdPath);
@@ -25,6 +50,10 @@ async function isPrdFetched(outputRoot) {
     if (PRD_PLACEHOLDER_MARKERS.some((m) => content.includes(m))) {
         return { ok: false, detail: "source/PRD.md 仍为占位内容，请先执行 Step1 拉取 PRD" };
     }
+    const title = extractPrdTitle(content);
+    if (title && hasForbiddenPrdTitle(title)) {
+        return { ok: false, detail: `source/PRD.md 命中技术文档标题: ${title}` };
+    }
     return { ok: true, detail: "PRD 已回填" };
 }
 async function isQuestionsClosed(outputRoot) {

package/dist/core/sessionState.js

@@ -9,6 +9,7 @@ exports.defaultSession = defaultSession;
 exports.normalizeSession = normalizeSession;
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("./fs");
+const executionMode_1 = require("./executionMode");
 const SESSION_FILE = ".session-state.json";
 async function readSession(outputRoot) {
     const raw = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, SESSION_FILE));
@@ -29,6 +30,8 @@ function defaultSession(args) {
         status: "awaiting_user_confirmation",
         docModeOnly: true,
         autoChainOpsx: true,
+        executionMode: "full-chain",
+        strictCommands: false,
         activeChange: null,
         createdAtISO: new Date().toISOString(),
         implGitBaseline: null,
@@ -50,6 +53,7 @@ function normalizeSession(raw, outputRoot) {
         status,
         docModeOnly: raw.docModeOnly !== false,
         autoChainOpsx: raw.autoChainOpsx !== false,
+        ...(0, executionMode_1.normalizeExecutionModeFields)(raw),
         activeChange: raw.activeChange ? String(raw.activeChange) : null,
         createdAtISO: String((_e = raw.createdAtISO) !== null && _e !== void 0 ? _e : new Date().toISOString()),
         implGitBaseline: raw.implGitBaseline ? String(raw.implGitBaseline) : null,

package/dist/core/turnEndPolicy.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTurnEndPolicyMarkdown = getTurnEndPolicyMarkdown;
+exports.getExecutionModeGuideMarkdown = getExecutionModeGuideMarkdown;
+/**
+ * 回合结束条件（写入 NEXT.md / 07 指引，约束 AI 不得「待办清单式」提前收尾）。
+ */
+function getTurnEndPolicyMarkdown() {
+    return [
+        "## 回合结束条件（唯一合法出口）",
+        "",
+        "- ✅ `gate shipped` 通过 **且** `deliver` exit 0",
+        "- ⛔ **禁止**在 `tasks.md` 未全 `- [x]`、delivery-pipeline 未 exit 0 时结束回合",
+        "- ⛔ **禁止**用「后续待办」「骨架已完成」「文档已更新」作为结束语",
+        "- ⛔ **禁止**输出仅含待办清单的收尾（`executionMode=full-chain` 时）",
+        "- 唯一允许暂停：",
+        "  - `gate` / `validate` / `deliver` exit≠0",
+        "  - `prd-remediate` 单项 3 次未果需人工裁定",
+        "  - 矛盾点池未闭合（提问模式）",
+        "  - `executionMode=staged-confirm` 且当前阶段已完成（输出门禁结果后等人确认）",
+        "  - 用户明确说「只提案」「先别写代码」或 `autoChainOpsx=false`",
+        "",
+    ];
+}
+function getExecutionModeGuideMarkdown() {
+    return [
+        "## 执行模式（`.session-state.json`）",
+        "",
+        "| 字段 | 值 | 含义 |",
+        "|------|-----|------|",
+        "| `executionMode` | `full-chain`（默认） | 矛盾点闭合后 C→D→E 同一回合跑到底 |",
+        "| `executionMode` | `staged-confirm` | 每阶段完成后暂停，等人确认再继续 |",
+        "| `strictCommands` | `true` | 禁止用等价命令替代 NEXT.md 中的 gate/phase 链路 |",
+        "| `autoChainOpsx` | `false` | 文档完成后停止，不自动 propose/apply |",
+        "",
+        "**用户口令示例**",
+        "- 确认后全链路：`执行模式：确认后全链路，禁止中途停止`",
+        "- 分阶段确认：`执行模式：分阶段确认`",
+        "- 严格命令（可与全链路组合）：`执行模式：严格命令`",
+        "- 兼容旧版：`执行模式：严格SOP，不可替代` → `staged-confirm` + `strictCommands`",
+        "",
+        "设置模式：",
+        "```bash",
+        "npx sdd-flow-kit session mode --run-id <runId> --execution-mode full-chain",
+        "npx sdd-flow-kit session mode --run-id <runId> --execution-mode staged-confirm --strict-commands",
+        "```",
+        "",
+    ];
+}

package/dist/core/writeNext.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeInitialNext = writeInitialNext;
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("./fs");
+const turnEndPolicy_1 = require("./turnEndPolicy");
 /**
  * run 初始化后写入 NEXT.md，强制 AI 按脚本推进而非自然语言跳步。
  */
@@ -16,6 +17,14 @@ async function writeInitialNext(outputRoot, projectRoot, runId) {
         "",
         "> **禁止**跳过下列命令。失败 (exit≠0) 时不得进入下一阶段或修改 `src/`。",
         "",
+        ...(0, turnEndPolicy_1.getTurnEndPolicyMarkdown)(),
+        ...(0, turnEndPolicy_1.getExecutionModeGuideMarkdown)(),
+        "## 机械串联（可选，AI 步骤完成后）",
+        "```bash",
+        `npx sdd-flow-kit chain --project-root "${pr}" --run-id ${runId} --change <kebab-name> --from docs-done`,
+        "# --from 可选：docs-done | propose-done | impl | validate-done",
+        "```",
+        "",
         "## 文档职责（SSOT）",
         "",
         "| 文档 | 职责 |",
@@ -26,7 +35,7 @@ async function writeInitialNext(outputRoot, projectRoot, runId) {
         "| `tasks.md` | AC 的可执行映射（`[AC-XX]`） |",
         "",
         "## 1. Step1 — 拉取 PRD",
-        "按 `01-获取需求文档指引.md` 执行 confluence 脚本，然后：",
+        "按 `01-获取需求文档指引.md` 执行 confluence 脚本；脚本和 gate 会拒绝 `技术文档`/`后端`/`详细设计` 等非 PRD 页面，然后：",
         "```bash",
         `npx sdd-flow-kit gate --project-root "${pr}" --run-id ${runId} --expect prd-fetched`,
         `npx sdd-flow-kit phase advance --project-root "${pr}" --run-id ${runId} --to after-prd`,

package/dist/steps/runChain.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChain = runChain;
+const runGate_1 = require("./runGate");
+const runPhaseAdvance_1 = require("./runPhaseAdvance");
+const runPrdReview_1 = require("./runPrdReview");
+const runPrdDiff_1 = require("./runPrdDiff");
+const runValidate_1 = require("./runValidate");
+const runDeliver_1 = require("./runDeliver");
+const resolveRun_1 = require("./resolveRun");
+/**
+ * 机械串联 gate / phase / validate / deliver；AI 步骤（propose、apply、填 08）须先完成，否则在对应 gate 失败即停。
+ */
+async function runChain(options) {
+    var _a, _b;
+    const loaded = await (0, resolveRun_1.loadRunSession)(options.projectRoot, options.runId);
+    if (!(loaded === null || loaded === void 0 ? void 0 : loaded.resolved)) {
+        return { ok: false, runId: null, detail: "未找到 PRD run" };
+    }
+    const runId = loaded.resolved.runId;
+    const pr = options.projectRoot;
+    const change = options.change;
+    const agent = (_a = options.agent) !== null && _a !== void 0 ? _a : "cursor";
+    const allSteps = [
+        {
+            label: "gate docs-closed",
+            run: async () => {
+                const g = await (0, runGate_1.runGate)({ projectRoot: pr, runId, expect: "docs-closed" });
+                if (!g.ok)
+                    (0, runGate_1.printGateResult)(g);
+                return { ok: g.ok, detail: g.checks.map((c) => c.detail).join("; ") };
+            },
+        },
+        {
+            label: "phase advance docs-done",
+            run: async () => {
+                const r = await (0, runPhaseAdvance_1.runPhaseAdvance)({
+                    projectRoot: pr,
+                    runId,
+                    to: "docs-done",
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.message };
+            },
+        },
+        {
+            label: "gate propose-ready",
+            run: async () => {
+                const g = await (0, runGate_1.runGate)({ projectRoot: pr, runId, expect: "propose-ready", change });
+                if (!g.ok)
+                    (0, runGate_1.printGateResult)(g);
+                return { ok: g.ok, detail: g.checks.map((c) => c.detail).join("; ") };
+            },
+        },
+        {
+            label: "gate ac-ready",
+            run: async () => {
+                const g = await (0, runGate_1.runGate)({ projectRoot: pr, runId, expect: "ac-ready", change });
+                if (!g.ok)
+                    (0, runGate_1.printGateResult)(g);
+                return { ok: g.ok, detail: g.checks.map((c) => c.detail).join("; ") };
+            },
+        },
+        {
+            label: "phase advance propose-done",
+            run: async () => {
+                const r = await (0, runPhaseAdvance_1.runPhaseAdvance)({
+                    projectRoot: pr,
+                    runId,
+                    to: "propose-done",
+                    change,
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.message };
+            },
+        },
+        {
+            label: "phase advance impl",
+            run: async () => {
+                const r = await (0, runPhaseAdvance_1.runPhaseAdvance)({
+                    projectRoot: pr,
+                    runId,
+                    to: "impl",
+                    change,
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.message };
+            },
+        },
+        {
+            label: "gate impl-allowed",
+            run: async () => {
+                const g = await (0, runGate_1.runGate)({ projectRoot: pr, runId, expect: "impl-allowed", change });
+                if (!g.ok)
+                    (0, runGate_1.printGateResult)(g);
+                return { ok: g.ok, detail: g.checks.map((c) => c.detail).join("; ") };
+            },
+        },
+        {
+            label: "prd-review",
+            run: async () => {
+                const r = await (0, runPrdReview_1.runPrdReview)({ projectRoot: pr, runId, dryRun: options.dryRun });
+                return { ok: r.ok, detail: r.detail };
+            },
+        },
+        {
+            label: "prd-diff",
+            run: async () => {
+                const r = await (0, runPrdDiff_1.runPrdDiff)({ projectRoot: pr, runId, dryRun: options.dryRun });
+                return { ok: r.ok, detail: r.detail };
+            },
+        },
+        {
+            label: "gate prd-coverage",
+            run: async () => {
+                const g = await (0, runGate_1.runGate)({ projectRoot: pr, runId, expect: "prd-coverage", change });
+                if (!g.ok)
+                    (0, runGate_1.printGateResult)(g);
+                return { ok: g.ok, detail: g.checks.map((c) => c.detail).join("; ") };
+            },
+        },
+        {
+            label: "validate",
+            run: async () => {
+                const r = await (0, runValidate_1.runValidate)({
+                    projectRoot: pr,
+                    runId,
+                    change,
+                    agent,
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.detail };
+            },
+        },
+        {
+            label: "phase advance validate-done",
+            run: async () => {
+                const r = await (0, runPhaseAdvance_1.runPhaseAdvance)({
+                    projectRoot: pr,
+                    runId,
+                    to: "validate-done",
+                    change,
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.message };
+            },
+        },
+        {
+            label: "gate ac-signed",
+            run: async () => {
+                const g = await (0, runGate_1.runGate)({ projectRoot: pr, runId, expect: "ac-signed" });
+                if (!g.ok)
+                    (0, runGate_1.printGateResult)(g);
+                return { ok: g.ok, detail: g.checks.map((c) => c.detail).join("; ") };
+            },
+        },
+        {
+            label: "deliver",
+            run: async () => {
+                const r = await (0, runDeliver_1.runDeliver)({
+                    projectRoot: pr,
+                    runId,
+                    change,
+                    agent,
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.detail };
+            },
+        },
+        {
+            label: "phase advance shipped",
+            run: async () => {
+                const r = await (0, runPhaseAdvance_1.runPhaseAdvance)({
+                    projectRoot: pr,
+                    runId,
+                    to: "shipped",
+                    change,
+                    dryRun: options.dryRun,
+                });
+                return { ok: r.ok, detail: r.message };
+            },
+        },
+    ];
+    const startIndex = {
+        "docs-done": 0,
+        "propose-done": 3,
+        impl: 5,
+        "validate-done": 11,
+    };
+    const steps = allSteps.slice(startIndex[options.from]);
+    if (options.dryRun) {
+        return {
+            ok: true,
+            runId,
+            detail: `dry-run: 将依次执行 ${steps.map((s) => s.label).join(" → ")}`,
+        };
+    }
+    for (const step of steps) {
+        // eslint-disable-next-line no-console
+        console.log(`[chain] ${step.label} ...`);
+        const result = await step.run();
+        if (!result.ok) {
+            return {
+                ok: false,
+                runId,
+                failedStep: step.label,
+                detail: `${step.label} 失败：${(_b = result.detail) !== null && _b !== void 0 ? _b : "exit≠0"}。请先完成 AI 步骤（propose/apply/填 08/签收 05）后重试 chain。`,
+            };
+        }
+    }
+    return { ok: true, runId, detail: "chain 完成：已执行至 shipped" };
+}

package/dist/steps/runSessionMode.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSessionMode = runSessionMode;
+exports.applyInvokeTextToSession = applyInvokeTextToSession;
+const sessionState_1 = require("../core/sessionState");
+const executionMode_1 = require("../core/executionMode");
+const resolveRun_1 = require("./resolveRun");
+/**
+ * 更新 run 的 executionMode / strictCommands（用户口令或 CLI flag）。
+ */
+async function runSessionMode(options) {
+    var _a;
+    const loaded = await (0, resolveRun_1.loadRunSession)(options.projectRoot, options.runId);
+    if (!(loaded === null || loaded === void 0 ? void 0 : loaded.resolved) || !loaded.session) {
+        return { ok: false, runId: null, detail: "未找到 run 或 .session-state.json" };
+    }
+    const { resolved, session } = loaded;
+    let parsed = (0, executionMode_1.parseExecutionModeFromText)((_a = options.text) !== null && _a !== void 0 ? _a : "");
+    if (options.executionMode) {
+        parsed = { ...parsed, executionMode: options.executionMode };
+    }
+    if (options.strictCommands === true) {
+        parsed = { ...parsed, strictCommands: true };
+    }
+    const next = (0, executionMode_1.applyExecutionModeToSession)(session, parsed, true);
+    if (!options.dryRun) {
+        await (0, sessionState_1.writeSession)(resolved.outputRoot, next);
+    }
+    return {
+        ok: true,
+        runId: resolved.runId,
+        detail: `executionMode=${next.executionMode}, strictCommands=${next.strictCommands === true}`,
+    };
+}
+/** invoke 完成后根据用户口令写入 session 模式 */
+async function applyInvokeTextToSession(projectRoot, runId, invokeText) {
+    const loaded = await (0, resolveRun_1.loadRunSession)(projectRoot, runId);
+    if (!(loaded === null || loaded === void 0 ? void 0 : loaded.resolved))
+        return;
+    const session = await (0, sessionState_1.readSession)(loaded.resolved.outputRoot);
+    if (!session)
+        return;
+    const parsed = (0, executionMode_1.parseExecutionModeFromText)(invokeText);
+    const next = (0, executionMode_1.applyExecutionModeToSession)(session, parsed, false);
+    if (next.executionMode !== session.executionMode ||
+        next.strictCommands !== session.strictCommands) {
+        await (0, sessionState_1.writeSession)(loaded.resolved.outputRoot, next);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-flow-kit",
-  "version": "1.3.12",
+  "version": "1.3.14",
   "private": false,
   "description": "Cross-agent SDD automated development workflow kit (ADI/ADI-like).",
   "license": "MIT",
@@ -26,6 +26,10 @@
   "devDependencies": {
     "@types/node": "^20.14.10",
     "typescript": "^5.6.3"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "sdd-flow-kit"
+    ]
   }
 }
-

package/src/templates/artifacts/01-adi-doc-skill-/346/214/207/345/274/225.template.md

@@ -14,11 +14,17 @@ python3 confluence-doc.py {{VERSION_EXAMPLE}}
 
 2. 脚本会依次用关键词打开 **Confluence 专用搜索页** `dosearchsite.action?queryString=<关键词>`（非首页顶栏搜索），并依次尝试：`ADI_V*` → `ADI-V*` → `ADI_*` → `ADI-*` → `ADI_v*` → `ADI-v*` → `ADI V*` → `ADI_V*结算` → `V*` 等。
 
-3. 匹配规则：**标题包含关键词或以关键词为前缀**，或 **URL 路径包含关键词**，任一满足即命中（Confluence 列表标题常被截断）。
+3. 匹配规则：先收集 **标题包含关键词或以关键词为前缀**、或 **URL 路径包含关键词** 的候选页，再执行 PRD 类型校验。
 
-4. **禁止**在 Confluence 脚本未跑完或未确认失败前，用本地 Word/原型替代 `source/PRD.md`。
+4. PRD 类型校验（强制黑名单）：候选页必须通过脚本内 `is_prd_page()` 与 `has_forbidden_prd_title()` 双重校验。以下标题特征会被直接拒绝：
+   - `技术文档`、`技术方案`、`后端`、`详细设计`、`数据库`、`接口文档`
+   - `实现文档`、`设计文档`、`开发文档`
+   
+   若所有候选均未通过校验，脚本必须失败退出（exit code 1），**禁止回退使用第一个非 PRD 候选**。AI 不得手动复制技术文档到 `source/PRD.md`。
 
-5. 成功后把生成的 `docs/*.md` **主文档**复制/回填到本 run 目录：
+5. **禁止**在 Confluence 脚本未跑完或未确认失败前，用本地 Word/原型替代 `source/PRD.md`。
+
+6. 成功后把生成的 `docs/*.md` **主文档**复制/回填到本 run 目录：
    - `source/PRD.md`
 
 ## 直链兜底（可选，非默认）
@@ -49,6 +55,10 @@ python3 confluence-doc.py 2.3.4
 ## 失败排查
 
 - 输出 `❌ 未找到`：到 Confluence 确认页面标题（ADI 常为 `ADI_V2.3.4结算、开票…`，**下划线**而非 `ADI-V`）；可尝试输入更长关键词如 `ADI_V2.3.4结算`
+- 输出 `✗ 命中技术文档标题，拒绝作为 PRD` 或 `跳过技术文档候选` 或 `⚠ 搜索结果均未通过 PRD 校验` 时：
+  - **禁止**手动复制技术/后端/设计页到 `source/PRD.md`
+  - 应在 Confluence 中找到真正的业务 PRD 页面（通常标题含「结算」「开票」「回款」「数据对接」等业务词汇）
+  - 使用该页面的 pageId 或 URL 直链重跑：`CONFLUENCE_PAGE_ID=<正确pageId> python3 confluence-doc.py 2.3.4`
 - 页面存在但搜不到：加 `CONFLUENCE_DEBUG=1` 查看选择器解析日志；或（可选）设置 `CONFLUENCE_PAGE_ID` / `CONFLUENCE_PAGE_URL` 直链下载
 - Playwright 失败且设置 `CONFLUENCE_USE_REST=1` 时才回退 Token；登录最多重试 3 次，并用 `expect_navigation` 避免竞态
 - 登录偶发失败：用 `CONFLUENCE_HEADED=1 CONFLUENCE_SLOW_MO=500` 有头观察；失败截图 `confluence-login-fail-*.png`

package/src/templates/artifacts/02-/351/234/200/346/261/202/345/210/206/346/236/220/346/217/220/347/244/272/350/257/215.template.md

@@ -12,6 +12,7 @@
 - `source/PRD.md` 若仍是占位文本（没有真实 PRD 内容），**禁止**继续 Step2，先返回“Step1 未完成”并停止。
 - 当处于“提问模式”时，**只允许更新** `03-待确认问题清单.md`；**禁止**产出最终版 `01-需求分析报告.md` / `02-改动点清单.md`。
 - 只有当用户明确确认“矛盾点池已闭合”后，才可进入“交付模式”并输出最终版 `01` / `02`。
+- 用户口令 `执行模式：确认后全链路` → `.session-state.json` 中 `executionMode: full-chain`（矛盾点闭合后禁止中途停止）。
 
 ## 输入注入（建议做法）
 - 将 `source/PRD.md` 的内容作为 `{{PRD_MARKDOWN}}` 注入

package/src/templates/artifacts/06-agent-skill.template.md

@@ -46,27 +46,43 @@ npx sdd-flow-kit run --product {{DEFAULT_PRODUCT}} --version <版本号> -y --ag
    - `.cursor/skills/opsx-superpowers-workflow/SKILL.md`
    - `openspec-propose` → `openspec-apply-change` → `pnpm run opsx:delivery-pipeline -- <change>`
 8. TDD/Playwright 遵循 `LAYERED-TESTING.md`（L2 交互契约、L3 每页 E2E）。
+9. **`executionMode=full-chain`（默认）**：矛盾点闭合后 **禁止** 以待办清单结束回合；必须 C→D→E 直至 `deliver` exit 0。
 
-## 严格 SOP 模式（用户声明后强制生效，不可替代）
+## 执行模式（`.session-state.json`）
 
-当用户明确声明「执行模式：严格SOP，不可替代」时，以下规则优先于默认自动串联：
+| 口令 | `executionMode` | `strictCommands` | 行为 |
+|------|-----------------|------------------|------|
+| （默认） | `full-chain` | `false` | 确认后同一回合跑到底 |
+| `执行模式：确认后全链路` | `full-chain` | — | 同上，禁止中途停止 |
+| `执行模式：分阶段确认` | `staged-confirm` | — | 每阶段完成后等人确认 |
+| `执行模式：严格命令` | — | `true` | 禁止等价命令替代 gate 链路 |
+| `严格SOP，不可替代`（兼容） | `staged-confirm` | `true` | 分阶段确认 + 严格命令 |
 
-1. 必须严格按仓库已安装的 `sdd-flow-kit` 流程执行，禁止“等价方式”替代。
-2. Step1 必须执行用户指定的文档获取流程（Confluence/脚本链路）；除非用户明确说“允许替代”，否则禁止用本地文件手动回填代替。
-3. 阶段 B 产出的 `04-技术文档草稿.md` 必须是可执行技术方案，禁止模板占位；且需逐条引用 `05-验收清单.md` 的 AC-ID。
-4. 阶段 C 必须执行 `/opsx-propose`（输入 **05 + 04 + 02 + UI**），禁止用 `npx sdd-flow-kit propose` 代替提案生成。
-5. 每完成一个阶段，必须先输出：`门禁结果 + 证据文件路径 + 下一步命令`，等待用户确认后再继续。
-6. 任一步骤不满足 SOP，必须立即停止并先询问用户，不得自行继续。
-7. 禁止将“门禁通过”视为“流程正确”；必须同时满足：命令正确 + 产物正确 + 顺序正确。
-8. 若需要替代方案，必须先提出并等待用户确认。
+```bash
+npx sdd-flow-kit session mode --run-id <runId> --execution-mode full-chain
+npx sdd-flow-kit chain --run-id <runId> --change <name> --from docs-done
+```
+
+## 回合结束条件
+
+- ✅ 唯一合法出口：`gate shipped` + `deliver` exit 0
+- ⛔ 禁止「骨架已完成」「后续待办」式收尾（`full-chain` 时）
+- ⛔ 禁止在 `tasks.md` 未全 `[x]` 时宣称完成
+
+## 严格命令模式（`strictCommands=true`）
 
-### 严格 SOP 的固定预执行动作
+与是否分阶段暂停**正交**；可与 `full-chain` 组合：
 
-进入每个阶段前，先输出：
+1. 必须严格按 `NEXT.md` 中的 gate/phase 链路执行，禁止“等价方式”替代。
+2. Step1 须走 Confluence/脚本链路；除非用户明确允许，禁止手动回填代替。
+3. 阶段 B 的 `04` 须可执行且逐条引用 AC-ID。
+4. 阶段 C 须 `/opsx-propose`（输入 **05 + 04 + 02 + UI**），禁止仅用 `sdd-flow-kit propose` 代替 AI 提案生成。
 
-`本次计划命令清单（逐条）`
+## 分阶段确认模式（`executionMode=staged-confirm`）
 
-并等待用户确认后再执行命令。
+1. 每阶段前先输出：`本次计划命令清单（逐条）`
+2. 每阶段后输出：`门禁结果 + 证据文件路径 + 下一步命令`
+3. **等待用户确认**后再进入下一阶段
 
 ## 阶段摘要
 

package/src/templates/artifacts/07-opsx-auto-chain.template.md

@@ -2,7 +2,28 @@
 
 > **不要**在阶段 B 结束后停下来问用户「是否继续」或「是否 apply」。  
 > 除非用户明确说「只提案」「先别写代码」，或 `.session-state.json` 中 `autoChainOpsx: false`。
-> 若用户声明「执行模式：严格SOP，不可替代」，则本文件的“自动串联”必须降级为“分阶段确认执行”：每阶段先输出`本次计划命令清单（逐条）`并等待用户确认。
+
+## 执行模式（读 `.session-state.json`）
+
+| `executionMode` | 行为 |
+|-----------------|------|
+| `full-chain`（**默认**） | 矛盾点闭合后 **同一回合** C→D→E，直至 `deliver` exit 0 |
+| `staged-confirm` | 每阶段完成后输出门禁结果，**等待用户确认**再进下一阶段 |
+
+| `strictCommands` | 行为 |
+|------------------|------|
+| `true` | 禁止用等价命令替代 NEXT.md 中的 gate/phase 链路（可与 full-chain 组合） |
+| `false`（默认） | 按 NEXT.md 执行即可 |
+
+**用户口令**：`执行模式：确认后全链路` → `full-chain`；`执行模式：分阶段确认` → `staged-confirm`；`执行模式：严格命令` → `strictCommands: true`。  
+**兼容旧版**：`执行模式：严格SOP，不可替代` → `staged-confirm` + `strictCommands: true`。
+
+## 回合结束条件（唯一合法出口）
+
+- ✅ `gate shipped` 通过 **且** `deliver` exit 0
+- ⛔ **禁止**在 `tasks.md` 未全 `- [x]`、pipeline 未 exit 0 时结束回合
+- ⛔ **禁止**用「后续待办」「骨架已完成」作为结束语
+- 唯一允许暂停：gate exit≠0、prd-remediate 3 次未果、矛盾点未闭合、`staged-confirm` 阶段间确认、`autoChainOpsx=false`
 
 ## 输入（本 runId）
 
@@ -33,18 +54,20 @@
    ```
 5. 更新 `06-openspec-提案草稿.md` 与 `.session-state.json`：`status: propose_done`
 6. **禁止**在本阶段写 `src/` 或跑 delivery-pipeline
-7. 阶段完成后先输出：`门禁结果 + 证据文件路径 + 下一步命令`；严格SOP模式下等待用户确认再进入阶段 D。
+7. 阶段完成后输出：`门禁结果 + 证据文件路径 + 下一步命令`
+8. **`executionMode=staged-confirm` 时**：等待用户确认后再进入阶段 D；**`full-chain` 时不得停止**
 
-## 阶段 D — `/opsx-apply`（ac-ready 后**立即**执行，无需再等用户）
+## 阶段 D — `/opsx-apply`（ac-ready 后执行）
 
-> 严格SOP模式下，本阶段不允许“立即执行”，必须先获得用户确认。
+> `full-chain`：**立即**执行，无需再等用户。`staged-confirm`：须先获得用户确认。
 
 1. `npx sdd-flow-kit ensure-opsx --agent cursor -y`（仓库根）
-2. 写 `.opsx-active-change` = change 名
-3. **Apply 前必读**：`source/PRD.md` 对应章节 + `05-验收清单.md`
-4. 读并执行：`openspec-apply-change` → `tdd-script`（分层测试策略）→ `openspec-superpowers-pipeline` → `opsx-dev-delivery-pipeline`
-5. Red 断言须写死 PRD/05 原文（toast、tooltip、列序等）
-6. `pnpm run opsx:delivery-pipeline -- <change-name>` 直至 **exit 0**
+2. `npx sdd-flow-kit phase advance --to impl --change <name>`
+3. 写 `.opsx-active-change` = change 名
+4. **Apply 前必读**：`source/PRD.md` 对应章节 + `05-验收清单.md`
+5. 读并执行：`openspec-apply-change` → `tdd-script`（分层测试策略）→ `openspec-superpowers-pipeline` → `opsx-dev-delivery-pipeline`
+6. Red 断言须写死 PRD/05 原文（toast、tooltip、列序等）
+7. `pnpm run opsx:delivery-pipeline -- <change-name>` 直至 **exit 0**
 
 ## 阶段 E — PRD 一致性复查 + 脚本语义 diff + 强制验收（交付前）
 
@@ -53,6 +76,7 @@
 3. `npx sdd-flow-kit prd-diff --project-root <repo> --run-id <runId>`（脚本 PRD×代码字面量 diff → `09-PRD语义diff报告.md`）
 4. 若 diff 失败：`prd-remediate --change <name>` 或 `validate` 内置循环（按 09 调 `/opsx-apply` 修，**每项最多 3 次**、每轮只修剩余失败项，重试附带上次错误代码摘要；仍失败 → 08 待人工确认）
 5. `npx sdd-flow-kit gate --project-root <repo> --run-id <runId> --expect prd-coverage`
+6. 机械串联（AI 步骤完成后）：`npx sdd-flow-kit chain --from validate-done --change <name>`
 
 ## 完成判定
 

package/src/templates/prompts/02-sdd-loop-prompt.md

@@ -98,20 +98,21 @@
 #### 路径 B：交付模式 (矛盾点池已闭合)
 > **触发条件**：用户已回复待确认点，或明确表示矛盾点池已闭合（不得在未获用户确认时自行进入）。
 
-**任务（本路径仅文档，不含 openspec，不含写代码）**：
+**任务（阶段 B 文档产出；`full-chain` 模式下不得在本路径结束回合）**：
 1.  更新 `03-待确认问题清单.md`，标注“**矛盾点池状态：已闭合**”，写入用户确认结论。
 2.  **从 `source/PRD.md` 生成 `05-验收清单.md`**（标注「定义状态：已定义」），再生成 `04-技术文档草稿.md`（引用 AC-ID）。
 3.  生成最终版 `01-需求分析报告.md` 和 `02-改动点清单.md`（清单中的路径是**计划**，不得在本回合修改这些文件）。
 4.  确认 `02-改动点清单.md` 中仅包含代码文件改动，不涉及 `openspec/spec/` 内容。
 5.  **禁止** 在阶段 B 内修改 `src/` 等业务代码。
-6.  更新 `.session-state.json`：`status: ready_for_propose`，`phase: B_done`。
-7.  **若 `autoChainOpsx !== false`（默认）且用户未说「只提案」**：同一回合继续读 `07-opsx-自动串联指引.md`，执行 `/opsx-propose`（输入 **05+04+02**+UI）→ `/opsx-apply`；**不要**要求用户再说「继续」。
-8.  仅当 `autoChainOpsx === false` 时输出：`05/01/02/03/04 已更新。回复「继续」进入提案。`
-9.  若用户已声明「执行模式：严格SOP，不可替代」：本路径必须改为“阶段确认制”：
+6.  更新 `.session-state.json`：`status: ready_for_propose`；若用户口令含执行模式，同步 `executionMode` / `strictCommands`。
+7.  执行 `gate docs-closed` → `phase advance --to docs-done`（exit 0 才继续）。
+8.  **若 `autoChainOpsx !== false` 且 `executionMode !== staged-confirm`（默认 full-chain）**：**不得结束回合**，同一回合继续读 `07-opsx-自动串联指引.md`，执行 C→D→E 直至 `deliver` exit 0；**不要**要求用户再说「继续」。
+9.  仅当 `autoChainOpsx === false` 时输出：`05/01/02/03/04 已更新。回复「继续」进入提案。`
+10. **`executionMode=staged-confirm` 时**（含兼容口令「严格SOP，不可替代」）：
     - 每阶段执行前先输出：`本次计划命令清单（逐条）`
     - 每阶段执行后输出：`门禁结果 + 证据文件路径 + 下一步命令`
     - 等待用户确认后再进入下一阶段
-    - 禁止用等价命令替代用户指定命令链路
+11. **`strictCommands=true` 时**：禁止用等价命令替代 NEXT.md 中的 gate/phase 链路（可与 full-chain 组合，不强制每阶段暂停）
 
 ---
 

package/src/templates/rules/sdd-no-implement-until-apply.mdc.template

@@ -24,6 +24,17 @@ alwaysApply: true
    - `npx sdd-flow-kit phase advance --to impl` + `gate --expect impl-allowed`（阶段 D 前）
 4. **禁止**在未执行 `gate prd-coverage`、`gate ac-signed` 与 `npx sdd-flow-kit deliver` 成功前宣称需求开发完成。
 
+## 禁止过早结束（对称于「禁止过早写代码」）
+
+当 `executionMode=full-chain`（默认）且 `autoChainOpsx !== false`：
+
+- **禁止**在 propose/apply/validate/deliver 未完成前结束回合
+- **禁止**输出仅含「后续待办」「骨架已完成」的收尾
+- 矛盾点闭合后须同一回合继续 C→D→E，直至 `deliver` exit 0
+- 唯一允许暂停：gate exit≠0、prd-remediate 需人工裁定、用户说「只提案」
+
+`executionMode=staged-confirm` 时：每阶段完成后可暂停等人确认。
+
 ## docModeOnly
 
 当 `openspec/PRD/*/.session-state.json` 中 `docModeOnly: true`：
@@ -68,6 +79,8 @@ npx sdd-flow-kit validate --project-root <repo> --run-id <runId> --change <name>
 npx sdd-flow-kit gate --project-root <repo> --run-id <runId> --expect ac-signed
 npx sdd-flow-kit deliver --project-root <repo> --run-id <runId> --change <name>
 npx sdd-flow-kit phase advance --project-root <repo> --run-id <runId> --to shipped --change <name>
+# 或机械串联（AI 步骤完成后）：
+npx sdd-flow-kit chain --project-root <repo> --run-id <runId> --change <name> --from docs-done
 ```
 
 ## 分层测试（L1–L4）

package/src/templates/skills/confluence-doc.py.template

@@ -292,10 +292,36 @@ def read_breadcrumb_text(page) -> str:
     return " > ".join(parts)
 
 
+PRD_TECHNICAL_TITLE_MARKERS = (
+    "技术文档",
+    "技术方案",
+    "详细设计",
+    "接口文档",
+    "后端",
+    "数据库",
+    "实现文档",
+    "设计文档",
+    "开发文档",
+    "API文档",
+    "数据结构",
+    "表设计",
+)
+
+
+def has_forbidden_prd_title(title: str) -> bool:
+    """技术文档/后端设计页必须在 PRD 拉取阶段直接拦截。"""
+    title_upper = (title or "").upper()
+    return any(marker.upper() in title_upper for marker in PRD_TECHNICAL_TITLE_MARKERS)
+
+
 def is_adi_requirement_page(title: str, crumbs: str, page_url: str) -> bool:
     """ADI 需求页常无 PRD 字样，标题形如 ADI_V2.3.4结算、开票、回款数据对接欢聚。"""
     title_upper = (title or "").upper()
     crumbs_upper = (crumbs or "").upper()
+
+    if has_forbidden_prd_title(title):
+        print(f"      ✗ 命中技术文档标题，拒绝作为 PRD: {title[:80]}")
+        return False
     if re.search(r"ADI[_-]?V\d+\.\d+\.\d+", title_upper):
         print(f"      ✓ ADI 版本标题命中: {title[:80]}")
         return True
@@ -326,6 +352,10 @@ def is_prd_page(page, page_url: str) -> bool:
     except Exception:
         title = ""
 
+    if has_forbidden_prd_title(title):
+        print(f"      ✗ 命中技术文档标题，拒绝作为 PRD: {title[:80]}")
+        return False
+
     # ADI：标题常无「PRD/需求」字样，单独识别
     if prefix == "ADI" and is_adi_requirement_page(title, crumbs, page_url):
         return True
@@ -445,7 +475,9 @@ def rest_search_candidates(
     for item in data.get("results", []):
         title = (item.get("title") or "").strip()
         page_id = str(item.get("id", ""))
-        if not page_id:
+        if not page_id or has_forbidden_prd_title(title):
+            if title and has_forbidden_prd_title(title):
+                print(f"   跳过技术文档候选: {title[:80]}")
             continue
         href = f"/spaces/{(item.get('space') or {}).get('key', '')}/pages/{page_id}/"
         score = score_link_match(title, href, prefix, version, keyword)
@@ -462,10 +494,13 @@ def rest_resolve_target(
     direct_id = resolve_direct_page_id()
     if direct_id:
         page = rest_fetch_page(base_url, token, direct_id)
+        if has_forbidden_prd_title(page["title"]):
+            print(f"❌ 直链页面不是业务 PRD，命中技术文档黑名单: {page['title']}")
+            print("   请确认提供的 pageId 是业务需求文档，而非技术文档/后端设计文档")
+            raise RuntimeError(f"直链页面不是 PRD，命中技术文档标题: {page['title']}")
         kw = keywords[0] if keywords else f"{prefix}_V{version}"
         return page["id"], page["title"], kw, page["url"]
 
-    fallback: tuple[str, str, str, str] | None = None
     for kw in keywords:
         print(f"\n🔍 [REST] 搜索: {kw}")
         candidates = rest_search_candidates(base_url, token, prefix, version, kw)
@@ -475,17 +510,25 @@ def rest_resolve_target(
         for score, page_id, title in candidates:
             print(f"   候选 (score={score}): {title[:80]}")
             page = rest_fetch_page(base_url, token, page_id)
-            if prefix.upper() == "ADI" and is_adi_title_match(title, version):
+            # 双重校验：标题黑名单 + ADI 特殊规则
+            if has_forbidden_prd_title(page["title"]):
+                print(f"      ✗ 命中技术文档标题，拒绝作为 PRD: {page['title'][:80]}")
+                continue
+            if prefix.upper() == "ADI" and is_adi_title_match(page["title"], version):
+                print(f"      ✓ ADI 业务 PRD 命中")
                 return page_id, page["title"], kw, page["url"]
             if score >= 4:
                 return page_id, page["title"], kw, page["url"]
-            if fallback is None:
-                fallback = (page_id, page["title"], kw, page["url"])
-    return fallback
+    print("   ⚠ REST 搜索结果均未通过 PRD 校验")
+    print("      → 所有候选页面要么是技术/后端/设计文档，要么评分不足")
+    print("      → 不回退到非 PRD 候选；请确认业务需求文档的 pageId")
+    return None
 
 
 def is_adi_title_match(title: str, version: str) -> bool:
     """ADI 长标题页识别（面包屑可无 PRD 字样）。"""
+    if has_forbidden_prd_title(title):
+        return False
     title_upper = (title or "").upper()
     v_compact = version.replace(".", "")
     if re.search(rf"ADI[_-]?V{re.escape(version)}", title_upper):
@@ -702,7 +745,6 @@ def resolve_prd_target(
 ) -> tuple[str | None, str | None, str]:
     """依次用每个关键词搜索，直到找到父级为 PRD 的页面。"""
     seen_urls: set[str] = set()
-    fallback: tuple[str, str, str] | None = None  # url, title, keyword
 
     for kw in keywords:
         print(f"\n🔍 搜索关键词: {kw}")
@@ -720,15 +762,16 @@ def resolve_prd_target(
                     continue
                 seen_urls.add(url)
                 print(f"    · 候选: {title[:70]}")
+                # 先执行标题级黑名单快速拒绝
+                if has_forbidden_prd_title(title):
+                    print(f"      ✗ 命中技术文档标题，拒绝作为 PRD: {title[:80]}")
+                    continue
                 if is_prd_page(page, url):
                     return url, kw, title
-                if fallback is None:
-                    fallback = (url, kw, title)
 
-    if fallback:
-        url, kw, title = fallback
-        print(f"   ⚠ 未找到 PRD 父级，回退使用: {title[:70]}")
-        return url, kw, title
+    print("   ⚠ 搜索结果均未通过 PRD 校验")
+    print("      → 所有候选页面要么是技术/后端/设计文档，要么面包屑不含 PRD 父级")
+    print("      → 不回退到非 PRD 候选；请确认业务需求文档的 Confluence 标题与 pageId")
     return None, None, ""
 
 
@@ -919,8 +962,12 @@ def main():
             return
 
     print("\n❌ PRD 拉取失败：Playwright 与 REST 均未成功。")
-    print("   排查：CONFLUENCE_HEADED=1 CONFLUENCE_SLOW_MO=500 有头模式观察登录")
-    print("   或直链：CONFLUENCE_PAGE_ID=<pageId> python3 confluence-doc.py <版本>")
+    print("   排查：")
+    print("     1. CONFLUENCE_HEADED=1 CONFLUENCE_SLOW_MO=500 有头模式观察登录与搜索结果")
+    print("     2. 到 Confluence 确认业务 PRD 页面的准确标题与 pageId")
+    print("     3. 若搜索命中了技术/后端/设计文档，这些已被黑名单拒绝")
+    print("     4. 使用业务 PRD 的直链重跑：CONFLUENCE_PAGE_ID=<pageId> python3 confluence-doc.py <版本>")
+    print("     5. 禁止手动复制非 PRD 页面到 source/PRD.md")
     sys.exit(1)
 
 
@@ -976,23 +1023,42 @@ def _download_via_playwright(
                     print(f"   已保存调试截图: {debug_path}")
                 except Exception:
                     pass
-                print(f"❌ 未找到 {prefix} {version} 的需求文档。")
+                print(f"❌ 未找到 {prefix} {version} 的业务需求文档（PRD）。")
                 print(
                     "   排查：1) 页面标题是否含 ADI_V2.3.4（下划线，非 ADI-V）及中文后缀"
                 )
                 print(
                     "   2) 依次尝试 ADI_V2.3.4 / ADI-V2.3.4 / ADI_V2.3.4结算 / V2.3.4"
                 )
-                print("   3) 直链：CONFLUENCE_PAGE_ID=109609740 或 CONFLUENCE_PAGE_URL=<完整URL>")
-                print("   4) ADI 页面包屑可能无 PRD 字样，脚本已按 ADI_V* 标题规则识别")
+                print("   3) 若搜索命中了「技术文档」「后端」「详细设计」等页面，这些已被黑名单自动拒绝")
+                print("   4) 直链解决：CONFLUENCE_PAGE_ID=<正确pageId> 或 CONFLUENCE_PAGE_URL=<完整URL>")
+                print("   5) ADI 页面包屑可能无 PRD 字样，脚本已按 ADI_V* 标题规则识别")
+                print("   6) 禁止手动复制技术文档到 source/PRD.md，必须找到真正的业务 PRD")
                 return False
 
             print(f"✅ 命中关键词: {matched_keyword}")
             if matched_title:
                 print(f"   页面: {matched_title[:100]}")
             print(f"   URL: {target_url[:120]}...")
+            
+            # 直链模式下也需检查标题黑名单
+            if direct_url:
+                page.goto(target_url, wait_until="domcontentloaded", timeout=60000)
+                try:
+                    direct_title = page.locator("#title-text").text_content().strip()
+                    if has_forbidden_prd_title(direct_title):
+                        print(f"❌ 直链页面不是业务 PRD，命中技术文档黑名单: {direct_title}")
+                        print("   请确认提供的 pageId/URL 是业务需求文档，而非技术文档/后端设计文档")
+                        raise RuntimeError("直链页面命中技术文档标题，拒绝作为 PRD")
+                except Exception as e:
+                    if "技术文档" in str(e) or "黑名单" in str(e):
+                        raise
+            
             page.goto(target_url, wait_until="networkidle", timeout=60000)
 
+            if not is_prd_page(page, target_url):
+                raise RuntimeError("命中的页面未通过 PRD 校验，疑似技术文档或设计文档")
+
             try:
                 title = page.locator("#title-text").text_content().strip()
             except Exception:

package/src/templates/skills/doc-skill.SKILL.md.template

@@ -2,7 +2,7 @@
 name: {{SKILL_NAME}}
 description: |
   当用户说「获取 {{PRODUCT}} Vx.y.z 需求文档」「下载 {{PRODUCT}}-Vx.y.z PRD」「查询 {{PRODUCT}} x.y.z 版本需求」时触发。
-  自动从 Confluence 搜索对应版本 PRD 页面，下载图片并生成 Markdown 到本仓库 `docs/`。
+  自动从 Confluence 搜索对应版本 PRD 页面；`技术文档`、`后端`、`详细设计` 类页面会被拒绝，避免误下载为 PRD；下载图片并生成 Markdown 到本仓库 `docs/`。
 ---
 
 # {{PRODUCT}} 需求文档获取（docs/{{SKILL_DIR}}）
@@ -60,7 +60,9 @@ python3 confluence-doc.py {{PRODUCT_PREFIX}}_V1.2.3
 4. `{{PRODUCT_PREFIX}}-<版本>`（如 ADI-2.3.2）
 5. `ADI_V<版本>结算`（ADI 长标题页，如 V2.3.4 结算对接欢聚）
 
-每个关键词优先走 **`dosearchsite.action?queryString=...` 专用搜索页**（比首页 `#all-updates` 顶栏搜索稳定）；无结果时再兜底顶栏搜索。匹配时 **标题或 URL 路径** 任一命中即可，并忽略 `-`/`_` 差异；ADI 页按 `ADI_V*` 标题规则识别（面包屑可无 PRD 字样）。
+每个关键词优先走 **`dosearchsite.action?queryString=...` 专用搜索页**（比首页 `#all-updates` 顶栏搜索稳定）；无结果时再兜底顶栏搜索。匹配时先收集 **标题或 URL 路径** 命中的候选，再执行 PRD 类型校验；`技术文档`、`技术方案`、`后端`、`详细设计`、`数据库`、`接口文档` 等页面会被直接拒绝。ADI 页按 `ADI_V*` 标题规则识别（面包屑可无 PRD 字样）。
+
+若所有候选均未通过 PRD 校验，脚本必须失败退出，**禁止回退使用第一个非 PRD 候选**；此时应改用正确 PRD 的 `CONFLUENCE_PAGE_ID` / `CONFLUENCE_PAGE_URL` 直链。
 
 调试搜索解析：