@guanlin4924/devflow-pi 0.1.106 → 0.1.107

package/README.md

@@ -11,7 +11,7 @@ Devflow Pi 是一个面向项目研发交付的独立 OMP 产品入口，内置
 安装与启动：
 
 ```bash
-npm install -g @guanlin4924/devflow-pi@0.1.106
+npm install -g @guanlin4924/devflow-pi@0.1.107
 cd /path/to/your-project
 devflow-pi init
 devflow-pi doctor

package/package.json

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

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

@@ -19,6 +19,7 @@ import { generateProjectDocuments } from "../../../src/project-documents.ts";
 import { preparedRolloverRevision } from "../../../src/session-rollover.ts";
 import { describeStartupIssue, renderStartupBriefing } from "../../../src/startup-briefing.ts";
 import { PRODUCT_VERSION } from "../../../src/constants.ts";
+import { dynamicWorkflowDirective, renderDynamicWorkflow } from "../../../src/dynamic-workflow.ts";
 import {
   FIX_LABELS,
   buildHelpBundle,
@@ -819,6 +820,7 @@ const REQUIRED_EXTENSION_TOOLS = [
 ];
 
 const REQUIRED_SKILLS = [
+  "workflow-dynamic",
   "code-index-query",
   "code-review",
   "requirement-feasibility-review",
@@ -876,6 +878,7 @@ const REQUIRED_MODEL_ROLES = ["@smol", "@task", "@slow"];
 const REQUIRED_AGENT_NAMES = new Set(Object.keys(REQUIRED_AGENTS));
 
 const REQUIRED_SCRIPTS = [
+  "workflow-orchestrator/scripts/dynamic_plan.rb",
   "workflow-orchestrator/scripts/init_workflow.rb",
   "workflow-orchestrator/scripts/init_state.rb",
   "workflow-orchestrator/scripts/phase_ownership.rb",
@@ -1535,6 +1538,7 @@ export function isShellControlMutation(toolName: string, input: unknown): boolea
   }
   const command = String((input as Record<string, unknown>).command ?? (input as Record<string, unknown>).cmd ?? "");
   if (!command) return false;
+  if (/\bdynamic_plan\.rb\b/.test(command)) return true;
   const invokesWriter =
     /workflow-orchestrator\/scripts\/(?:advance_state|init_state|init_workflow|sync_artifacts|requirement_graph|machine_evidence|execution_contract)\.rb[^\n]*--write/.test(
       command,
@@ -1997,6 +2001,10 @@ export default function devflowCore(pi: ExtensionAPI) {
   const reviewBindingKey = randomBytes(32).toString("hex");
   const pendingReviewTasks = new Map<string, { feature: string; contractId: string }>();
   const completedReviewTasks = new Map<string, { feature: string; contractId: string; report: Record<string, unknown> }>();
+  const dynamicReviewBindings = new Map<string, { taskId: string; attempt: string; revision: number }>();
+  const dynamicReviewResults = new Map<string, { taskId: string; attempt: string; revision: number; report: Record<string, unknown> }>();
+  let dynamicTurnRevision: number | undefined;
+  let dynamicTurnProgress: string | undefined;
   let latestReviewTaskCallId: string | undefined;
   let projectRoot: string | undefined;
 
@@ -2109,6 +2117,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       const content = lines.map((line, index) => {
         if (index === 0) return theme.bold(theme.fg("accent", line));
         if (line.startsWith("──")) return theme.fg("accent", line);
+        if (line.startsWith("—")) return theme.fg("dim", line);
         return theme.fg("muted", line);
       }).join("\n");
       panel.addChild(new Text(content, 0, 0));
@@ -2660,6 +2669,22 @@ export default function devflowCore(pi: ExtensionAPI) {
     return { result, snapshot: parseJsonResult(result) };
   }
 
+  async function runDynamicPlan(cwd: string, request: Record<string, unknown>): Promise<ProcessResult> {
+    assertRuntimeProjectBoundary(cwd);
+    return runProcess(["ruby", path.join(resolveKitRoot(cwd), "workflow-orchestrator/scripts/dynamic_plan.rb")], cwd, {}, JSON.stringify(request));
+  }
+
+  async function startDynamicTurn(ctx: { ui: { notify(message: string, level: "info" | "error"): void } }, snapshot: Record<string, unknown>) {
+    ctx.ui.notify(renderDynamicWorkflow(snapshot), "info");
+    if (["ready", "cancelled"].includes(String(snapshot.delivery))) return;
+    dynamicTurnRevision = Number(snapshot.revision);
+    dynamicTurnProgress = String(snapshot.progress_key);
+    activeContract = undefined;
+    activeWorkflowTurn = true;
+    controlState = executingState("执行中文工作流");
+    await pi.sendUserMessage(dynamicWorkflowDirective(snapshot));
+  }
+
   async function inspectWorkflowWithRegistryRecovery(cwd: string): Promise<{ result: ProcessResult; snapshot: Record<string, unknown> | null }> {
     let inspected = await inspectWorkflow(cwd);
     const errors = Array.isArray(inspected.snapshot?.state_validation && (inspected.snapshot.state_validation as Record<string, unknown>).errors)
@@ -2819,6 +2844,10 @@ export default function devflowCore(pi: ExtensionAPI) {
     snapshot: Record<string, unknown>,
     options: { doctorAlreadyPassed: boolean },
   ): Promise<WorkflowResumeDisposition> {
+    if (snapshot.mode === "dynamic") {
+      await startDynamicTurn(ctx, snapshot);
+      return snapshot.delivery === "ready" ? "complete" : "execute";
+    }
     const disposition = workflowResumeDisposition(snapshot);
     const stepId = String(selectedWorkflowStep(snapshot)?.id ?? "当前步骤");
     if (disposition === "execute") {
@@ -3000,6 +3029,11 @@ export default function devflowCore(pi: ExtensionAPI) {
       ctx.ui.notify("当前步骤正在执行，等这一轮结束后再说「下一步」。", "info");
       return;
     }
+    const dynamic = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+    if (dynamic?.mode === "dynamic") {
+      await startDynamicTurn(ctx, dynamic);
+      return;
+    }
     if (mode === "next") {
       const report = await runDoctor(ctx);
       if (!report.ok) {
@@ -3704,6 +3738,25 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   pi.on("agent_end", async (event, ctx) => {
     if (!activeWorkflowTurn || event.willContinue) return;
+    if (dynamicTurnRevision !== undefined) {
+      const before = dynamicTurnRevision;
+      dynamicTurnRevision = undefined;
+      activeWorkflowTurn = false;
+      const snapshot = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+      if (snapshot?.mode === "dynamic") {
+        ctx.ui.notify(renderDynamicWorkflow(snapshot), "info");
+        if (["run_task", "plan_work", "reconcile_plan"].includes(String(snapshot.action)) && Number(snapshot.revision) > before && snapshot.progress_key !== dynamicTurnProgress) {
+          dynamicTurnRevision = Number(snapshot.revision);
+          dynamicTurnProgress = String(snapshot.progress_key);
+          activeWorkflowTurn = true;
+          setControlState(ctx, executingState("继续执行中文工作流"));
+          pi.sendMessage({ customType: "devflow-dynamic-continue", content: dynamicWorkflowDirective(snapshot), display: false }, { triggerTurn: true, deliverAs: "nextTurn" });
+        } else {
+          setControlState(ctx, snapshot.delivery === "ready" ? initialControlState() : waitingUserState("保留当前结果；等待决定、外部条件或执行恢复"));
+        }
+        return;
+      }
+    }
     const assistant = [...event.messages].reverse().find(message => (
       message && typeof message === "object" && (message as { role?: unknown }).role === "assistant"
     ));
@@ -3750,6 +3803,17 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   pi.on("input", async (event, ctx) => {
     if (event.source !== "interactive") return;
+    if (event.text.trim() && !event.text.trim().startsWith("/") && !classifyNextStepPhrase(event.text)) {
+      const dynamic = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+      if (dynamic?.mode === "dynamic") {
+        dynamicTurnRevision = Number(dynamic.revision);
+        dynamicTurnProgress = String(dynamic.progress_key);
+        activeWorkflowTurn = true;
+        activeContract = undefined;
+        setControlState(ctx, executingState("处理需求调整"));
+        return { text: `${dynamicWorkflowDirective(dynamic)}\n用户补充：${event.text}`, handled: false };
+      }
+    }
     const controlAction = classifyNaturalControlAction(event.text);
     const stepNote = event.text.trim();
     if (controlState.intent === "workflow-execute" && !controlAction && stepNote && !stepNote.startsWith("/") && !classifyNextStepPhrase(stepNote)) {
@@ -3943,6 +4007,18 @@ export default function devflowCore(pi: ExtensionAPI) {
   });
 
   pi.on("tool_call", async (event, ctx) => {
+    if (dynamicTurnRevision !== undefined) {
+      const name = String(event.toolName).toLowerCase();
+      if (isDirectControlMutation(name, event.input, ctx.cwd) || isShellControlMutation(name, event.input) || name === "devflow_transition") {
+        return { block: true, reason: "动态计划由 Core 独占写入；请使用 devflow_plan，不能手工写入通过状态。" };
+      }
+      if (name === "task" && requestedTaskAgents(event.input).names.includes("devflow-code-reviewer")) {
+        const snapshot = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+        const task = snapshot?.current_step as Record<string, unknown> | undefined;
+        if (task?.kind === "review" && task.status === "running") dynamicReviewBindings.set(event.toolCallId, { taskId: String(task.id), attempt: String(task.attempt), revision: Number(snapshot?.revision) });
+      }
+      return;
+    }
     const decision = await (async () => {
     const toolName = String(event.toolName).toLowerCase();
     const toolInput = event.input && typeof event.input === "object" ? event.input as Record<string, unknown> : undefined;
@@ -4108,6 +4184,18 @@ export default function devflowCore(pi: ExtensionAPI) {
   });
 
   pi.on("tool_result", async (event, ctx) => {
+    const dynamicBinding = dynamicReviewBindings.get(event.toolCallId);
+    if (event.toolName === "task" && dynamicBinding) {
+      dynamicReviewBindings.delete(event.toolCallId);
+      const results = (event.details as { results?: Array<Record<string, unknown>> } | undefined)?.results;
+      const child = results?.length === 1 ? results[0] : undefined;
+      if (!event.isError && child?.agent === "devflow-code-reviewer" && child.exitCode === 0 && child.truncated === false && typeof child.output === "string") {
+        try {
+          const report = JSON.parse(child.output);
+          if (typeof report.summary === "string" && Array.isArray(report.findings)) dynamicReviewResults.set(event.toolCallId, { ...dynamicBinding, report });
+        } catch { /* Invalid reviewer output never becomes a pass. */ }
+      }
+    }
     if (event.toolName === "task") {
       const binding = pendingReviewTasks.get(event.toolCallId);
       if (binding) {
@@ -5018,6 +5106,59 @@ export default function devflowCore(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "devflow_plan",
+    label: "Devflow 中文工作流",
+    description: "Inspect or execute the Core-owned dynamic plan. Never accepts caller-written pass/approval results. Use revise for task proposals, claim before work, report for activity results, verify for actual executable checks, review_result for a captured independent review, and decision only for genuine user choices. Task fields: id,title,kind(discover/implement/verify/review),requirements(R-ids),dependencies,inputs,outputs,checks([{argv:string[],timeout?:number}]),cancelled?,reason?.",
+    parameters: z.object({
+      action: z.enum(["inspect", "revise", "claim", "report", "verify", "review_result", "recover", "wait", "resume", "decision"]),
+      expected_revision: z.number().int().optional(),
+      task_id: z.string().optional(),
+      attempt: z.string().optional(),
+      tasks: z.array(z.object({
+        id: z.string(), title: z.string(), kind: z.enum(["discover", "implement", "repair", "verify", "review"]),
+        requirements: z.array(z.string()), dependencies: z.array(z.string()), inputs: z.array(z.string()), outputs: z.array(z.string()),
+        checks: z.array(z.object({ argv: z.array(z.string()).min(1), timeout: z.number().int().optional() })),
+        cancelled: z.boolean().optional(), reason: z.string().optional(),
+      })).optional(),
+      reason: z.string().optional(), summary: z.string().optional(), task_call_id: z.string().optional(),
+      question: z.string().optional(), options: z.array(z.string()).optional(),
+      task_ids: z.array(z.string()).optional(),
+      scope_decision_id: z.string().optional(), remove_requirements: z.array(z.string()).optional(), approval_option: z.string().optional(),
+    }),
+    approval: "write",
+    async execute(_id, rawParams, _signal, _onUpdate, ctx) {
+      const params = rawParams as { action: string; task_call_id?: string; task_id?: string; attempt?: string; expected_revision?: number; question?: string };
+      const request: Record<string, unknown> = { ...params };
+      if (params.action === "review_result") {
+        const captured = params.task_call_id ? dynamicReviewResults.get(params.task_call_id) : undefined;
+        if (!captured || captured.taskId !== params.task_id || captured.attempt !== params.attempt || captured.revision !== params.expected_revision) {
+          return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "No current independent reviewer result is bound to this task attempt. Dispatch the read-only reviewer first." });
+        }
+        request.runtime_review = true;
+        request.report = captured.report;
+      }
+      let result = await runDynamicPlan(ctx.cwd, request);
+      let snapshot = parseJsonResult(result);
+      if (snapshot?.ok === true && params.action === "review_result" && params.task_call_id) dynamicReviewResults.delete(params.task_call_id);
+      if (snapshot?.ok === true && params.action === "decision") {
+        const decisions = snapshot.decisions as Array<Record<string, unknown>>;
+        const pending = decisions.find(item => item.status === "pending" && item.question === params.question);
+        if (pending) {
+          const removals = pending.remove_requirements as string[] | undefined;
+          const question = String(pending.question) + (removals?.length ? `\n拟移除验收要求：${removals.join("、")}；仅选择「${pending.approval_option}」会授权移除。` : "");
+          const choice = await ctx.ui.select(question, pending.options as string[]);
+          if (choice) {
+            result = await runDynamicPlan(ctx.cwd, { action: "decide", expected_revision: snapshot.revision, decision_id: pending.id, choice, runtime_decision: true });
+            snapshot = parseJsonResult(result);
+          }
+        }
+      }
+      if (snapshot?.mode === "dynamic") ctx.ui.setWidget?.("devflow-plan", projectControlWidget(renderDynamicWorkflow(snapshot).split("\n")));
+      return renderResult(result);
+    },
+  });
+
   pi.registerTool({
     name: "devflow_bootstrap",
     label: "Devflow Bootstrap",
@@ -5025,11 +5166,24 @@ export default function devflowCore(pi: ExtensionAPI) {
     parameters: z.object({
       feature: z.string().min(1),
       phase: z.string().min(1).optional(),
-      flow: z.enum(["feature-development", "acceptance-remediation", "regression-acceptance"]).default("feature-development"),
+      flow: z.enum(["dynamic", "feature-development", "acceptance-remediation", "regression-acceptance"]).default("dynamic"),
       force: z.boolean().default(false),
     }),
     approval: "write",
-    async execute(_id, params, _signal, _onUpdate, ctx) {
+    async execute(_id, rawParams, _signal, _onUpdate, ctx) {
+      const params = rawParams as { flow: string; feature: string; phase?: string; force: boolean };
+      if (params.flow === "dynamic") {
+        const result = await runDynamicPlan(ctx.cwd, { action: "initialize", feature: params.feature, phase: params.phase });
+        const snapshot = parseJsonResult(result);
+        if (snapshot?.mode === "dynamic") {
+          dynamicTurnRevision = Number(snapshot.revision);
+          dynamicTurnProgress = String(snapshot.progress_key);
+          activeWorkflowTurn = true;
+          activeContract = undefined;
+          setControlState(ctx, executingState("梳理需求并生成中文步骤"));
+        }
+        return renderResult(result);
+      }
       // Consume the one-shot runtime authorization before running Core's
       // atomic bootstrap sequence. A retry must obtain a fresh user approval.
       runtimeBootstrapAuthorizations.delete(String(_id));
@@ -5398,6 +5552,15 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   const devflowCommand = async (args: string, ctx: DevflowCommandContext): Promise<void> => {
     const trimmed = args.trim();
+    if (["", "status", "control", "explain-state"].includes(trimmed)) {
+      const dynamic = parseJsonResult(await runDynamicPlan(ctx.cwd, { action: "inspect" }));
+      if (dynamic?.mode === "dynamic") {
+        const lines = renderDynamicWorkflow(dynamic, trimmed === "control").split("\n");
+        ctx.ui.notify(lines.join("\n"), "info");
+        ctx.ui.setWidget?.("devflow-plan", projectControlWidget(lines));
+        return;
+      }
+    }
     if (trimmed === "" || trimmed === "status") {
       await showWorkflowOverview(ctx);
       return;
@@ -5470,6 +5633,17 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (trimmed === "abandon" || trimmed.startsWith("abandon ") || trimmed === "cancel" || trimmed.startsWith("cancel ")) {
       const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
       const snapshot = inspected.snapshot;
+      if (snapshot?.mode === "dynamic") {
+        const result = await runDynamicPlan(ctx.cwd, { action: "cancel", expected_revision: snapshot.revision, runtime_cancel: true, reason: trimmed.replace(/^\S+\s*/, "") || "用户主动终止当前需求" });
+        const cancelled = parseJsonResult(result);
+        if (cancelled?.ok) {
+          dynamicTurnRevision = undefined;
+          activeWorkflowTurn = false;
+          setControlState(ctx, initialControlState());
+          ctx.ui.notify("已取消需求，保留已有工作与失败证据。", "info");
+        } else ctx.ui.notify(String(cancelled?.reason ?? result.stderr), "error");
+        return;
+      }
       const revision = typeof snapshot?.revision === "number" ? snapshot.revision : undefined;
       const feature = typeof snapshot?.current_feature === "string" ? snapshot.current_feature : undefined;
       const status = typeof snapshot?.status === "string" ? snapshot.status : undefined;
@@ -5573,100 +5747,19 @@ export default function devflowCore(pi: ExtensionAPI) {
     }
     if (trimmed.startsWith("start ")) {
       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");
+      if (!feature || (requestedPhase && !validPhaseId(requestedPhase))) {
+        ctx.ui.notify("用法：/devflow start <需求名>|<可选阶段标识>", "error");
         return;
       }
       const report = await runDoctor(ctx);
-      if (!report.ok) {
-        ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "info");
-
-      }
-      const existing = await inspectWorkflow(ctx.cwd);
-      const existingFeature = existing.snapshot?.current_feature;
-      const previousWorkflowComplete = ["workflow_complete", "workflow_cancelled"].includes(existing.snapshot?.action as string);
-      if (
-        !previousWorkflowComplete &&
-        typeof existingFeature === "string" &&
-        existingFeature !== feature
-      ) {
-        ctx.ui.notify(
-          `当前仍有未完成需求：${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");
+      if (!report.ok) ctx.ui.notify(formatDoctorReport(report).slice(0, 6000), "info");
+      const result = await runDynamicPlan(ctx.cwd, { action: "initialize", feature, phase: requestedPhase || undefined });
+      const snapshot = parseJsonResult(result);
+      if (!snapshot?.ok) {
+        ctx.ui.notify(String(snapshot?.reason ?? result.stderr), "error");
         return;
       }
-      const workflow = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_workflow.rb", [
-        "--write",
-        "--json",
-      ]);
-      if (!controlPlaneSucceeded(workflow)) {
-        ctx.ui.notify(workflow.stderr || workflow.stdout, "error");
-        return;
-      }
-      const state = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/init_state.rb", [
-        "--feature",
-        feature,
-        "--phase",
-        phase,
-        "--flow",
-        "feature-development",
-        "--write",
-        "--json",
-        ...(previousWorkflowComplete ? ["--force"] : []),
-      ]);
-      if (!controlPlaneSucceeded(state)) {
-        ctx.ui.notify((state.stderr || state.stdout).slice(0, 6000), "error");
-        return;
-      }
-      const artifacts = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/sync_artifacts.rb", [
-        "--write",
-        "--json",
-      ]);
-      if (!controlPlaneSucceeded(artifacts)) {
-        ctx.ui.notify((artifacts.stderr || artifacts.stdout).slice(0, 6000), "error");
-        return;
-      }
-      const inspected = await inspectWorkflow(ctx.cwd);
-      if (!inspected.result.ok || !inspected.snapshot) {
-        ctx.ui.notify(
-          `Devflow initialized but inspector failed: ${inspected.result.stderr || inspected.result.stdout || "invalid JSON"}`,
-          "error",
-        );
-        return;
-      }
-      setControlState(ctx, planningState("requirement-draft"));
-      await pi.sendUserMessage(
-        [
-          "<devflow-requirement-draft-directive>",
-          `Devflow 已创建 Feature ${feature}。当前为安全的需求梳理阶段：允许澄清和只读证据收集，不得写入项目或迁移状态。`,
-          "请先基于功能名说明你需要的最少业务背景，并邀请用户直接补充目标、使用者、约束和验收结果。收到用户的下一段需求描述后，运行时会将其原文注入 requirement-triage 并启动该步骤。",
-          "不要让用户输入命令；也不要把普通需求文本当成批准或 checkpoint 确认。",
-          "</devflow-requirement-draft-directive>",
-        ].join("\n"),
-      );
+      await startDynamicTurn(ctx, snapshot);
       return;
     }
     ctx.ui.notify(

package/plugins/devflow-core/skills/workflow-dynamic/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: workflow-dynamic
+description: Execute a Core-owned dynamic requirement plan, maintain one readable requirement document, route technical findings to repair skills, and ask only genuine business decisions. Use when the inspector reports mode dynamic; existing fixed workflows keep their own contracts.
+---
+
+# Dynamic requirement delivery
+
+Use `devflow_plan inspect` as the scheduling authority. Present task titles and progress in the user's language. Do not edit STATE, synthesize test results, or use legacy complete-step/checkpoint tools.
+
+## Intent and planning
+
+Read the single document returned by Core and inspect relevant source. Update that document for scope, approach, and acceptance requirements. Each acceptance clause has a stable heading such as `### R-1: Do not send another batch after the deadline`. Preserve IDs across wording changes. Cosmetic whitespace does not change the obligation. Removing an obligation requires a genuine scope decision; never delete a failed obligation to finish.
+
+Propose tasks with `revise`, including its inspected `expected_revision` and a plain-language change reason. Fields are `id`, `title`, `kind`, `requirements`, `dependencies`, `inputs`, `outputs`, `checks`. Allowed kinds: discover, implement, verify, review. Each check declares an executable `argv` array and optional timeout seconds. Inputs must include the relevant production code, tests, and configuration: a test file alone is insufficient. Prefer directories where additional source files affect behavior. Every acceptance clause needs a verification task. Code changes need an independent review task that depends on the implementation and verification tasks.
+
+Generate only applicable work. A backend-only feature has no UI, wireframe, browser-test, or frontend-document task. If applicability is unclear, investigate it before proposing that branch. Do not generate no-op documents. Tasks may produce source, tests, migrations, schemas or genuinely needed design assets; their existence must have a consumer.
+
+## Execution
+
+1. Inspect and claim the task selected by Core. Use the returned task ID and attempt for all subsequent results.
+2. Read its exact Skill ID. In dynamic mode use that skill's technical procedures, but the dynamic task supplies scope, inputs, outputs and acceptance. Legacy stage lists, mandatory Markdown/meta pairs and checkpoint instructions do not apply.
+3. For discovery/implementation/repair, do the work and call `report` with a factual summary. This records activity completion, not an acceptance pass.
+4. For verification, call `verify`. Core executes the declared commands and captures exit status and output. Do not substitute a shell transcript or self-reported pass. Use tests that assert the actual expected behavior, including production paths and meaningful failure scenarios.
+5. For review, dispatch a read-only `devflow-code-reviewer` task with the requirement document, task, source paths and recorded verification evidence. Ask for strict JSON `{"summary":"...","findings":[...]}`; each finding identifies the violated requirement, evidence, affected scope and suggested recheck. Submit its task-call ID using `review_result`; Core accepts only the captured child result, not your rewritten report.
+6. Continue ready tasks. Failed checks automatically create a bounded repair task. Read the finding and invoke its repair skill, then allow Core to rerun the original verification. Do not reset repair budgets by renaming tasks.
+
+## Changes, waiting, and recovery
+
+Keep stable task IDs. To cancel unnecessary work, retain the task with `cancelled: true` and a reason and rewire its consumers in the same proposal. Preserve verification coverage. A failed required behavior is a repair, not an irrelevant task.
+
+After a requirement edit, inspect and revise only affected work. Old evidence remains history and cannot certify changed inputs. Never weaken checks merely to obtain a pass.
+
+Use `decision` only for business alternatives, scope reduction, residual-risk choices, or actions outside existing authorization. Supply one clear question and two or three options with consequences; place the recommendation first. Core displays and records the actual user choice. Missing metadata, stale indexes, missing tests and repairable code defects are technical work, not user decisions. A cancelled choice stays pending; it is not approval. Continue independent tasks if possible.
+
+For removed acceptance clauses, include their IDs in `remove_requirements` and identify the exact `approval_option` in the decision. Only that actual user selection authorizes removing those clauses; bind the subsequent revision with `scope_decision_id`. A generic confirmation or a choice to retain scope is not permission to remove acceptance requirements.
+
+For an interrupted running/checking task, inspect actual effects first. Use `recover` with the findings only after establishing the previous operation is no longer running and retry is appropriate. Do not rerun uncertain external writes. Repair exhaustion remains failed: explain what was attempted and actionable next choices without claiming delivery complete.
+
+If an external dependency is unavailable, use `wait` with the task attempt and concrete reason. After read-only evidence establishes readiness, use `resume`; this creates eligibility for a new attempt. Do not classify missing generated documents as external dependencies.
+
+Summarize the readable task board and remaining decisions. Detailed machine evidence stays in Core; do not generate another report document for each invocation.

package/plugins/devflow-core/skills/workflow-orchestrator/SKILL.md

@@ -3,6 +3,9 @@ name: workflow-orchestrator
 description: Use when the user asks to continue, resume, advance, inspect, or route a .devflow/planning-based workflow; when the OMP development agent must decide the next workflow skill from project state; or when a checkpoint must be handled before proceeding.
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 ## 默认软门禁策略
 
 工作流硬门禁已移除。下文及各步骤中的产物、索引、合同、审查、质量、恢复和 CP 审批条件均为诊断建议：保留失败证据和缺项，允许继续执行。用户说“下一步”即可推进，无需额外批准弹窗；不得把继续执行记录成人工批准，也不得把失败、未执行的测试改写为通过。真实读写/执行失败、无法解析的状态和并发版本冲突须如实报告。硬门禁及其恢复开关已移除。

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/advance_state.rb

@@ -15,6 +15,12 @@ require_relative "validate_state"
 require_relative "phase_ownership"
 require_relative "requirement_graph"
 require_relative "gate_runtime"
+require_relative "dynamic_plan"
+
+if DynamicPlan.read_state(Dir.pwd)&.dig("current_flow") == "dynamic"
+  puts JSON.generate({ "ok" => false, "reason" => "dynamic_plan_requires_evidence", "message" => "Use devflow_plan; legacy complete-step cannot complete dynamic tasks." })
+  exit 1
+end
 
 options = {
   state: nil,

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/dynamic_plan.rb

@@ -0,0 +1,504 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "digest"
+require "securerandom"
+require "open3"
+require "timeout"
+require_relative "control_io"
+
+# STATE is the only mutable authority. Documents own intent, never verdicts.
+module DynamicPlan
+  SKILLS = {
+    "discover" => "workflow-requirement-triage",
+    "implement" => "workflow-execute-phase",
+    "repair" => "workflow-bug-fix",
+    "verify" => "workflow-run-acceptance-tests",
+    "review" => "code-review"
+  }.freeze
+  module_function
+
+  def digest(value)
+    Digest::SHA256.hexdigest(JSON.generate(value))
+  end
+
+  def normalize(text)
+    text.to_s.split.join(" ")
+  end
+
+  def path(root, relative)
+    raise ArgumentError, "project-relative path required" unless relative.is_a?(String) && !relative.empty? && !relative.start_with?("/") && !relative.split(/[\\\/]/).include?("..")
+    absolute = File.expand_path(relative, root)
+    cursor = absolute
+    cursor = File.dirname(cursor) until File.exist?(cursor) || File.symlink?(cursor)
+    real = File.realpath(cursor)
+    raise ArgumentError, "path escapes project" unless real == File.realpath(root) || real.start_with?(File.realpath(root) + "/")
+    absolute
+  end
+
+  def clauses(root, plan)
+    text = File.read(path(root, plan.fetch("document")))
+    result = {}
+    text.scan(/^### (R-[A-Za-z0-9_-]+)[:：]([^\n]*\n(?:(?!^### |^## ).*\n?)*)/).each do |id, body|
+      raise ArgumentError, "duplicate requirement #{id}" if result.key?(id)
+      result[id] = normalize(body)
+    end
+    result
+  end
+
+  def file_pin(root, relative)
+    absolute = path(root, relative)
+    return "missing" unless File.exist?(absolute)
+    return Digest::SHA256.file(absolute).hexdigest if File.file?(absolute)
+    entries = Dir.glob(File.join(absolute, "**", "*"), File::FNM_DOTMATCH).sort.filter_map do |entry|
+      next if entry.sub(absolute + "/", "").split("/").any? { |part| %w[.git node_modules .devflow __pycache__].include?(part) }
+      next unless File.file?(entry)
+      safe = path(root, entry.sub(File.expand_path(root) + "/", ""))
+      [entry.sub(absolute + "/", ""), Digest::SHA256.file(safe).hexdigest]
+    end
+    digest(entries)
+  end
+
+  def pins(root, plan, task)
+    requirements = clauses(root, plan)
+    {
+      "requirements" => task.fetch("requirements").to_h { |id| [id, requirements[id]] },
+      "inputs" => task.fetch("inputs").to_h { |file| [file, file_pin(root, file)] },
+      "spec" => digest(task.slice("kind", "requirements", "inputs", "outputs", "checks"))
+    }
+  end
+
+  def validate!(root, plan)
+    tasks = plan.fetch("tasks")
+    raise ArgumentError, "tasks must be an array" unless tasks.is_a?(Array)
+    ids = tasks.map { |task| task.fetch("id") }
+    raise ArgumentError, "duplicate task ids" unless ids.uniq == ids
+    tasks.each do |task|
+      raise ArgumentError, "invalid task id" unless task["id"].match?(/\A[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}\z/)
+      raise ArgumentError, "unknown capability" unless SKILLS.key?(task["kind"])
+      raise ArgumentError, "task title required" if task["title"].to_s.strip.empty?
+      %w[dependencies requirements inputs outputs checks].each { |key| raise ArgumentError, "#{key} must be an array" unless task[key].is_a?(Array) }
+      raise ArgumentError, "unknown dependency" unless (task["dependencies"] - ids).empty?
+      (task["inputs"] + task["outputs"]).each { |file| path(root, file) }
+      raise ArgumentError, "verification needs inputs and executable checks" if task["kind"] == "verify" && (task["checks"].empty? || task["inputs"].empty?)
+      raise ArgumentError, "review needs source inputs" if task["kind"] == "review" && task["inputs"].empty?
+      task["checks"].each do |check|
+        argv = check["argv"]
+        raise ArgumentError, "checks require nonempty argv arrays" unless argv.is_a?(Array) && argv.any? && argv.all? { |arg| arg.is_a?(String) && !arg.include?("\0") }
+      end
+      next unless task["status"] == "cancelled"
+      raise ArgumentError, "cancellation reason required" if task["reason"].to_s.strip.empty?
+      raise ArgumentError, "cancelled task still has consumers" if tasks.any? { |other| other["status"] != "cancelled" && other["dependencies"].include?(task["id"]) }
+    end
+    visited, visiting = [], []
+    visit = lambda do |id|
+      raise ArgumentError, "cyclic task dependencies" if visiting.include?(id)
+      return if visited.include?(id)
+      visiting << id
+      tasks.find { |task| task["id"] == id }["dependencies"].each { |dependency| visit.call(dependency) }
+      visiting.delete(id)
+      visited << id
+    end
+    ids.each { |id| visit.call(id) }
+    requirements = clauses(root, plan)
+    active = tasks.reject { |task| task["status"] == "cancelled" }
+    active.each do |task|
+      raise ArgumentError, "unknown requirement" unless (task["requirements"] - requirements.keys).empty?
+    end
+    unless tasks.empty? || plan["cancelled"]
+      raise ArgumentError, "requirement clauses missing from main document" if requirements.empty?
+      requirements.each_key do |id|
+        raise ArgumentError, "#{id} has no verification task" unless active.any? { |task| task["kind"] == "verify" && task["requirements"].include?(id) }
+      end
+      if active.any? { |task| %w[implement repair].include?(task["kind"]) }
+        raise ArgumentError, "code changes require independent review" unless active.any? { |task| task["kind"] == "review" }
+      end
+      ancestors = lambda do |task|
+        task["dependencies"].flat_map do |id|
+          [id, *ancestors.call(tasks.find { |other| other["id"] == id })]
+        end.uniq
+      end
+      active.select { |task| task["kind"] == "verify" }.each do |task|
+        producers = active.select { |other| other["kind"] == "implement" && (other["requirements"] & task["requirements"]).any? }
+        raise ArgumentError, "verification must depend on its implementation" unless (producers.map { |item| item["id"] } - ancestors.call(task)).empty?
+      end
+      if active.any? { |task| %w[implement repair].include?(task["kind"]) }
+        changed_requirements = active.select { |task| %w[implement repair].include?(task["kind"]) }.flat_map { |task| task["requirements"] }.uniq
+        changed_requirements.each do |id|
+          verifiers = active.select { |task| task["kind"] == "verify" && task["requirements"].include?(id) }
+          covered = active.any? do |task|
+            task["kind"] == "review" && task["requirements"].include?(id) && (verifiers.map { |item| item["id"] } - ancestors.call(task)).empty?
+          end
+          raise ArgumentError, "#{id} needs review after verification" unless covered
+        end
+      end
+    end
+    true
+  end
+
+  def refresh!(root, plan)
+    plan["tasks"].each do |task|
+      next unless task["status"] == "completed" && task["evidence"]
+      current_pins = pins(root, plan, task)
+      observed_pins = task["evidence"]["pins"]
+      unchanged = if %w[implement repair].include?(task["kind"])
+                    observed_pins.slice("requirements", "spec") == current_pins.slice("requirements", "spec")
+                  else
+                    observed_pins == current_pins
+                  end
+      next if unchanged
+      task["status"] = "pending"
+      task["verification"] = "stale"
+    end
+    loop do
+      changed = false
+      plan["tasks"].each do |task|
+        next unless task["status"] == "completed"
+        next if task["dependencies"].all? { |id| plan["tasks"].find { |other| other["id"] == id }&.dig("status") == "completed" }
+        task["status"], task["verification"], changed = "pending", "stale", true
+      end
+      break unless changed
+    end
+  end
+
+  def snapshot(root, state)
+    plan = state.fetch("plan")
+    refresh!(root, plan)
+    validation_error = begin
+      validate!(root, plan)
+      nil
+    rescue ArgumentError, KeyError => error
+      error.message
+    end
+    tasks = plan["tasks"]
+    ready = tasks.find do |task|
+      task["status"] == "pending" && task["dependencies"].all? { |id| tasks.find { |other| other["id"] == id }&.dig("status") == "completed" }
+    end
+    running = tasks.find { |task| %w[running checking].include?(task["status"]) }
+    complete = tasks.any? && tasks.all? { |task| %w[completed cancelled].include?(task["status"]) } && plan.fetch("decisions", []).none? { |item| item["status"] == "pending" }
+    action = if plan["cancelled"] then "workflow_cancelled"
+             elsif validation_error then "reconcile_plan"
+             elsif tasks.empty? then "plan_work"
+             elsif running then "resume_task"
+             elsif ready then "run_task"
+             elsif complete then "workflow_complete"
+             else "waiting" end
+    selected = running || ready
+    {
+      "ok" => true, "mode" => "dynamic", "action" => action, "revision" => state["revision"],
+      "current_flow" => "dynamic", "current_feature" => state["current_feature"], "current_phase" => state["current_phase"],
+      "status" => plan["cancelled"] ? "cancelled" : (complete && !validation_error ? "completed" : "in_progress"),
+      "document" => plan["document"], "plan_revision" => plan["revision"], "reason" => validation_error,
+      "progress_key" => digest(tasks.map { |task| task.slice("id", "status", "verification", "attempt").merge("results" => task.fetch("history", []).length) }),
+      "delivery" => plan["cancelled"] ? "cancelled" : (complete && !validation_error ? "ready" : "incomplete"),
+      "current_step" => selected && selected.merge("label" => selected["title"], "skill" => SKILLS[selected["kind"]]),
+      "workflow_steps" => tasks.map { |task| task.slice("id", "status", "verification", "reason").merge("label" => task["title"]) },
+      "tasks" => tasks, "decisions" => plan.fetch("decisions", [])
+    }
+  end
+
+  def read_state(root)
+    file, = DevflowControlIO.resolve_control_path(root, ".devflow/planning/STATE.md", :state)
+    return nil unless File.file?(file)
+    YAML.safe_load(File.read(file)[/\A---\n(.*?)\n---\n/m, 1], permitted_classes: [], aliases: false)
+  end
+
+  def save(root, state)
+    state["revision"] += 1
+    view = snapshot(root, state)
+    state["status"] = view["status"]
+    state["current_step"] = view.dig("current_step", "id")
+    state["completed_steps"] = state["plan"]["tasks"].select { |task| task["status"] == "completed" }.map { |task| task["id"] }
+    state["pending_steps"] = state["plan"]["tasks"].reject { |task| %w[completed cancelled].include?(task["status"]) }.map { |task| task["id"] }
+    file, = DevflowControlIO.resolve_control_path(root, ".devflow/planning/STATE.md", :state)
+    # JSON round-trip removes shared object identities; safe YAML readers must
+    # never need aliases to read a runtime state snapshot.
+    DevflowControlIO.atomic_write(file, JSON.parse(JSON.generate(state)).to_yaml + "---\n\n# Runtime state\n\nManaged by Core. Edit the requirement document to change intent.\n")
+    snapshot(root, state)
+  end
+
+  def transact(root, expected)
+    lock = DevflowControlIO.acquire_project_lock(root)
+    state = read_state(root)
+    raise ArgumentError, "dynamic plan not initialized" unless state && state["current_flow"] == "dynamic"
+    raise ArgumentError, "REVISION_CONFLICT: inspect again" unless expected.is_a?(Integer) && expected == state["revision"]
+    before = digest(state)
+    refresh!(root, state["plan"])
+    yield state
+    return snapshot(root, state) if digest(state) == before
+    save(root, state)
+  ensure
+    DevflowControlIO.release_lock(lock)
+  end
+
+  def run_check(root, check)
+    output, status, timed_out = +"", nil, false
+    seconds = [[Integer(check.fetch("timeout", 120)), 1].max, 600].min
+    Open3.popen2e(*check.fetch("argv"), chdir: root, pgroup: true) do |stdin, stream, wait|
+      stdin.close
+      reader = Thread.new do
+        loop do
+          chunk = stream.readpartial(4096)
+          output << chunk if output.bytesize < 32_768
+        end
+      rescue EOFError, IOError
+        nil
+      end
+      begin
+        Timeout.timeout(seconds) { status = wait.value.exitstatus }
+      rescue Timeout::Error
+        timed_out = true
+        Process.kill("KILL", -wait.pid) rescue nil
+        wait.value
+      ensure
+        # Drain the exited child's buffered output before closing the pipe.
+        # A descendant retaining the pipe cannot keep recovery waiting forever.
+        reader.join(1)
+        stream.close unless stream.closed?
+        reader.join
+      end
+    end
+    { "argv" => check["argv"], "exit_code" => status, "timeout" => timed_out, "output" => output.encode("UTF-8", invalid: :replace, undef: :replace), "passed" => status == 0 && !timed_out }
+  rescue SystemCallError => error
+    { "argv" => check["argv"], "passed" => false, "output" => error.message }
+  end
+
+  def failure!(plan, task, evidence)
+    task["status"], task["verification"] = "failed", "fail"
+    fingerprint = digest(evidence["checks"]&.map { |check| check.slice("argv", "exit_code", "output") } || evidence["review"])
+    previous = task.fetch("history", [])[0...-1].last
+    attempts = task.fetch("repair_attempts", 0)
+    if attempts >= 2 || (previous && previous["finding"] == fingerprint && previous["pins"] == evidence["pins"])
+      task["reason"] = "自动修复已停止：达到次数上限或没有进展；保留失败结果。"
+      return
+    end
+    evidence["finding"] = fingerprint
+    task["repair_attempts"] = attempts + 1
+    repair_id = "repair-#{digest(task['id'])[0, 12]}-#{attempts + 1}"
+    task["status"] = "pending"
+    task["dependencies"] << repair_id
+    plan["tasks"] << {
+      "id" => repair_id, "title" => "修复：#{task['title']}", "kind" => "repair", "requirements" => task["requirements"].dup,
+      "inputs" => task["inputs"].dup, "outputs" => [], "checks" => [], "dependencies" => [], "status" => "pending",
+      "verification" => "not_run", "finding" => evidence, "repairs" => task["id"], "history" => []
+    }
+    unless plan["tasks"].any? { |item| item["kind"] == "review" && item["status"] != "cancelled" && (task["requirements"] - item["requirements"]).empty? }
+      plan["tasks"] << {
+        "id" => "review-#{digest(task['id'])[0, 12]}-#{attempts + 1}", "title" => "独立审查修复结果", "kind" => "review", "requirements" => task["requirements"].dup,
+        "inputs" => task["inputs"].dup, "outputs" => [], "checks" => [], "dependencies" => plan["tasks"].select { |item| item["kind"] == "verify" && item["status"] != "cancelled" && (item["requirements"] & task["requirements"]).any? }.map { |item| item["id"] },
+        "status" => "pending", "verification" => "not_run", "history" => []
+      }
+    end
+    plan["revision"] += 1
+  end
+
+  def dispatch(root, request)
+    action = request.fetch("action")
+    if action == "inspect"
+      state = read_state(root)
+      return { "ok" => true, "mode" => "legacy" } unless state && state["current_flow"] == "dynamic"
+      return snapshot(root, state)
+    end
+    if action == "initialize"
+      lock = DevflowControlIO.acquire_project_lock(root)
+      begin
+        old = read_state(root)
+        raise ArgumentError, "active workflow exists; continue it or explicitly migrate" if old && !%w[completed cancelled].include?(old["status"])
+        feature = request.fetch("feature").to_s.strip
+        raise ArgumentError, "feature required" if feature.empty?
+        if old
+          archive = path(root, ".devflow/runs/plans/#{Digest::SHA256.hexdigest(old['current_phase'].to_s)[0, 16]}-#{SecureRandom.uuid}.json")
+          DevflowControlIO.atomic_write(archive, JSON.pretty_generate(old))
+        end
+        phase = request["phase"] || "feature-#{Digest::SHA256.hexdigest(feature)[0, 12]}-#{SecureRandom.hex(3)}"
+        raise ArgumentError, "invalid phase identifier" unless phase.is_a?(String) && phase.match?(/\A[A-Za-z0-9][A-Za-z0-9_-]{0,63}\z/)
+        document = ".devflow/planning/features/#{phase}/需求.md"
+        absolute = path(root, document)
+        raise ArgumentError, "requirement document already exists; choose a new phase or resume" if File.exist?(absolute)
+        DevflowControlIO.atomic_write(absolute, "# #{feature}\n\n## 目标与范围\n\n#{request.fetch('description', feature)}\n\n## 验收要求\n\n在需求核实后，将可验证要求写成 `### R-1: 要求描述`，每条保留稳定编号。\n\n## 方案与决定\n\n执行进度由 Core 展示；此处不手工记录通过状态。\n")
+        state = { "state_schema_version" => 3, "revision" => old ? old["revision"] : -1, "current_flow" => "dynamic", "current_feature" => feature, "current_phase" => phase,
+                  "plan" => { "version" => 1, "revision" => 0, "document" => document, "tasks" => [], "decisions" => [], "changes" => [] } }
+        return save(root, state)
+      ensure
+        DevflowControlIO.release_lock(lock)
+      end
+    end
+    if action == "verify"
+      claim = transact(root, request["expected_revision"]) do |state|
+        task = state["plan"]["tasks"].find { |item| item["id"] == request["task_id"] }
+        raise ArgumentError, "running verification attempt required" unless task && task["kind"] == "verify" && task["status"] == "running" && task["attempt"] == request["attempt"]
+        task["status"] = "checking"
+        task["runner_pid"] = Process.pid
+        task["check_pins"] = pins(root, state["plan"], task)
+      end
+      task = claim["tasks"].find { |item| item["id"] == request["task_id"] }
+      checks = task["checks"].map { |check| run_check(root, check) }
+      return transact(root, claim["revision"]) do |state|
+        current = state["plan"]["tasks"].find { |item| item["id"] == task["id"] }
+        raise ArgumentError, "verification inputs changed during execution" unless current["attempt"] == task["attempt"] && task["check_pins"] == pins(root, state["plan"], current)
+        evidence = { "attempt" => task["attempt"], "pins" => task["check_pins"], "checks" => checks, "at" => Time.now.utc.iso8601 }
+        current["history"] << evidence
+        current["evidence"] = evidence
+        if checks.all? { |check| check["passed"] }
+          current["status"], current["verification"] = "completed", "pass"
+        else
+          failure!(state["plan"], current, evidence)
+        end
+      end
+    end
+    transact(root, request["expected_revision"]) do |state|
+      plan = state["plan"]
+      raise ArgumentError, "workflow was cancelled; create a new requirement" if plan["cancelled"]
+      case action
+      when "cancel"
+        raise ArgumentError, "cancellation must come from user runtime action" unless request["runtime_cancel"] == true
+        plan["cancelled"] = true
+        plan["cancel_reason"] = request.fetch("reason")
+        plan["tasks"].each do |task|
+          next if task["status"] == "completed"
+          task["status"], task["reason"] = "cancelled", plan["cancel_reason"]
+          task.delete("attempt")
+        end
+      when "revise"
+        old_tasks = plan["tasks"].to_h { |task| [task["id"], task] }
+        new_requirements = clauses(root, plan)
+        scope_decision = plan["decisions"].find { |item| item["id"] == request["scope_decision_id"] }
+        permitted_removals = if scope_decision && scope_decision["status"] == "answered" && scope_decision["choice"] == scope_decision["approval_option"] && scope_decision["requirements_pin"] == digest(plan.fetch("requirements", {}))
+                              scope_decision.fetch("remove_requirements", [])
+                            else [] end
+        proposal = request.fetch("tasks")
+        raise ArgumentError, "keep removed tasks as cancelled with reasons" unless (old_tasks.keys - proposal.map { |task| task["id"] }).empty?
+        new_tasks = proposal.map do |item|
+          spec = item.slice("id", "title", "kind", "requirements", "inputs", "outputs", "checks", "dependencies")
+          %w[requirements inputs outputs checks dependencies].each { |key| spec[key] ||= [] }
+          old = old_tasks[item["id"]]
+          candidate = (old || { "status" => "pending", "verification" => "not_run", "history" => [] }).merge(spec)
+          changed = old && spec.any? { |key, value| key != "title" && old[key] != value }
+          if changed
+            candidate["status"], candidate["verification"] = "pending", "stale"
+            candidate.delete("attempt")
+          end
+          if item["cancelled"] == true
+            if old && old["verification"] == "fail"
+              withdrawn = (old["requirements"] - permitted_removals).empty? && (old["requirements"] & new_requirements.keys).empty?
+              raise ArgumentError, "cannot cancel a failing obligation without its explicit scope withdrawal" unless withdrawn
+            end
+            candidate["status"], candidate["reason"] = "cancelled", item["reason"]
+            candidate.delete("attempt")
+          end
+          candidate
+        end
+        plan["tasks"] = new_tasks
+        validate!(root, plan)
+        old_requirements = plan.fetch("requirements", {})
+        removed = old_requirements.keys - new_requirements.keys
+        raise ArgumentError, "removing acceptance requirements needs an explicit scope decision for those clauses" unless (removed - permitted_removals).empty?
+        plan["requirements"] = new_requirements
+        plan["revision"] += 1
+        plan["changes"] << { "revision" => plan["revision"], "reason" => request.fetch("reason"), "at" => Time.now.utc.iso8601 }
+      when "claim"
+        view = snapshot(root, state)
+        raise ArgumentError, "no runnable task" unless view["action"] == "run_task"
+        task = plan["tasks"].find { |item| item["id"] == view.dig("current_step", "id") }
+        task["status"], task["attempt"] = "running", SecureRandom.uuid
+        task["started_at"] = Time.now.utc.iso8601
+        task["dispatch_pins"] = pins(root, plan, task)
+      when "report", "review_result"
+        task = plan["tasks"].find { |item| item["id"] == request["task_id"] }
+        raise ArgumentError, "stale or missing task attempt" unless task && task["status"] == "running" && task["attempt"] == request["attempt"]
+        raise ArgumentError, "verification must run through Core" if task["kind"] == "verify"
+        if task["kind"] == "review"
+          raise ArgumentError, "independent reviewer result required" unless action == "review_result" && request["runtime_review"] == true
+          raise ArgumentError, "review inputs changed" unless task["dispatch_pins"] == pins(root, plan, task)
+          report = request.fetch("report")
+          raise ArgumentError, "invalid reviewer report" unless report["findings"].is_a?(Array) && report["summary"].is_a?(String)
+          evidence = { "pins" => pins(root, plan, task), "review" => report, "task_call_id" => request.fetch("task_call_id"), "attempt" => task["attempt"] }
+          task["history"] << evidence
+          task["evidence"] = evidence
+          if report["findings"].empty?
+            task["status"], task["verification"] = "completed", "pass"
+          else
+            failure!(plan, task, evidence)
+          end
+        else
+          raise ArgumentError, "requirements changed during execution" unless task["dispatch_pins"]["requirements"] == pins(root, plan, task)["requirements"]
+          raise ArgumentError, "result summary required" if request["summary"].to_s.strip.empty?
+          raise ArgumentError, "expected output missing" unless task["outputs"].all? { |file| File.exist?(path(root, file)) }
+          # Implementation is an activity result, never an acceptance pass.
+          evidence = { "pins" => pins(root, plan, task), "summary" => request["summary"], "attempt" => task["attempt"] }
+          task["evidence"] = evidence
+          task["history"] << evidence
+          task["status"], task["verification"] = "completed", "not_run"
+        end
+      when "recover"
+        task = plan["tasks"].find { |item| item["id"] == request["task_id"] }
+        raise ArgumentError, "only an interrupted attempt may recover" unless task && %w[running checking].include?(task["status"])
+        if task["status"] == "checking" && task["runner_pid"]
+          alive = begin
+            Process.kill(0, task["runner_pid"])
+            true
+          rescue Errno::ESRCH
+            false
+          end
+          raise ArgumentError, "verification process is still running" if alive
+        end
+        raise ArgumentError, "inspect actual effects and provide a recovery reason" if request["reason"].to_s.strip.empty?
+        task["history"] << { "attempt" => task["attempt"], "interrupted" => true, "reason" => request["reason"] }
+        task["status"] = "pending"
+        task.delete("attempt")
+      when "wait"
+        task = plan["tasks"].find { |item| item["id"] == request["task_id"] }
+        raise ArgumentError, "running attempt required" unless task && task["status"] == "running" && task["attempt"] == request["attempt"]
+        raise ArgumentError, "external dependency reason required" if request["reason"].to_s.strip.empty?
+        task["status"], task["reason"] = "waiting_external", request["reason"]
+      when "resume"
+        task = plan["tasks"].find { |item| item["id"] == request["task_id"] }
+        raise ArgumentError, "external waiting task required" unless task && task["status"] == "waiting_external"
+        raise ArgumentError, "evidence that external dependency is ready required" if request["reason"].to_s.strip.empty?
+        task["history"] << { "resumed" => true, "reason" => request["reason"] }
+        task["status"] = "pending"
+        task.delete("attempt")
+      when "decision"
+        options = request.fetch("options")
+        raise ArgumentError, "provide two or three concrete options" unless options.is_a?(Array) && (2..3).include?(options.length) && options.all? { |item| item.is_a?(String) && !item.strip.empty? }
+        question = request.fetch("question")
+        removals = request.fetch("remove_requirements", [])
+        raise ArgumentError, "scope removal must name existing requirement IDs" unless removals.is_a?(Array) && (removals - plan.fetch("requirements", {}).keys).empty?
+        raise ArgumentError, "scope removal needs an explicit approving option" if removals.any? && !options.include?(request["approval_option"])
+        binding = file_pin(root, plan["document"])
+        unless plan["decisions"].any? { |item| item["question"] == question && item["document_pin"] == binding }
+          plan["decisions"].select { |item| item["question"] == question && item["status"] == "pending" }.each { |item| item["status"] = "superseded" }
+          affected = request["task_ids"] || [snapshot(root, state).dig("current_step", "id")].compact
+          raise ArgumentError, "unknown affected decision task" unless (affected - plan["tasks"].map { |task| task["id"] }).empty?
+          blocked = plan["tasks"].select { |task| affected.include?(task["id"]) && !%w[completed cancelled].include?(task["status"]) }
+          prior = blocked.to_h { |task| [task["id"], task["status"] == "waiting_decision" ? "pending" : task["status"]] }
+          blocked.each { |task| task["status"] = "waiting_decision" }
+          plan["decisions"] << { "id" => SecureRandom.uuid, "question" => question, "options" => options, "status" => "pending", "document_pin" => binding, "requirements_pin" => digest(plan.fetch("requirements", {})), "blocked_tasks" => prior, "remove_requirements" => removals, "approval_option" => request["approval_option"] }
+        end
+      when "decide"
+        raise ArgumentError, "user response must come from runtime UI" unless request["runtime_decision"] == true
+        decision = plan["decisions"].find { |item| item["id"] == request["decision_id"] }
+        raise ArgumentError, "decision expired" unless decision && decision["status"] == "pending" && decision["document_pin"] == file_pin(root, plan["document"])
+        raise ArgumentError, "invalid option" unless decision["options"].include?(request["choice"])
+        decision["status"], decision["choice"] = "answered", request["choice"]
+        decision.fetch("blocked_tasks", {}).each do |id, prior|
+          task = plan["tasks"].find { |item| item["id"] == id }
+          still_blocked = plan["decisions"].any? { |item| item["status"] == "pending" && item.fetch("blocked_tasks", {}).key?(id) }
+          task["status"] = prior if task && task["status"] == "waiting_decision" && !still_blocked
+        end
+      else
+        raise ArgumentError, "unknown dynamic plan action"
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  begin
+    puts JSON.generate(DynamicPlan.dispatch(Dir.pwd, JSON.parse(STDIN.read)))
+  rescue StandardError => error
+    puts JSON.generate({ "ok" => false, "reason" => error.message })
+    exit 1
+  end
+end

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/inspect_state.rb

@@ -7,6 +7,7 @@ require "yaml"
 require_relative "validate_state"
 require_relative "checkpoint_meta"
 require_relative "gate_policy"
+require_relative "dynamic_plan"
 
 options = { json: false, state: nil }
 OptionParser.new do |opts|
@@ -16,6 +17,11 @@ OptionParser.new do |opts|
 end.parse!
 
 root = Dir.pwd
+dynamic_state = DynamicPlan.read_state(root)
+if dynamic_state && dynamic_state["current_flow"] == "dynamic"
+  puts JSON.pretty_generate(DynamicPlan.snapshot(root, dynamic_state))
+  exit 0
+end
 state_path = options[:state] ? File.expand_path(options[:state], root) : File.join(root, ".devflow/planning", "STATE.md")
 
 def fail_result(reason, details = {})

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/sync_artifacts.rb

@@ -69,6 +69,10 @@ project_lock = DevflowControlIO.acquire_project_lock(root) if options[:write]
 begin
 state_path, = DevflowControlIO.resolve_control_path(root, options[:state], :state)
 state = load_state(state_path)
+if state["current_flow"] == "dynamic"
+  puts JSON.generate({ "ok" => true, "written" => false, "mode" => "dynamic", "reason" => "task evidence is maintained in STATE; no per-skill artifact registry required" })
+  exit 0
+end
 ownership = PhaseOwnership.validate_state(root: root, state: state)
 unless ownership["ok"]
   puts JSON.pretty_generate(ownership.merge("written" => false))

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/validate_state.rb

@@ -60,6 +60,15 @@ module WorkflowStateValidator
     issues = []
 
     state = state_override || load_state(state_path, issues)
+    if state && state["current_flow"] == "dynamic"
+      require_relative "dynamic_plan"
+      begin
+        DynamicPlan.validate!(root, state.fetch("plan"))
+      rescue ArgumentError, KeyError => error
+        issues << issue("error", "invalid_dynamic_plan", error.message)
+      end
+      return result(issues.empty?, state_path, nil, nil, issues)
+    end
     return result(false, state_path, nil, nil, issues) unless state
 
     REQUIRED_STATE_FIELDS.each do |field|

package/plugins/devflow-core/skills/workflow-pipeline/SKILL.md

@@ -3,6 +3,9 @@ name: workflow-pipeline
 description: Use when running or resuming the full .devflow/planning delivery pipeline from requirements through implementation, frozen acceptance tests, and Devflow release closeout.
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 ## 默认软门禁策略
 
 工作流硬门禁已移除。下文及各步骤中的产物、索引、合同、审查、质量、恢复和 CP 审批条件均为诊断建议：保留失败证据和缺项，允许继续执行。用户说“下一步”即可推进，无需额外批准弹窗；不得把继续执行记录成人工批准，也不得把失败、未执行的测试改写为通过。真实读写/执行失败、无法解析的状态和并发版本冲突须如实报告。硬门禁及其恢复开关已移除。

package/plugins/devflow-implementation/skills/workflow-bug-fix/SKILL.md

@@ -3,6 +3,9 @@ name: workflow-bug-fix
 description: "Use when a bug must be traced through workflow artifacts, root-caused, fixed, verified, and captured as a lesson when needed."
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
 
 ## Legacy Command Metadata

package/plugins/devflow-implementation/skills/workflow-execute-phase/SKILL.md

@@ -3,6 +3,9 @@ name: workflow-execute-phase
 description: "Use when a planned .devflow/planning phase needs implementation, dependency-aware task execution, progress tracking, and verification evidence."
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
 
 ## Legacy Command Metadata

package/plugins/devflow-quality/agents/code-reviewer.md

@@ -13,6 +13,8 @@ autoloadSkills:
   - code-review
 ---
 
+For a Core dynamic-plan review (task kind `review`, mode `dynamic`), read the requirement main document, production source, tests and Core verification evidence directly. Use only applicable review surfaces. Return strict JSON `{ "summary": "evidence inspected and conclusion", "findings": [] }`; findings must include requirement ID, file/line evidence, triggering scenario, impact and recheck. Missing technical evidence is a finding to collect or repair, not a request for the user to manufacture metadata. An empty findings array requires evidence supporting every linked acceptance requirement. The legacy frozen-test-case and REVIEW.md contract below applies only to legacy fixed workflows. Remain read-only.
+
 Review the actual diff and its affected call paths. Prefer concrete defects over style commentary. Treat the parent agent's task summary as scope guidance, never as acceptance authority: verify each expected behavior against confirmed Core requirements/contracts or an explicit human decision, then independently read the relevant source and test evidence at fixed revisions. For each finding provide severity, authoritative expectation reference, source file and location, triggering scenario, impact, evidence status, and a minimal fix direction. Verify whether tests cover the failure. If an essential business fact is absent or conflicting, stop and return the exact question requiring human confirmation; do not infer a clean result.
 
 Do not edit code, fix findings, or mutate workflow state. If no actionable finding remains, say so and list the validation evidence inspected.

package/plugins/devflow-quality/skills/code-review/SKILL.md

@@ -3,6 +3,9 @@ name: code-review
 description: "Use when code needs review for project conventions, spec compliance, behavioral risks, missing tests, change-list completion criteria verification, or post-refactor validation."
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
 
 # 代码规范审查技能

package/plugins/devflow-quality/skills/workflow-run-acceptance-tests/SKILL.md

@@ -3,6 +3,9 @@ name: workflow-run-acceptance-tests
 description: "Execute the frozen TC acceptance suite after code review. Use the requirement baseline and frozen TC nodes for test intent; use current code only to bind execution adapters."
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
 
 # 冻结验收测试执行

package/plugins/devflow-requirements/skills/workflow-requirement-triage/SKILL.md

@@ -3,6 +3,9 @@ name: workflow-requirement-triage
 description: "Use as the lightweight first step for a new request, bug report, PRD, or feature idea. Classify the request, check shallow duplicate and prior out-of-scope/rejected decisions, then route a viable request into workflow-wayfinder; do not perform deep requirement validation or route directly to baseline."
 ---
 
+Dynamic plan mode: when Core reports `mode: dynamic`, use `workflow-dynamic` as the execution protocol. The selected task supplies scope, dependencies, required outputs and verification. Use this skill's relevant technical guidance, but do not create legacy stage documents/meta pairs, require fixed checkpoints, or advance legacy STATE. Return activity/evidence to `devflow_plan`; only Core records verification.
+
+
 门禁策略：默认软门禁，门禁行为以本段为准。本文及引用材料中的前置检查、审查、质量、完成条件和 CP 确认用于诊断；未满足时记录缺项、风险与后续处理，继续可执行的工作，不自动阻断阶段推进。保留真实的 failed/blocked/未审批状态，不把继续执行写成通过或人工批准。硬门禁及其恢复开关已移除。
 
 # Workflow: Requirement Triage（需求入口分诊）

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.106";
+export const PRODUCT_VERSION = "0.1.107";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";
 

package/src/dynamic-workflow.ts

@@ -0,0 +1,31 @@
+/** Presentation only. The revisioned Core plan owns every execution fact. */
+export function renderDynamicWorkflow(snapshot: Record<string, unknown>, showHistory = false): string {
+  const tasks = (snapshot.workflow_steps ?? []) as Array<Record<string, unknown>>;
+  const marks: Record<string, string> = { completed: "✓", cancelled: "—", pending: "○", running: "●", checking: "●", failed: "✗" };
+  const labels: Record<string, string> = { cancelled: "已取消", waiting_decision: "待确认", waiting_external: "等待外部条件", failed: "未通过", checking: "验证中" };
+  const visible = !showHistory && tasks.length > 8 ? tasks.filter(task => !["completed", "cancelled"].includes(String(task.status))) : tasks;
+  const lines = visible.map(task => `${marks[String(task.status)] ?? "○"} ${task.label}${labels[String(task.status)] ? `（${labels[String(task.status)]}）` : ""}${task.verification === "stale" ? "（需要重新验证）" : ""}${task.reason ? `：${task.reason}` : ""}`);
+  if (visible.length < tasks.length) lines.push(`已折叠 ${tasks.length - visible.length} 项历史记录，可在 /devflow control 查看全部步骤。`);
+  const decisions = (snapshot.decisions ?? []) as Array<Record<string, unknown>>;
+  for (const decision of decisions.filter(item => item.status === "pending")) lines.push(`待确认：${decision.question}`);
+  return [String(snapshot.current_feature ?? "需求工作流"), `需求说明：${snapshot.document}`, ...lines,
+    snapshot.delivery === "ready" ? "验收证据齐备，可以交付。" : snapshot.delivery === "cancelled" ? "需求已取消，历史结果已保留。" : snapshot.reason ? `需要调整计划：${snapshot.reason}` : "",
+  ].filter(Boolean).join("\n");
+}
+
+export function dynamicWorkflowDirective(snapshot: Record<string, unknown>): string {
+  return [
+    "<devflow-dynamic-workflow>",
+    "读取 skill://workflow-dynamic。当前是动态计划模式，按需求选择工作，不套用固定阶段和逐步审批。",
+    "Core STATE 是计划与结果的唯一写入入口。通过 devflow_plan inspect/revise/claim/report/verify 管理任务。",
+    "先读需求主文档和下列真实状态。没有计划时，核实项目后在主文档验收要求下维护稳定的 ### R-1: 描述 条目，提交中文任务计划。",
+    "已有计划时，执行 Core 选中的任务，读取它的精确 skill。缺项先补证据，技术失败自动修复。完成后继续可执行任务，不逐步询问用户。",
+    "只有真实业务取舍或未获授权的操作才调用 devflow_plan decision，给出 2–3 个选项，首项为推荐并说明影响。",
+    "已有 running/checking 任务先检查实际产物与执行状态；不得盲目重复外部操作。确认旧执行已结束才 recover。",
+    "不生成无关前端任务、空白方案或每技能一份报告。修改需求主文档；源码、测试、API 契约等必要产物照常维护。",
+    "验证必须用 verify 运行声明的命令；review 必须派发 devflow-code-reviewer 独立只读 task，返回 JSON {summary:string,findings:array}，再用 review_result 提交捕获的原始结果。",
+    "Agent 回合结束不等于任务完成；缺失证据、失败、取消与通过必须保持区别。",
+    JSON.stringify(snapshot),
+    "</devflow-dynamic-workflow>",
+  ].join("\n");
+}

package/templates/omp/AGENTS.md

@@ -4,14 +4,15 @@ This repository uses an OMP-native, project-scoped software delivery runtime.
 
 ## Gate policy
 
-Workflow hard gates have been removed: workflow prerequisites, artifact/index checks, contracts, reviews, acceptance results, recovery checks and CP confirmation are advisory. Preserve failed/blocked results and missing evidence, report risks, and continue executable work. Continuation is never test success or human approval. There is no strict workflow or mandatory CP approval mode. Actual operation errors, unreadable control state and revision conflicts must still be resolved for the affected operation.
+New requirements use dynamic plans: continue dependency-ready work and automatically repair technical findings. Delivery requires current verification and applicable independent review evidence. Preserve failed, stale, waiting and cancelled results; none means passed. Business choices use concise runtime option cards. Actual operation errors, unreadable control state and revision conflicts reject the affected operation. Existing fixed workflows retain their advisory checkpoint policy; do not apply their fixed stage/document requirements to dynamic tasks.
 
 ## Control plane
 
 - Start only through `/devflow start <feature>|<phase>` after checking `/devflow doctor` and reporting its diagnostics; resume with `/devflow resume`.
 - Inspect workflow state with `devflow_state`; do not infer state from chat history.
 - Initialize delivery with `devflow_bootstrap`.
-- Mutate checkpoints and steps only with `devflow_transition`.
+- When the inspector reports `mode: dynamic`, load `workflow-dynamic` and use `devflow_plan` for task proposals, execution results and verification. The requirement document owns intent; Core owns progress and observed results. Do not generate irrelevant UI tasks or per-skill Markdown/meta pairs.
+- For existing fixed workflows, mutate checkpoints and steps only with `devflow_transition`.
 - To abandon an active feature, use the runtime-confirmed `devflow_transition`
   `cancel-feature` operation or `/devflow abandon`; never edit control files.
 - Never directly edit `.devflow/planning/STATE.md`, `.devflow/planning/.next-intent`, `.devflow/planning/workflows/`, or `.devflow/planning/artifacts/index.yaml`.
@@ -39,4 +40,4 @@ An index accelerates discovery; it never overrides source code, executable tests
 - A model assertion is not validation evidence.
 - Record exact commands and results for tests, builds, migrations, and acceptance checks.
 - When context reconciliation is requested, follow `skill://workflow-context-sync`, validate the required level, then acknowledge through `devflow_context_sync`.
-- Soft checkpoints continue with `continued_with_warning`, including in headless mode. When explicit CP confirmation is enabled, wait for it and never synthesize human approval.
+- Legacy soft checkpoints continue with `continued_with_warning`. Dynamic plans continue from actual task results and never treat an Agent turn ending as successful completion. Never synthesize human approval.