@guanlin4924/devflow-pi 0.1.12 → 0.1.14

package/README.md

@@ -29,9 +29,6 @@ devflow-pi
 /devflow explain-state
 /devflow recover
 /devflow start <feature>|<phase>
-/devflow continue
-/devflow advance
-/devflow checkpoint
 /devflow resume
 /devflow-usage
 /usage-stats
@@ -118,7 +115,7 @@ bash .skills/install.sh --apply --force-config
 
 首次使用时，在 OMP 的模型角色界面中分别为 `smol`、`task`、`slow` 选择具体模型；`modelRoleStorage: project` 会把选择保存在项目作用域。建议分别使用快速探索模型、代码实现模型和独立推理/审查模型。配置完成后以 `/devflow doctor` 的 `models:` 行为准。
 
-`/devflow start` 只创建 Feature 状态，不会自动启动整条流程。`/devflow continue` 只运行当前一个工作流步骤并停止；产物审查后由用户显式执行 `/devflow advance`，checkpoint 也必须由用户通过 `/devflow checkpoint` 确认。`/devflow explain-state` 发现控制面和制品 registry 漂移时会给出只读恢复计划；用户审查后可用 `/devflow recover` 确认仅修复可由文件系统证明的 registry 字段，它绝不推进步骤或自动通过 checkpoint。恢复已有流程使用 `/devflow resume`，它同样只恢复状态而不自动执行。普通中文输入“初始化项目”“查看状态”“需求：……”会进入相应的受控只读分诊，不会偷偷启动实现或状态迁移。
+`/devflow start` 会先进入安全的需求梳理：可澄清并只读检查，不写入项目。用户随后直接补充需求，原文会被带入入口分诊并启动当前步骤。每个步骤结束后，系统展示产物和证据；用户明确回复“批准执行”才会推进并运行下一步，回复修改意见或“拒绝执行”则保持原步骤。普通需求描述绝不会自动确认 checkpoint。`/devflow explain-state` 发现控制面和制品 registry 漂移时会给出只读恢复计划；用户审查后可用 `/devflow recover` 确认仅修复可由文件系统证明的 registry 字段，它绝不推进步骤或自动通过 checkpoint。恢复已有流程使用 `/devflow resume`，它同样只恢复状态而不自动执行。
 
 ## Marketplace 能力包
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",

