sdd-flow-kit 1.0.14 → 1.0.18

package/README.md

@@ -18,8 +18,9 @@
     检查是否安装  - `ls .cursor/skills/sdd-flow-kit/SKILL.md`
     - `ls .claude/skills/sdd-flow-kit/SKILL.md`
     - `ls docs/*-doc-skill/SKILL.md`
-3.  若仍未生成，执行手动兜底（100%触发初始化）：
-    - `node ./node_modules/sdd-flow-kit/dist/postinstall.js`
+3.  若 skill 未生成，执行手动兜底：
+    - `node ./node_modules/sdd-flow-kit/dist/postinstall.js`（轻量，秒级）
+    - 或 `npx sdd-flow-kit install -y`（完整环境）
     
 4.  （可选）预演安装：`npx sdd-flow-kit install --dry-run --plan-json`
 5.  （可选）环境健检：`npx sdd-flow-kit doctor --agent claude-code`
@@ -44,7 +45,11 @@
 
 团队推荐安装命令（稳妥）：
 
-`pnpm add -D sdd-flow-kit && pnpm rebuild sdd-flow-kit`
+`pnpm add -D sdd-flow-kit`
+
+> `postinstall` 仅做**轻量**初始化（写入 skill / Cursor 规则 / docs-skill / `.opsx/config.json`），**不会**交互提问，也**不会**跑 `npx opsx-workflow`（避免 `pnpm i` 卡住）。  
+> 完整环境（分支切换 + opsx-workflow）请另执行：`npx sdd-flow-kit install -y`  
+> 跳过 postinstall：`SDD_FLOW_KIT_SKIP_POSTINSTALL=1 pnpm add -D sdd-flow-kit`
 
 #### 使用说明
 
@@ -56,6 +61,22 @@
 
 阶段口语（可选，非必须）：`继续` / `做提案` → propose；`开始 apply` → 实现。
 
+##### `/opsx-apply` 与 TDD + Playwright 检查机制
+
+| 环节 | 实现 | 说明 |
+|------|------|------|
+| 安装时 | `postinstall`（light） | 只写 sdd skill/rule；**不**自动跑 opsx-workflow（避免 `pnpm i` 卡住） |
+| 完整安装 | `npx sdd-flow-kit install -y` | 缺什么跑什么 → `ensureOpsxWorkflow` → `npx @lixin5257xxx/opsx-workflow setup` |
+| Apply 前 | `npx sdd-flow-kit ensure-opsx -y` | **阶段 D 第 0 步**；doctor 加 `--fix` 等价修复 |
+| Apply 时 | Cursor 读 skill 链 + `pnpm run opsx:delivery-pipeline` | 由 `AGENTS.md` / `06-agent-skill` 约束 AI，非 Node 自动执行 |
+
+```bash
+npx sdd-flow-kit ensure-opsx --agent cursor -y   # /opsx-apply 前
+npx sdd-flow-kit doctor --agent cursor --fix     # 检查并尝试修复
+```
+
+常见遗漏：只 `pnpm add sdd-flow-kit` 未跑 `ensure-opsx`；或 AI 跳过 skill 直接改代码。
+
 1.  `install`（等价 `setup`）：提示选择开发环境（cursor/claude-code/codex/openclaw，默认 claude-code）与开发分支（无则自动创建），并检测/安装 openspec+superpower 基础环境，同时写入项目级 Skill 与 Cursor 门禁规则
 2.  安装完成后，本工具主要负责“流程环境与模板”落地；业务需求由你在目标 AI 工具中自然语言驱动
 3.  `start`/`run`/`invoke` 属于进阶能力（脚本化或一键编排时使用）

package/dist/cli.js