package/plugins/devflow-core/extensions/devflow-core.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { mkdir, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -41,6 +41,12 @@ const READ_ONLY_TOOLS = new Set([
   "usage_stats",
 ]);
 
+const REQUIREMENT_DRAFT_TOOLS = new Set([...READ_ONLY_TOOLS, "ask"]);
+// A Todo update changes only the client-visible task list, never the project
+// or Devflow state. Permit it during planning so a harmless checklist cannot
+// produce a misleading "blocked" warning during initialization.
+const PLANNING_INTERNAL_TOOLS = new Set(["todo"]);
+
 const PLANNING_AGENTS = new Set(["project-scout", "requirements-auditor", "contract-auditor"]);
 
 const STATE_MUTATION_TOOLS = new Set([
@@ -91,11 +97,47 @@ export function statusText(state: SessionControlState): string {
 
 export function isPlanningToolAllowed(toolName: string, taskAgents: string[] = []): boolean {
   const normalized = toolName.toLowerCase();
+  if (PLANNING_INTERNAL_TOOLS.has(normalized)) return true;
   if (READ_ONLY_TOOLS.has(normalized)) return true;
   if (normalized !== "task") return false;
   return taskAgents.length > 0 && taskAgents.every(agent => PLANNING_AGENTS.has(agent));
 }
 
+/** Requirement drafting may inspect with a shell, but never mutate a project. */
+export function isReadOnlyShellCommand(command: string): boolean {
+  return command.trim() !== "" && !shellMutationPaths(command, ".").mutating;
+}
+
+export function isRequirementDraftToolAllowed(toolName: string, input: unknown, taskAgents: string[] = []): boolean {
+  const normalized = toolName.toLowerCase();
+  if (PLANNING_INTERNAL_TOOLS.has(normalized)) return true;
+  if (["bash", "shell", "exec_command"].includes(normalized)) {
+    const record = input && typeof input === "object" ? input as Record<string, unknown> : {};
+    return isReadOnlyShellCommand(String(record.command ?? record.cmd ?? ""));
+  }
+  if (REQUIREMENT_DRAFT_TOOLS.has(normalized)) return true;
+  return normalized === "task" && taskAgents.length > 0 && taskAgents.every(agent => PLANNING_AGENTS.has(agent));
+}
+
+/** `xd://devflow_contract` is an in-memory OMP control resource, not a
+ * project file. The planner must be able to read and activate it while the
+ * filesystem remains read-only; otherwise initialization deadlocks before it
+ * can create a bounded execution contract. */
+export function isInternalDevflowContractResource(toolName: string, input: unknown): boolean {
+  if (!["read", "write"].includes(toolName.toLowerCase()) || !input || typeof input !== "object") return false;
+  const record = input as Record<string, unknown>;
+  return [record.path, record.uri, record.resource].some(value => value === "xd://devflow_contract");
+}
+
+export type NaturalControlAction = "approve" | "reject";
+
+export function classifyNaturalControlAction(input: string): NaturalControlAction | null {
+  const text = input.trim();
+  if (/^(?:批准|确认|同意|通过)(?:\s*(?:(?:full|完整|全量)?\s*初始化|执行|继续|推进|当前(?:方案|步骤|计划)))?[。！!]?$/i.test(text)) return "approve";
+  if (/^(?:拒绝|不同意|暂不|需要修改|退回)(?:执行|继续|推进|当前(?:方案|步骤|计划))?[。！!]?$/.test(text)) return "reject";
+  return null;
+}
+
 export function isStateMutationTool(toolName: string): boolean {
   return STATE_MUTATION_TOOLS.has(toolName.toLowerCase());
 }
@@ -230,6 +272,7 @@ const REQUIRED_AGENT_NAMES = new Set(Object.keys(REQUIRED_AGENTS));
 const REQUIRED_SCRIPTS = [
   "workflow-orchestrator/scripts/init_workflow.rb",
   "workflow-orchestrator/scripts/init_state.rb",
+  "workflow-orchestrator/scripts/phase_ownership.rb",
   "workflow-orchestrator/scripts/inspect_state.rb",
   "workflow-orchestrator/scripts/advance_state.rb",
   "workflow-orchestrator/scripts/sync_artifacts.rb",
@@ -237,6 +280,17 @@ const REQUIRED_SCRIPTS = [
   "workflow-context-sync/scripts/context_sync_cursor.py",
 ];
 
+function defaultPhaseId(feature: string): string {
+  // STATE.md is project-global, so a generic name such as "delivery" is not
+  // a safe default. Keep the generated id filesystem-safe and deterministic
+  // without requiring a user to learn a phase-naming command.
+  return `feature-${createHash("sha256").update(feature, "utf8").digest("hex").slice(0, 12)}`;
+}
+
+function validPhaseId(phase: string): boolean {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(phase);
+}
+
 function resolvePluginRoot(): string {
   const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
   return path.resolve(process.env.DEVFLOW_PLUGIN_ROOT || path.resolve(moduleDirectory, "../.."));
@@ -464,6 +518,13 @@ function parseJsonResult(result: ProcessResult): Record<string, unknown> | null
   }
 }
 
+/** Ruby control-plane scripts report expected validation failures as JSON with
+ * `ok: false` and intentionally keep a zero process exit code. Never mistake
+ * that structured failure for a successful state mutation. */
+function controlPlaneSucceeded(result: ProcessResult): boolean {
+  return result.ok && parseJsonResult(result)?.ok === true;
+}
+
 function compactStep(value: unknown): Record<string, unknown> | null {
   if (!value || typeof value !== "object") return null;
   const step = value as Record<string, unknown>;
@@ -488,7 +549,7 @@ function compactStep(value: unknown): Record<string, unknown> | null {
   };
 }
 
-function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "resume" | "continue"): string {
+function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string): string {
   const selectedStep = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
   const envelope = {
     source,
@@ -502,19 +563,31 @@ function workflowDirective(snapshot: Record<string, unknown>, source: "start" |
     failure_branch: snapshot.failure_branch,
     reason: snapshot.reason,
     recovery: snapshot.recovery,
+    requirement_draft: requirementDraft,
   };
   return [
     "<devflow-runtime-directive>",
     "Devflow 已通过启动预检。读取 skill://workflow-pipeline，并只执行当前项目的一个工作流步骤。",
     "先调用 devflow_state(action=\"inspect\") 重新确认 revision，再由 workflow-orchestrator 路由当前步骤。",
     "只按 inspector 返回的当前 step 加载所需 Skill；不得调用 devflow_transition、不得推进下一步骤、不得替用户通过人工 checkpoint。",
-    "完成本步骤的真实产物后，报告证据、未决项和验证结果并停止，等待用户执行 /devflow advance。",
+    "完成本步骤的真实产物后，报告证据、未决项和验证结果并停止。请用户审查后明确回复“批准执行”才可推进；回复修改意见或“拒绝执行”则不得推进。",
     "当前步骤信封：",
     JSON.stringify(envelope, null, 2),
     "</devflow-runtime-directive>",
   ].join("\n");
 }
 
+function projectInitializationDirective(summary: string): string {
+  return [
+    "<devflow-project-initialization-directive>",
+    "用户已批准完整项目初始化。现在处于执行模式；不要再创建 Todo、不要读取或写入 xd://devflow_contract。",
+    "执行 skill://workflow-project-context，按已确认的项目边界建立 .planning/PROJECT.md、.planning/navigation/INDEX.md、.context/spec/index.md，并按用户选择建立 full 代码索引。",
+    "只写项目初始化所需的 .planning/ 与 .context/ 控制产物；不得改动业务源码、依赖或配置。完成后运行项目初始化校验，报告生成文件和验证结果并停止，等待用户审查。",
+    summary,
+    "</devflow-project-initialization-directive>",
+  ].join("\n");
+}
+
 function explainWorkflowSnapshot(snapshot: Record<string, unknown> | null): string {
   if (!snapshot) return "Devflow 当前没有可解释的工作流状态。可使用 /devflow start <feature> 创建新 Feature。";
   const step = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
@@ -853,8 +926,12 @@ export default function devflowCore(pi: ExtensionAPI) {
     return { result, snapshot: parseJsonResult(result) };
   }
 
-  async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "resume" | "continue") {
-    await pi.sendUserMessage(workflowDirective(snapshot, source));
+  let activeWorkflowTurn = false;
+  let pendingProjectInitialization: string | undefined;
+
+  async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string) {
+    activeWorkflowTurn = true;
+    await pi.sendUserMessage(workflowDirective(snapshot, source, requirementDraft));
   }
 
   pi.setLabel("Devflow Project Runtime");
@@ -879,8 +956,84 @@ export default function devflowCore(pi: ExtensionAPI) {
     systemPrompt: [...event.systemPrompt, DEVFLOW_CHINESE_LANGUAGE_POLICY],
   }));
 
+  pi.on("agent_end", async (event, ctx) => {
+    if (!activeWorkflowTurn || event.willContinue) return;
+    activeWorkflowTurn = false;
+    if (controlState.phase === "executing") {
+      setControlState(ctx, waitingUserState("等待用户审查步骤产物并明确决定"));
+      ctx.ui.notify("当前步骤已结束。请审查输出：明确回复“批准执行”推进，或回复修改意见/“拒绝执行”保持当前步骤。", "info");
+    }
+  });
+
   pi.on("input", async (event, ctx) => {
     if (event.source !== "interactive") return;
+    const controlAction = classifyNaturalControlAction(event.text);
+    if (controlState.intent === "requirement-draft" && controlState.phase === "planning") {
+      const requirementDraft = event.text.trim();
+      if (!requirementDraft) return { handled: true };
+      const inspected = await inspectWorkflow(ctx.cwd);
+      if (!inspected.result.ok || !inspected.snapshot) {
+        ctx.ui.notify(`需求分诊启动失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
+        return { handled: true };
+      }
+      setControlState(ctx, executingState("执行需求入口分诊"));
+      await triggerWorkflow(inspected.snapshot, "start", requirementDraft);
+      return { handled: true };
+    }
+    if (controlState.intent === "project-init" && controlState.phase === "planning") {
+      if (controlAction === "approve") {
+        if (!pendingProjectInitialization) {
+          ctx.ui.notify("项目初始化缺少已确认的边界信息，请重新发起初始化。", "error");
+          return { handled: true };
+        }
+        setControlState(ctx, executingState("执行已批准的项目初始化"));
+        activeWorkflowTurn = true;
+        return { text: projectInitializationDirective(pendingProjectInitialization), handled: false };
+      }
+      if (controlAction === "reject") {
+        ctx.ui.notify("已保留初始化规划，未创建任何项目控制文件。请直接说明需要调整的初始化范围。", "info");
+        return { handled: true };
+      }
+    }
+    if (controlState.phase === "awaiting-approval" || controlState.phase === "waiting-user") {
+      if (controlAction === "reject") {
+        ctx.ui.notify("已保留当前步骤和产物。请直接说明需要修改的内容；未执行任何推进。", "info");
+        return { handled: true };
+      }
+      if (controlAction === "approve") {
+        const inspected = await inspectWorkflow(ctx.cwd);
+        if (!inspected.result.ok || !inspected.snapshot) {
+          ctx.ui.notify(`审批处理失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
+          return { handled: true };
+        }
+        const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
+        const checkpoint = inspected.snapshot.status === "waiting_checkpoint";
+        const step = compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step);
+        const stepId = typeof step?.id === "string" ? step.id : undefined;
+        if (revision === undefined || (!checkpoint && !stepId)) {
+          ctx.ui.notify("当前状态缺少可确认的 revision 或步骤，拒绝推进。", "error");
+          return { handled: true };
+        }
+        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
+          "--write", "--json", "--expected-revision", String(revision),
+          ...(checkpoint ? ["--confirm-checkpoint"] : ["--complete-step", stepId!]),
+        ]);
+        if (!result.ok) {
+          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "推进校验失败" });
+          ctx.ui.notify(`未推进：${result.stderr || result.stdout}`, "error");
+          return { handled: true };
+        }
+        const after = await inspectWorkflow(ctx.cwd);
+        if (!after.result.ok || !after.snapshot || after.snapshot.action === "workflow_complete") {
+          setControlState(ctx, initialControlState());
+          ctx.ui.notify(after.snapshot?.action === "workflow_complete" ? "工作流已完成。" : "已推进，但读取下一步骤失败。", "info");
+          return { handled: true };
+        }
+        setControlState(ctx, executingState("执行已批准的下一工作流步骤"));
+        await triggerWorkflow(after.snapshot, "approval");
+        return { handled: true };
+      }
+    }
     const intent = classifyNaturalLanguageIntent(event.text);
     if (intent === "explain-state") {
       const inspected = await inspectWorkflow(ctx.cwd);
@@ -894,6 +1047,7 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (intent === "project-init") {
       const summary = await collectProjectInitialization(ctx);
       if (!summary) return { handled: true };
+      pendingProjectInitialization = summary;
       const state = planningState("project-init");
       setControlState(ctx, state);
       return {
@@ -913,7 +1067,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       return {
         text: [
           "<devflow-planner-directive>",
-          "当前是需求梳理（只读）阶段。只允许澄清、收集证据、派发只读审查代理和输出计划草案。",
+          "当前是需求梳理（只读）阶段。可澄清、收集证据、派发只读审查代理，且可使用不修改文件的 shell 检查。",
           "不得开始工作流、不得写入产物、不得调用实现代理或状态迁移。",
           "把用户目标、约束、未知项、反例和下一步最少问题分开列出；缺少证据时不得猜测。",
           event.text,
@@ -944,7 +1098,10 @@ export default function devflowCore(pi: ExtensionAPI) {
       if (shadows.length > 0) {
         return { block: true, reason: `Devflow task agent shadow detected: ${shadows.join("; ")}` };
       }
-      if (controlState.phase === "planning" && !isPlanningToolAllowed(toolName, requested.names)) {
+      const allowedInDraft = controlState.intent === "requirement-draft"
+        ? isRequirementDraftToolAllowed(toolName, event.input, requested.names)
+        : isPlanningToolAllowed(toolName, requested.names);
+      if (controlState.phase === "planning" && !allowedInDraft) {
         return { block: true, reason: planningToolBlockReason(toolName) };
       }
       if (
@@ -957,8 +1114,11 @@ export default function devflowCore(pi: ExtensionAPI) {
     } else if (
       controlState.phase === "planning" &&
       toolName !== "devflow_contract" &&
+      !isInternalDevflowContractResource(toolName, event.input) &&
       !(toolName === "devflow_evidence" && String((event.input as Record<string, unknown> | undefined)?.action) !== "create") &&
-      !isPlanningToolAllowed(toolName)
+      !(controlState.intent === "requirement-draft"
+        ? isRequirementDraftToolAllowed(toolName, event.input)
+        : isPlanningToolAllowed(toolName))
     ) {
       return { block: true, reason: planningToolBlockReason(toolName) };
     }
@@ -966,7 +1126,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       return {
         block: true,
         reason:
-          "Devflow state transitions are user-command-only. Use /devflow start, /devflow advance, or /devflow checkpoint; an LLM may not advance delivery state directly.",
+          "Devflow 状态迁移只能由运行时在用户明确批准已展示的步骤或 checkpoint 后执行；LLM 不得自行推进。",
       };
     }
     if (toolName.startsWith("devflow_")) return;
@@ -1246,35 +1406,54 @@ export default function devflowCore(pi: ExtensionAPI) {
     description: "Initialize workflow definitions, STATE.md, and the artifact registry for a project feature.",
     parameters: z.object({
       feature: z.string().min(1),
-      phase: z.string().min(1).default("delivery"),
+      phase: z.string().min(1).optional(),
       flow: z.string().min(1).default("feature-development"),
       force: z.boolean().default(false),
     }),
     approval: "write",
     async execute(_id, params, _signal, _onUpdate, ctx) {
+      const phase = params.phase?.trim() || defaultPhaseId(params.feature);
+      if (!validPhaseId(phase)) {
+        return {
+          content: [{ type: "text" as const, text: "Phase ID 必须是 1-64 位字母、数字、下划线或连字符，且不得包含路径分隔符。" }],
+          isError: true,
+        };
+      }
       const force = params.force ? ["--force"] : [];
+      const ownership = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/phase_ownership.rb", [
+        "claim",
+        "--feature",
+        params.feature,
+        "--phase",
+        phase,
+        "--flow",
+        params.flow,
+        "--json",
+      ]);
+      if (!controlPlaneSucceeded(ownership)) return renderResult(ownership, { stage: "phase-ownership" });
       const workflow = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_workflow.rb", [
         "--write",
         "--json",
         ...force,
       ]);
-      if (!workflow.ok) return renderResult(workflow, { stage: "workflow" });
+      if (!controlPlaneSucceeded(workflow)) return renderResult(workflow, { stage: "workflow" });
       const state = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_state.rb", [
         "--feature",
         params.feature,
         "--phase",
-        params.phase,
+        phase,
         "--flow",
         params.flow,
         "--write",
         "--json",
         ...force,
       ]);
-      if (!state.ok) return renderResult(state, { stage: "state" });
+      if (!controlPlaneSucceeded(state)) return renderResult(state, { stage: "state" });
       const artifacts = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/sync_artifacts.rb", [
         "--write",
         "--json",
       ]);
+      if (!controlPlaneSucceeded(artifacts)) return renderResult(artifacts, { stage: "artifacts" });
       return renderResult(artifacts, {
         stage: "complete",
         workflow: workflow.stdout,
@@ -1359,7 +1538,8 @@ export default function devflowCore(pi: ExtensionAPI) {
     approval: "write",
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const args = ["--write", "--confirm", "--expected-revision", String(params.expectedRevision), "--json"];
-      if (params.state) args.push("--state", params.state);
+      const state = safeControlPath(ctx.cwd, params.state, "state");
+      if (state) args.push("--state", state);
       return renderResult(
         await runRuby(ctx.cwd, "workflow-orchestrator/scripts/repair_control_plane.rb", args),
         { action: "repair-control-plane" },
@@ -1444,9 +1624,9 @@ export default function devflowCore(pi: ExtensionAPI) {
           const step = compactStep(inspected.snapshot?.next_step) ?? compactStep(inspected.snapshot?.current_step);
           const stepId = typeof step?.id === "string" ? step.id : "当前步骤";
           if (inspected.result.ok && status === "in_progress") {
-            ctx.ui.notify(`控制面状态一致，无需恢复。当前步骤是 ${stepId}；请执行 /devflow continue。`, "info");
+            ctx.ui.notify(`控制面状态一致，无需恢复。当前步骤是 ${stepId}；请审查当前产物后明确回复“批准执行”或提出修改意见。`, "info");
           } else if (inspected.result.ok && status === "waiting_checkpoint") {
-            ctx.ui.notify(`控制面状态一致，无需恢复。当前正在等待 checkpoint；请审查产物后执行 /devflow checkpoint。`, "info");
+            ctx.ui.notify("控制面状态一致，无需恢复。当前正在等待 checkpoint；请审查产物后明确回复“批准执行”或提出修改意见。", "info");
           } else {
             ctx.ui.notify("当前状态没有可安全自动执行的恢复计划；请运行 /devflow explain-state，并按其中的阻塞证据处理。", "error");
           }
@@ -1471,12 +1651,13 @@ export default function devflowCore(pi: ExtensionAPI) {
           ctx.ui.notify(`控制面恢复失败：${result.stderr || result.stdout}`, "error");
           return;
         }
-        ctx.ui.notify("控制面 registry 已修复；未推进工作流。请审查当前步骤产物后使用 /devflow advance。", "info");
+        ctx.ui.notify("控制面 registry 已修复；未推进工作流。请审查当前步骤产物后明确回复“批准执行”或提出修改意见。", "info");
         return;
       }
       if (trimmed === "project-init") {
         const summary = await collectProjectInitialization(ctx);
         if (!summary) return;
+        pendingProjectInitialization = summary;
         setControlState(ctx, planningState("project-init"));
         await pi.sendUserMessage(
           [
@@ -1515,138 +1696,22 @@ export default function devflowCore(pi: ExtensionAPI) {
         }
         setControlState(ctx, waitingUserState("等待用户审查步骤产物"));
         ctx.ui.notify(
-          `Devflow 已恢复到 ${String((compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step))?.id ?? "当前步骤")}；未自动执行。请先查看状态或使用 /devflow continue 执行一个步骤。`,
+          `Devflow 已恢复到 ${String((compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step))?.id ?? "当前步骤")}；请审查当前产物后明确回复“批准执行”，或直接提出修改意见。`,
           "info",
         );
         return;
       }
-      if (trimmed === "continue") {
-        const report = await runDoctor(ctx);
-        if (!report.ok) {
-          ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
-          return;
-        }
-        const inspected = await inspectWorkflow(ctx.cwd);
-        if (!inspected.result.ok || !inspected.snapshot) {
-          ctx.ui.notify(`Devflow continue failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
-          return;
-        }
-        if (inspected.snapshot.action === "workflow_complete") {
-          ctx.ui.notify("Devflow workflow is already complete.", "info");
-          return;
-        }
-        if (inspected.snapshot.status === "waiting_checkpoint") {
-          setControlState(ctx, { intent: "workflow-execute", phase: "awaiting-approval", label: "等待用户确认 checkpoint" });
-          ctx.ui.notify("当前步骤正在等待 checkpoint；请审查产物后使用 /devflow checkpoint。", "warning");
-          return;
-        }
-        setControlState(ctx, executingState("执行当前工作流步骤（完成后停止）"));
-        ctx.ui.notify("仅启动当前步骤；模型被禁止迁移状态或继续下一步骤。", "info");
-        await triggerWorkflow(inspected.snapshot, "continue");
-        return;
-      }
-      if (trimmed === "advance") {
-        const inspected = await inspectWorkflow(ctx.cwd);
-        if (!inspected.result.ok || !inspected.snapshot) {
-          ctx.ui.notify(`Devflow advance failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
-          return;
-        }
-        if (inspected.snapshot.action === "workflow_complete" && inspected.snapshot.source_flow) {
-          const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
-          if (revision === undefined) {
-            ctx.ui.notify("补救分支缺少 revision，拒绝返回主流程。", "error");
-            return;
-          }
-          const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
-            "--write",
-            "--json",
-            "--expected-revision",
-            String(revision),
-            "--exit-failure-branch",
-          ]);
-          if (!result.ok) {
-            ctx.ui.notify(`补救分支返回失败：${result.stderr || result.stdout}`, "error");
-            return;
-          }
-          ctx.ui.notify("补救分支已返回主流程；仍需审查 reverify 结果，并在 CP-4 明确确认后才能继续。", "info");
-          return;
-        }
-        if (inspected.snapshot.status === "waiting_checkpoint") {
-          ctx.ui.notify("当前状态等待 checkpoint；请使用 /devflow checkpoint。", "warning");
-          return;
-        }
-        const step = compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step);
-        const stepId = typeof step?.id === "string" ? step.id : undefined;
-        const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
-        if (!stepId || revision === undefined) {
-          ctx.ui.notify("当前状态没有可推进的步骤或 revision；请先执行 /devflow explain-state。", "error");
-          return;
-        }
-        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
-          "--write",
-          "--json",
-          "--expected-revision",
-          String(revision),
-          "--complete-step",
-          stepId,
-        ]);
-        if (!result.ok) {
-          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "推进校验失败" });
-          ctx.ui.notify(`步骤未推进：${result.stderr || result.stdout}`, "error");
-          return;
-        }
-        const after = await inspectWorkflow(ctx.cwd);
-        setControlState(
-          ctx,
-          after.snapshot?.status === "waiting_checkpoint"
-            ? { intent: "workflow-execute", phase: "awaiting-approval", label: "等待用户确认 checkpoint" }
-            : waitingUserState("等待用户审查步骤产物"),
-        );
-        ctx.ui.notify(`已完成步骤 ${stepId} 的真实产物校验并推进状态。${after.snapshot?.status === "waiting_checkpoint" ? "下一步需要 /devflow checkpoint。" : "下一步请审查后使用 /devflow continue。"}`, "info");
-        return;
-      }
-      if (trimmed === "checkpoint") {
-        const inspected = await inspectWorkflow(ctx.cwd);
-        if (!inspected.result.ok || !inspected.snapshot) {
-          ctx.ui.notify(`Devflow checkpoint failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
-          return;
-        }
-        if (inspected.snapshot.status !== "waiting_checkpoint") {
-          ctx.ui.notify("当前并不等待 checkpoint；请使用 /devflow explain-state 查看原因。", "warning");
-          return;
-        }
-        const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
-        if (revision === undefined) {
-          ctx.ui.notify("当前状态缺少 revision，拒绝确认 checkpoint。", "error");
-          return;
-        }
-        const confirmed = await ctx.ui.confirm("确认 Devflow checkpoint", "你已审查当前步骤产物并同意推进到下一步骤吗？");
-        if (!confirmed) {
-          ctx.ui.notify("checkpoint 未确认；状态保持不变。", "info");
-          return;
-        }
-        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
-          "--write",
-          "--json",
-          "--expected-revision",
-          String(revision),
-          "--confirm-checkpoint",
-        ]);
-        if (!result.ok) {
-          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "checkpoint 校验失败" });
-          ctx.ui.notify(`checkpoint 未推进：${result.stderr || result.stdout}`, "error");
-          return;
-        }
-        setControlState(ctx, waitingUserState("等待用户确认下一步骤"));
-        ctx.ui.notify("checkpoint 已由用户确认；下一步骤尚未执行，请使用 /devflow continue。", "info");
-        return;
-      }
       if (trimmed.startsWith("start ")) {
-        const [feature, phase = "delivery"] = trimmed.slice(6).split("|", 2).map(value => value.trim());
+        const [feature, requestedPhase] = trimmed.slice(6).split("|", 2).map(value => value.trim());
         if (!feature) {
           ctx.ui.notify("Usage: /devflow start <feature>|<phase>", "error");
           return;
         }
+        const phase = requestedPhase || defaultPhaseId(feature);
+        if (!validPhaseId(phase)) {
+          ctx.ui.notify("Phase ID 必须是 1-64 位字母、数字、下划线或连字符，且不得包含路径分隔符。", "error");
+          return;
+        }
         const report = await runDoctor(ctx);
         if (!report.ok) {
           ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
@@ -1661,16 +1726,33 @@ export default function devflowCore(pi: ExtensionAPI) {
           existingFeature !== feature
         ) {
           ctx.ui.notify(
-            `An unfinished Devflow state belongs to feature ${existingFeature}. Use /devflow resume and complete that workflow before starting ${feature}.`,
+            `当前仍有未完成需求：${existingFeature}。请在对话中继续处理当前步骤，完成后再创建新需求：${feature}。`,
             "error",
           );
           return;
         }
+        // This dry-run happens before init_workflow.rb, so a rejected feature
+        // can never overwrite generated workflow files belonging to an active
+        // owner or a legacy phase directory that has no trustworthy owner.
+        const ownership = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/phase_ownership.rb", [
+          "claim",
+          "--feature",
+          feature,
+          "--phase",
+          phase,
+          "--flow",
+          "feature-development",
+          "--json",
+        ]);
+        if (!controlPlaneSucceeded(ownership)) {
+          ctx.ui.notify((ownership.stderr || ownership.stdout).slice(0, 6000), "error");
+          return;
+        }
         const workflow = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_workflow.rb", [
           "--write",
           "--json",
         ]);
-        if (!workflow.ok) {
+        if (!controlPlaneSucceeded(workflow)) {
           ctx.ui.notify(workflow.stderr || workflow.stdout, "error");
           return;
         }
@@ -1685,7 +1767,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           "--json",
           ...(previousWorkflowComplete ? ["--force"] : []),
         ]);
-        if (!state.ok) {
+        if (!controlPlaneSucceeded(state)) {
           ctx.ui.notify((state.stderr || state.stdout).slice(0, 6000), "error");
           return;
         }
@@ -1693,7 +1775,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           "--write",
           "--json",
         ]);
-        if (!artifacts.ok) {
+        if (!controlPlaneSucceeded(artifacts)) {
           ctx.ui.notify((artifacts.stderr || artifacts.stdout).slice(0, 6000), "error");
           return;
         }
@@ -1706,14 +1788,19 @@ export default function devflowCore(pi: ExtensionAPI) {
           return;
         }
         setControlState(ctx, planningState("requirement-draft"));
-        ctx.ui.notify(
-          `Devflow 已创建 Feature ${feature}，但没有自动执行。当前步骤：${String((compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step))?.id ?? "requirement-triage")}。请补充需求后使用 /devflow continue。`,
-          "info",
+        await pi.sendUserMessage(
+          [
+            "<devflow-requirement-draft-directive>",
+            `Devflow 已创建 Feature ${feature}。当前为安全的需求梳理阶段：允许澄清和只读证据收集，不得写入项目或迁移状态。`,
+            "请先基于功能名说明你需要的最少业务背景，并邀请用户直接补充目标、使用者、约束和验收结果。收到用户的下一段需求描述后，运行时会将其原文注入 requirement-triage 并启动该步骤。",
+            "不要让用户输入命令；也不要把普通需求文本当成批准或 checkpoint 确认。",
+            "</devflow-requirement-draft-directive>",
+          ].join("\n"),
         );
         return;
       }
       ctx.ui.notify(
-        "Usage: /devflow doctor | status | explain-state | recover | project-init | start <feature>|<phase> | resume | continue | advance | checkpoint",
+        "Usage: /devflow doctor | status | explain-state | recover | project-init | start <feature>|<phase> | resume",
         "warning",
       );
     },