@@ -41,7 +41,11 @@ function printHelp() {
         "   npx sdd-flow-kit invoke \"开发 XXX 1.2.3 需求\"",
         "",
         "5) 环境健检：",
-        "   npx sdd-flow-kit doctor --agent claude-code",
+        "   npx sdd-flow-kit doctor --agent cursor",
+        "",
+        "6) Apply 前确保 OPSX+TDD+Playwright（/opsx-apply 前必须）：",
+        "   npx sdd-flow-kit ensure-opsx --agent cursor -y",
+        "   （缺省时自动 npx @lixin5257xxx/opsx-workflow setup）",
         "",
         "可选参数：",
         "   --projectRoot <path>   目标项目根目录（默认当前目录）",
@@ -67,6 +71,7 @@ async function main() {
         cmd !== "setup" &&
         cmd !== "install" &&
         cmd !== "doctor" &&
+        cmd !== "ensure-opsx" &&
         cmd !== "invoke") {
         printHelp();
         node_process_1.default.exitCode = 1;
@@ -96,10 +101,16 @@ async function main() {
         node_process_1.default.exitCode = 1;
         return;
     }
-    if (cmd === "doctor") {
-        const doctor = await (0, doctor_1.runDoctor)({ projectRoot: node_path_1.default.resolve(projectRoot), agent });
+    if (cmd === "doctor" || cmd === "ensure-opsx") {
+        const fix = cmd === "ensure-opsx" || node_process_1.default.argv.includes("--fix");
+        const doctor = await (0, doctor_1.runDoctor)({
+            projectRoot: node_path_1.default.resolve(projectRoot),
+            agent,
+            fix,
+            dryRun,
+        });
         // eslint-disable-next-line no-console
-        console.log(`doctor=${doctor.ok ? "ok" : "failed"}, agent=${agent}`);
+        console.log(`${cmd}=${doctor.ok ? "ok" : "failed"}, agent=${agent}${fix ? ", fix=on" : ""}`);
         for (const check of doctor.checks) {
             // eslint-disable-next-line no-console
             console.log(`[${check.ok ? "OK" : "FAIL"}] ${check.name}: ${check.detail}`);
@@ -108,6 +119,15 @@ async function main() {
             // eslint-disable-next-line no-console
             console.log(JSON.stringify({ command: "doctor", projectRoot: node_path_1.default.resolve(projectRoot), result: doctor }, null, 2));
         }
+        if (cmd === "ensure-opsx" && !dryRun) {
+            await (0, setupProject_1.setupProject)({
+                projectRoot: node_path_1.default.resolve(projectRoot),
+                agent,
+                yes: true,
+                light: true,
+                projectKind: projectKind,
+            });
+        }
         if (!doctor.ok)
             node_process_1.default.exitCode = 1;
         return;

package/dist/core/opsxDelivery.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliveryPipelineNpmScripts = deliveryPipelineNpmScripts;
+exports.pathExists = pathExists;
+exports.resolveOpsxAgent = resolveOpsxAgent;
+exports.repairOpsxDeliveryScripts = repairOpsxDeliveryScripts;
+exports.buildOpsxWorkflowSetupCommand = buildOpsxWorkflowSetupCommand;
+exports.isOpsxApplyReady = isOpsxApplyReady;
+exports.ensureOpsxWorkflow = ensureOpsxWorkflow;
+exports.collectDeliverySetupChecks = collectDeliverySetupChecks;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+const DELIVERY_SCRIPT_REL = ".cursor/skills/opsx-dev-delivery-pipeline/scripts/opsx-delivery-pipeline.sh";
+function deliveryPipelineNpmScripts() {
+    const full = `bash ${DELIVERY_SCRIPT_REL}`;
+    const short = `OPSX_PIPELINE_MODE=short ${full}`;
+    return { full, short };
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 优先使用已安装 OPSX skills 的 editor 目录 */
+async function resolveOpsxAgent(projectRoot, preferred) {
+    const deliverySkill = node_path_1.default.join(projectRoot, ".cursor", "skills", "opsx-dev-delivery-pipeline", "SKILL.md");
+    if (await pathExists(deliverySkill))
+        return "cursor";
+    const claudeDelivery = node_path_1.default.join(projectRoot, ".claude", "skills", "opsx-dev-delivery-pipeline", "SKILL.md");
+    if (await pathExists(claudeDelivery))
+        return "claude-code";
+    if (await pathExists(node_path_1.default.join(projectRoot, ".cursor")))
+        return "cursor";
+    if (await pathExists(node_path_1.default.join(projectRoot, ".claude")))
+        return "claude-code";
+    return preferred;
+}
+/** 将 package.json 中过期的 poquan-delivery-pipeline 脚本修正为 opsx-dev-delivery-pipeline */
+async function repairOpsxDeliveryScripts(projectRoot) {
+    const pkgPath = node_path_1.default.join(projectRoot, "package.json");
+    if (!(await pathExists(pkgPath)))
+        return false;
+    const scriptOnDisk = node_path_1.default.join(projectRoot, DELIVERY_SCRIPT_REL);
+    if (!(await pathExists(scriptOnDisk)))
+        return false;
+    const { full, short } = deliveryPipelineNpmScripts();
+    const text = await promises_1.default.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(text);
+    if (!pkg.scripts)
+        pkg.scripts = {};
+    let changed = false;
+    const needsFix = (v) => !v || v.includes("poquan-dev-delivery-pipeline") || v.includes("poquan-delivery-pipeline");
+    if (needsFix(pkg.scripts["opsx:delivery-pipeline"])) {
+        pkg.scripts["opsx:delivery-pipeline"] = full;
+        changed = true;
+    }
+    if (needsFix(pkg.scripts["opsx:delivery-pipeline:short"])) {
+        pkg.scripts["opsx:delivery-pipeline:short"] = short;
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await (0, fs_1.writeTextFileEnsuredDir)(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    return true;
+}
+function hasCommand(cmd) {
+    return (0, node_child_process_1.spawnSync)("which", [cmd], { stdio: "ignore" }).status === 0;
+}
+function buildOpsxWorkflowSetupCommand(projectRoot, agent) {
+    const baseArgs = ["@lixin5257xxx/opsx-workflow", "setup"];
+    if (agent === "cursor") {
+        return {
+            cmd: "npx",
+            args: [...baseArgs, "--editor", "cursor", "--project", projectRoot, "-y"],
+        };
+    }
+    if (agent === "claude-code") {
+        return { cmd: "npx", args: [...baseArgs, "--editor", "claude-code", "-y"] };
+    }
+    if (agent === "openclaw") {
+        return { cmd: "npx", args: [...baseArgs, "--editor", "openclaw", "-y"] };
+    }
+    return { cmd: "npx", args: [...baseArgs, "--editor", "codex", "-y"] };
+}
+async function isOpsxApplyReady(projectRoot) {
+    const checks = await collectDeliverySetupChecks(projectRoot);
+    return checks.every((c) => c.ok);
+}
+/** 缺 openspec/TDD/Playwright 工作流时安装 @lixin5257xxx/opsx-workflow，并修复 delivery 脚本 */
+async function ensureOpsxWorkflow(options) {
+    const plannedActions = [];
+    let checks = await collectDeliverySetupChecks(options.projectRoot);
+    if (checks.every((c) => c.ok)) {
+        return {
+            ready: true,
+            workflowInstalled: false,
+            repairedScripts: false,
+            checks,
+            plannedActions,
+        };
+    }
+    const agent = await resolveOpsxAgent(options.projectRoot, options.agent);
+    const { cmd, args } = buildOpsxWorkflowSetupCommand(options.projectRoot, agent);
+    plannedActions.push(`missing opsx apply stack → run: ${cmd} ${args.join(" ")}`);
+    if (options.dryRun) {
+        return {
+            ready: false,
+            workflowInstalled: false,
+            repairedScripts: false,
+            checks,
+            plannedActions,
+        };
+    }
+    const ret = (0, node_child_process_1.spawnSync)(cmd, args, {
+        cwd: options.projectRoot,
+        stdio: "inherit",
+        env: process.env,
+    });
+    if (ret.status !== 0) {
+        throw new Error(`opsx-workflow 安装失败：${cmd} ${args.join(" ")}`);
+    }
+    const repairedScripts = await repairOpsxDeliveryScripts(options.projectRoot);
+    if (repairedScripts) {
+        plannedActions.push("repaired package.json opsx:delivery-pipeline scripts");
+    }
+    checks = await collectDeliverySetupChecks(options.projectRoot);
+    return {
+        ready: checks.every((c) => c.ok),
+        workflowInstalled: true,
+        repairedScripts,
+        checks,
+        plannedActions,
+    };
+}
+async function collectDeliverySetupChecks(projectRoot) {
+    const checks = [];
+    checks.push({
+        name: "openspec-dir",
+        ok: await pathExists(node_path_1.default.join(projectRoot, "openspec")),
+        detail: "openspec/ 目录",
+    });
+    checks.push({
+        name: "openspec-cli",
+        ok: hasCommand("openspec"),
+        detail: "openspec CLI（npx openspec 或全局安装）",
+    });
+    const skillPath = node_path_1.default.join(projectRoot, ".cursor", "skills", "opsx-dev-delivery-pipeline", "SKILL.md");
+    checks.push({
+        name: "opsx-dev-delivery-pipeline-skill",
+        ok: await pathExists(skillPath),
+        detail: skillPath,
+    });
+    const tddPath = node_path_1.default.join(projectRoot, ".cursor", "skills", "tdd-script", "SKILL.md");
+    checks.push({
+        name: "tdd-script-skill",
+        ok: await pathExists(tddPath),
+        detail: tddPath,
+    });
+    const applyPath = node_path_1.default.join(projectRoot, ".cursor", "skills", "openspec-apply-change", "SKILL.md");
+    checks.push({
+        name: "openspec-apply-change-skill",
+        ok: await pathExists(applyPath),
+        detail: applyPath,
+    });
+    const pipelineScript = node_path_1.default.join(projectRoot, DELIVERY_SCRIPT_REL);
+    checks.push({
+        name: "delivery-pipeline-script",
+        ok: await pathExists(pipelineScript),
+        detail: pipelineScript,
+    });
+    try {
+        const pkgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8");
+        const pkg = JSON.parse(pkgText);
+        const cmd = pkg.scripts?.["opsx:delivery-pipeline"] ?? "";
+        const ok = cmd.includes("opsx-dev-delivery-pipeline") &&
+            cmd.includes("opsx-delivery-pipeline.sh") &&
+            !cmd.includes("poquan");
+        checks.push({
+            name: "package-json-delivery-script",
+            ok,
+            detail: ok ? cmd : `错误或缺失: ${cmd || "(empty)"}`,
+        });
+    }
+    catch {
+        checks.push({
+            name: "package-json-delivery-script",
+            ok: false,
+            detail: "无法读取 package.json",
+        });
+    }
+    try {
+        const cfgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, ".opsx", "config.json"), "utf8");
+        const cfg = JSON.parse(cfgText);
+        const skillsDir = cfg.skillsDir ?? "";
+        const hasCursorDelivery = await pathExists(node_path_1.default.join(projectRoot, ".cursor", "skills", "opsx-dev-delivery-pipeline", "SKILL.md"));
+        const nameOk = cfg.deliveryPipeline?.skillName === "opsx-dev-delivery-pipeline";
+        const dirOk = (hasCursorDelivery && skillsDir.includes(".cursor")) ||
+            (!hasCursorDelivery && (skillsDir.includes(".cursor") || skillsDir.includes(".claude")));
+        checks.push({
+            name: "opsx-config-skills-dir",
+            ok: nameOk && dirOk,
+            detail: hasCursorDelivery && !skillsDir.includes(".cursor")
+                ? `skills 在 .cursor 但 config 指向 ${skillsDir}，请 npx sdd-flow-kit install -y`
+                : `skillsDir=${skillsDir}, skillName=${cfg.deliveryPipeline?.skillName ?? ""}`,
+        });
+    }
+    catch {
+        checks.push({
+            name: "opsx-config",
+            ok: false,
+            detail: ".opsx/config.json 缺失",
+        });
+    }
+    try {
+        const pkgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8");
+        const pkg = JSON.parse(pkgText);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const hasPw = Boolean(deps["@playwright/test"] || deps.playwright);
+        checks.push({
+            name: "playwright-dependency",
+            ok: hasPw,
+            detail: hasPw ? "@playwright/test 或 playwright 已声明" : "package.json 缺少 Playwright 依赖",
+        });
+    }
+    catch {
+        checks.push({
+            name: "playwright-dependency",
+            ok: false,
+            detail: "无法读取 package.json 检查 Playwright",
+        });
+    }
+    const agentsMd = node_path_1.default.join(projectRoot, "AGENTS.md");
+    checks.push({
+        name: "agents-md",
+        ok: await pathExists(agentsMd),
+        detail: "AGENTS.md（Apply/TDD/pipeline 编排 SSOT）",
+    });
+    return checks;
+}

package/dist/postinstall.js

@@ -6,15 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_process_1 = __importDefault(require("node:process"));
+const opsxDelivery_1 = require("./core/opsxDelivery");
 const setupProject_1 = require("./steps/setupProject");
 const ALLOWED_PROJECTS = ["OMS", "ADI", "欢盟", "AD Tools"];
-function resolveProjectKindFromEnv() {
-    const raw = (node_process_1.default.env.SDD_FLOW_KIT_PROJECT ?? "").trim();
-    if (ALLOWED_PROJECTS.includes(raw)) {
-        return raw;
-    }
-    return "OMS";
-}
 async function inferProjectKind(projectRoot) {
     const fromEnv = (node_process_1.default.env.SDD_FLOW_KIT_PROJECT ?? "").trim();
     if (ALLOWED_PROJECTS.includes(fromEnv)) {
@@ -30,7 +24,6 @@ async function inferProjectKind(projectRoot) {
         return "欢盟";
     if (hit("ad-tools") || hit("adtools") || hit("tools"))
         return "AD Tools";
-    // 尝试读取项目 package.json 的 name 做二次推断
     try {
         const pkgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8");
         const pkg = JSON.parse(pkgText);
@@ -50,33 +43,71 @@ async function inferProjectKind(projectRoot) {
     }
     return "OMS";
 }
+async function inferAgent(projectRoot) {
+    const fromEnv = (node_process_1.default.env.SDD_FLOW_KIT_AGENT ?? "").trim();
+    const allowed = ["cursor", "claude-code", "codex", "openclaw"];
+    if (allowed.includes(fromEnv))
+        return fromEnv;
+    const exists = async (rel) => {
+        try {
+            await promises_1.default.access(node_path_1.default.join(projectRoot, rel));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (await exists(".cursor"))
+        return "cursor";
+    if (await exists(".claude"))
+        return "claude-code";
+    if (await exists(".codex"))
+        return "codex";
+    if (await exists(".openclaw"))
+        return "openclaw";
+    return "cursor";
+}
 async function main() {
-    // npm/pnpm 安装依赖时，INIT_CWD 指向用户项目根目录。
+    if (node_process_1.default.env.SDD_FLOW_KIT_SKIP_POSTINSTALL === "1") {
+        return;
+    }
     const initCwd = node_process_1.default.env.INIT_CWD ? node_path_1.default.resolve(node_process_1.default.env.INIT_CWD) : null;
     const pkgDir = node_path_1.default.resolve(__dirname, "..");
     const projectRoot = initCwd ?? node_process_1.default.cwd();
-    // 避免在本包自身仓库开发安装依赖时重复触发自动初始化。
     if (projectRoot === pkgDir)
         return;
-    const isInteractive = Boolean(node_process_1.default.stdin.isTTY && node_process_1.default.stdout.isTTY);
     const projectKind = await inferProjectKind(projectRoot);
+    const agent = await inferAgent(projectRoot);
     // eslint-disable-next-line no-console
-    console.log(`[sdd-flow-kit] postinstall bootstrap at: ${projectRoot}`);
+    console.log(`[sdd-flow-kit] postinstall (light) at: ${projectRoot}`);
     // eslint-disable-next-line no-console
-    console.log(`[sdd-flow-kit] interactive=${isInteractive}, inferredProject=${projectKind}`);
+    console.log(`[sdd-flow-kit] agent=${agent}, project=${projectKind}`);
     await (0, setupProject_1.setupProject)({
         projectRoot,
-        agent: "claude-code",
-        // 交互安装允许用户在 setupProject 内选择 agent/project/branch
-        yes: !isInteractive,
+        agent,
+        yes: true,
+        light: true,
         dryRun: false,
         projectKind,
     });
+    const repaired = await (0, opsxDelivery_1.repairOpsxDeliveryScripts)(projectRoot);
+    if (repaired) {
+        // eslint-disable-next-line no-console
+        console.log("[sdd-flow-kit] repaired package.json opsx:delivery-pipeline scripts");
+    }
+    const ready = await (0, opsxDelivery_1.isOpsxApplyReady)(projectRoot);
+    if (!ready) {
+        // eslint-disable-next-line no-console
+        console.warn("[sdd-flow-kit] OPSX/TDD/Playwright 工作流未就绪。/opsx-apply 前请执行: npx sdd-flow-kit ensure-opsx -y");
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log("[sdd-flow-kit] opsx apply stack ready");
+    }
     // eslint-disable-next-line no-console
-    console.log("[sdd-flow-kit] setup completed");
+    console.log("[sdd-flow-kit] light setup done (skills/rules). Full install: npx sdd-flow-kit install -y");
 }
 main().catch((err) => {
-    // 不阻断依赖安装，仅告警
     // eslint-disable-next-line no-console
     console.warn("[sdd-flow-kit] postinstall setup skipped:", err instanceof Error ? err.message : err);
 });

package/dist/steps/doctor.js

@@ -7,6 +7,7 @@ exports.runDoctor = runDoctor;
 const node_child_process_1 = require("node:child_process");
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const opsxDelivery_1 = require("../core/opsxDelivery");
 function hasCommand(cmd) {
     const out = (0, node_child_process_1.spawnSync)("which", [cmd], { stdio: "ignore" });
     return out.status === 0;
@@ -71,6 +72,28 @@ async function runDoctor(options) {
             detail: `${expectedDir} 目录存在性`,
         });
     }
-    const ok = checks.every((c) => c.ok);
+    for (const c of await (0, opsxDelivery_1.collectDeliverySetupChecks)(options.projectRoot)) {
+        checks.push(c);
+    }
+    let ok = checks.every((c) => c.ok);
+    if (!ok && options.fix) {
+        const ensured = await (0, opsxDelivery_1.ensureOpsxWorkflow)({
+            projectRoot: options.projectRoot,
+            agent: options.agent,
+            dryRun: options.dryRun,
+        });
+        checks.length = 0;
+        for (const c of ensured.checks) {
+            checks.push(c);
+        }
+        if (ensured.plannedActions.length > 0) {
+            checks.push({
+                name: "ensure-opsx-actions",
+                ok: ensured.ready,
+                detail: ensured.plannedActions.join(" | "),
+            });
+        }
+        ok = checks.every((c) => c.ok);
+    }
     return { ok, checks };
 }

package/dist/steps/setupProject.js

@@ -5,11 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupProject = setupProject;
 const node_child_process_1 = require("node:child_process");
-const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
-const promises_2 = require("node:readline/promises");
+const promises_1 = require("node:readline/promises");
 const node_process_1 = __importDefault(require("node:process"));
 const fs_1 = require("../core/fs");
+const opsxDelivery_1 = require("../core/opsxDelivery");
 const templates_1 = require("../core/templates");
 const EDITOR_CHOICES = ["claude-code", "cursor", "codex", "openclaw"];
 const PROJECT_CHOICES = ["OMS", "ADI", "欢盟", "AD Tools"];
@@ -47,7 +47,7 @@ function listLocalBranches(projectRoot) {
 async function askAgent(defaultAgent) {
     if (!node_process_1.default.stdin.isTTY)
         return defaultAgent;
-    const rl = (0, promises_2.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
     const prompt = [
         "请选择开发环境：",
         "1) claude-code (default)",
@@ -68,7 +68,7 @@ async function askAgent(defaultAgent) {
 async function askBranch(defaultBranch) {
     if (!node_process_1.default.stdin.isTTY)
         return defaultBranch;
-    const rl = (0, promises_2.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
     const answer = (await rl.question(`请输入开发分支（默认 ${defaultBranch}）：\n`)).trim();
     rl.close();
     return answer || defaultBranch;
@@ -76,7 +76,7 @@ async function askBranch(defaultBranch) {
 async function askProjectKind(defaultKind) {
     if (!node_process_1.default.stdin.isTTY)
         return defaultKind;
-    const rl = (0, promises_2.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
     const prompt = [
         "请选择当前项目类型（用于生成 PRD 下载 skill）：",
         "1) OMS (default)",
@@ -94,50 +94,6 @@ async function askProjectKind(defaultKind) {
         return defaultKind;
     return PROJECT_CHOICES[idx - 1];
 }
-function isEditorEnvironmentReady(projectRoot, agent) {
-    const checks = {
-        cursor: ["openspec", ".cursor"],
-        "claude-code": ["openspec", ".claude"],
-        codex: ["openspec", ".codex"],
-        openclaw: ["openspec", ".openclaw"],
-        custom: ["openspec"],
-    };
-    const targetPaths = checks[agent] ?? ["openspec"];
-    return Promise.all(targetPaths.map(async (p) => {
-        try {
-            await promises_1.default.access(node_path_1.default.join(projectRoot, p));
-            return true;
-        }
-        catch {
-            return false;
-        }
-    })).then((arr) => arr.every(Boolean));
-}
-function buildSetupCommand(projectRoot, agent) {
-    const baseArgs = ["@lixin5257xxx/opsx-workflow", "setup"];
-    if (agent === "cursor") {
-        return {
-            cmd: "npx",
-            args: [...baseArgs, "--editor", "cursor", "--project", projectRoot, "-y"],
-        };
-    }
-    if (agent === "claude-code") {
-        return {
-            cmd: "npx",
-            args: [...baseArgs, "--editor", "claude-code", "-y"],
-        };
-    }
-    if (agent === "openclaw") {
-        return {
-            cmd: "npx",
-            args: [...baseArgs, "--editor", "openclaw", "-y"],
-        };
-    }
-    return {
-        cmd: "npx",
-        args: [...baseArgs, "--editor", "codex", "-y"],
-    };
-}
 function ensureBranch(projectRoot, branch) {
     const branches = listLocalBranches(projectRoot);
     if (branches.includes(branch)) {
@@ -241,7 +197,8 @@ function getOpsxPathsByAgent(agent) {
 }
 async function installOpsxConfig(projectRoot, agent) {
     const target = node_path_1.default.join(projectRoot, ".opsx", "config.json");
-    const paths = getOpsxPathsByAgent(agent);
+    const resolvedAgent = await (0, opsxDelivery_1.resolveOpsxAgent)(projectRoot, agent);
+    const paths = getOpsxPathsByAgent(resolvedAgent);
     const config = {
         version: 1,
         editor: paths.editor,
@@ -268,39 +225,43 @@ async function setupProject(options) {
     const plannedActions = [];
     const branches = listLocalBranches(options.projectRoot);
     const branchExists = branches.includes(selectedBranch);
-    const branchResult = options.dryRun
-        ? { branch: selectedBranch, created: !branchExists }
-        : ensureBranch(options.projectRoot, selectedBranch);
-    if (options.dryRun) {
+    let branchResult;
+    if (options.light) {
+        branchResult = { branch: selectedBranch, created: false };
+        plannedActions.push("light mode: skipped git branch checkout");
+    }
+    else if (options.dryRun) {
+        branchResult = { branch: selectedBranch, created: !branchExists };
         plannedActions.push(branchExists
             ? `would checkout existing branch: ${selectedBranch}`
             : `would create and checkout branch: ${selectedBranch}`);
     }
-    let environmentReady = await isEditorEnvironmentReady(options.projectRoot, selectedAgent);
+    else {
+        branchResult = ensureBranch(options.projectRoot, selectedBranch);
+    }
+    let environmentReady = await (0, opsxDelivery_1.isOpsxApplyReady)(options.projectRoot);
     let setupExecuted = false;
     let skillInstalled = false;
     let docsSkillInstalled = false;
     let opsxConfigInstalled = false;
-    if (!environmentReady) {
-        const { cmd, args } = buildSetupCommand(options.projectRoot, selectedAgent);
-        if (options.dryRun) {
-            plannedActions.push(`would run: ${cmd} ${args.join(" ")}`);
-        }
-        else {
-            const ret = (0, node_child_process_1.spawnSync)(cmd, args, {
-                cwd: options.projectRoot,
-                stdio: "inherit",
-                env: node_process_1.default.env,
-            });
-            if (ret.status !== 0) {
-                throw new Error(`环境安装失败：${cmd} ${args.join(" ")}`);
-            }
-            setupExecuted = true;
-            environmentReady = await isEditorEnvironmentReady(options.projectRoot, selectedAgent);
+    if (options.light) {
+        plannedActions.push("light mode: skipped npx @lixin5257xxx/opsx-workflow setup");
+        if (!environmentReady) {
+            plannedActions.push("opsx apply stack incomplete → run: npx sdd-flow-kit ensure-opsx -y (before /opsx-apply)");
         }
     }
+    else if (!environmentReady) {
+        const ensured = await (0, opsxDelivery_1.ensureOpsxWorkflow)({
+            projectRoot: options.projectRoot,
+            agent: selectedAgent,
+            dryRun: options.dryRun,
+        });
+        plannedActions.push(...ensured.plannedActions);
+        setupExecuted = ensured.workflowInstalled;
+        environmentReady = ensured.ready;
+    }
     else if (options.dryRun) {
-        plannedActions.push("environment already ready, no setup needed");
+        plannedActions.push("opsx apply stack already ready");
     }
     if (options.dryRun) {
         for (const skillPath of allSkillInstallPaths(options.projectRoot)) {
@@ -319,6 +280,10 @@ async function setupProject(options) {
         docsSkillInstalled = true;
         await installOpsxConfig(options.projectRoot, selectedAgent);
         opsxConfigInstalled = true;
+        const repaired = await (0, opsxDelivery_1.repairOpsxDeliveryScripts)(options.projectRoot);
+        if (repaired) {
+            plannedActions.push("repaired package.json opsx:delivery-pipeline scripts (poquan → opsx)");
+        }
     }
     const summary = [
         "# SETUP-SUMMARY",
@@ -332,6 +297,7 @@ async function setupProject(options) {
         `skillInstalled: ${skillInstalled}`,
         `docsSkillInstalled: ${docsSkillInstalled}`,
         `opsxConfigInstalled: ${opsxConfigInstalled}`,
+        `light: ${Boolean(options.light)}`,
         `dryRun: ${Boolean(options.dryRun)}`,
         "",
         "plannedActions:",

package/dist/steps/startFlow.js

@@ -106,10 +106,10 @@ async function startFlowScaffold(options) {
         "产出在 `openspec/changes/<change-name>/`；在 `05-openspec-提案草稿.md` 记录 change 名称。",
         "门禁：仅当 03 已闭环且 01/02/04 完成后执行。",
         "",
-        "## Step 6：/opsx-apply 实现收尾",
-        "提案 apply-ready 后，按 `.opsx/config.json` 执行 `/opsx-apply` 对应 change 的 apply 与 delivery-pipeline。",
-        "必须在当前仓库本地 OPSX 配置下执行，禁止跨仓 fallback。",
-        "门禁：delivery-pipeline exit 0 前禁止宣称流程结束。",
+        "## Step 6：Apply + TDD + Playwright（阶段 D）",
+        "依次执行 skill：`openspec-apply-change` → `tdd-script` → `openspec-superpowers-pipeline` → `opsx-dev-delivery-pipeline`。",
+        "仓库根执行：`pnpm run opsx:delivery-pipeline -- <change-name>`（须 exit 0）。",
+        "禁止跳过 TDD / Playwright 裸写代码收尾。详见 `.cursor/skills/sdd-flow-kit/SKILL.md` 阶段 D。",
     ].join("\n"));
     return {
         runId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-flow-kit",
-  "version": "1.0.14",
+  "version": "1.0.18",
   "private": false,
   "description": "Cross-agent SDD automated development workflow kit (ADI/ADI-like).",
   "license": "MIT",

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

@@ -97,13 +97,32 @@ description: 开发某版本需求、SDD 流程、待确认问题澄清、用户
 
 ---
 
-### 阶段 D — `/opsx-apply`（实现与交付收尾）
-**触发条件**：阶段 C 的 openspec 提案已生成且状态为 apply-ready。
-
-**必须执行：**
-1. 按总编排 skill（`.opsx/config.json` 中 `deliveryPipeline` 指向的 skill）执行 **`/opsx-apply`**
-2. 在当前仓库根目录跑 delivery-pipeline（如 `pnpm run opsx:delivery-pipeline -- <change-name>`）
-3. **仅在 pipeline 成功（exit 0）后** 才可宣称本需求开发流程结束
+### 阶段 D — Apply + TDD + Playwright 交付（禁止裸写代码收尾）
+**触发条件**：阶段 C 的 openspec 提案已 apply-ready，且用户同意实现（如「开始 apply」）。
+
+**严禁**：跳过 skill 链、不按 `tasks.md` TDD、不跑 delivery-pipeline 就改 `src/` 并宣称完成。
+
+**必须按顺序执行（以仓库根 `AGENTS.md` 与 `.cursor/skills/` 为准）：**
+
+0. **环境门禁（缺则自动安装，不可跳过）** — 在仓库根执行：
+   ```bash
+   npx sdd-flow-kit ensure-opsx --agent cursor -y
+   ```
+   - 检测：openspec、TDD/Playwright skills、`opsx:delivery-pipeline` 脚本、`AGENTS.md` 等。
+   - 若 FAIL：上述命令会运行 `npx @lixin5257xxx/opsx-workflow setup ...` 安装工作流；**exit 0 前不得开始改 `src/`**。
+1. 读取 `AGENTS.md`、`docs/agent-workflow.md`、`.opsx/config.json`。
+2. 绑定 change 名：写入 `.opsx-active-change`（一行 kebab-case），或 `export OPSX_ACTIVE_CHANGE=<name>`。
+3. **依次读取并执行**（不可省略）：
+   - `.cursor/skills/openspec-apply-change/SKILL.md` — `openspec instructions apply --change "<name>" --json`
+   - `.cursor/skills/tdd-script/SKILL.md` — **每项 task 先测后实现**，并勾选 `tasks.md` 的 `- [x]`
+   - `.cursor/skills/openspec-superpowers-pipeline/SKILL.md` — Delta Spec / 代码质量审查门控
+   - `.cursor/skills/opsx-dev-delivery-pipeline/SKILL.md` — 机械交付脚本（TDD 门禁 → validate → **Playwright** → archive）
+4. 在**仓库根**（含 `package.json` 的目录）执行：
+   ```bash
+   pnpm run opsx:delivery-pipeline -- <change-name>
+   ```
+   脚本路径须为：`.cursor/skills/opsx-dev-delivery-pipeline/scripts/opsx-delivery-pipeline.sh`（若 `package.json` 仍指向 `poquan-*`，先运行 `npx sdd-flow-kit install -y` 修复）。
+5. **完成判定**：`tasks.md` 全部 `- [x]` **且** 上一条命令 **exit 0**。否则不得宣称 SDD 流程结束。
 
 ---