@guanlin4924/devflow-pi 0.1.48 → 0.1.50

package/README.md

@@ -117,7 +117,7 @@ bash .skills/install.sh --apply --force-config
 
 ### 窗口操作指引与干净会话
 
-Devflow 会在输入框上方显示与当前状态对应的“Devflow 操作指引”：空闲时给出初始化、创建功能和状态查看入口；需求梳理时提示直接补充需求；节点审查时提示回复“批准执行”或直接描述修改项；阻塞时只展示解释状态和安全恢复入口。
+Devflow 会在输入框上方显示“当前 Feature 交付链路”：它基于只读状态快照展示已知步骤、当前节点、完成数、工作流/执行状态、当前允许的操作，以及安全恢复方案。使用 `/devflow control` 打开交互式控制台：它只会在状态检查器允许时提供启动当前步骤、审查并批准推进、安全恢复或取消当前 Feature；每个有写入影响的操作都会重新读取状态并沿用已有确认流程。面板不提供重试或重置当前节点，避免破坏 revision、checkpoint 和证据链。
 
 正式节点经用户批准后，Devflow 会把已校验的状态和产物引用固化为内容校验的 handoff，再自动创建干净 Session 执行下一节点。交接期间工作流冻结；只有新 Session 成功认领并消费同一份 handoff 后才解除冻结。Devflow 不使用 OMP 的模型摘要 handoff，因此 `.planning/STATE.md` 仍是唯一流程事实源。
 

package/package.json

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

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

@@ -974,7 +974,10 @@ export function isShellControlMutation(toolName: string, input: unknown): boolea
       command,
     );
   const namesControlPath = [...CONTROL_PATHS, ...CONTROL_PREFIXES].some(item => command.includes(item)) || /\.planning\/requirements\//.test(command);
-  const looksLikeWrite = /(?:^|[;&|]\s*)(?:rm|mv|cp|install|truncate)\b|(?:^|\s)(?:tee|sed\s+-i|perl\s+-i)\b|(?:^|[\s;&|])(?:\d*)>{1,2}(?![>=])\s*\S/.test(
+  // `2>` and `2>>` only redirect stderr. They frequently accompany read-only
+  // probes of control-plane files and must not be treated as a file mutation.
+  // Keep bare `>`/`>>` and explicit stdout `1>`/`1>>` guarded.
+  const looksLikeWrite = /(?:^|[;&|]\s*)(?:rm|mv|cp|install|truncate)\b|(?:^|\s)(?:tee|sed\s+-i|perl\s+-i)\b|(?:^|[\s;&|])(?:1)?>{1,2}(?![>=&])\s*\S/.test(
     command,
   );
   return invokesWriter || (namesControlPath && looksLikeWrite);
@@ -1124,27 +1127,112 @@ export default function devflowCore(pi: ExtensionAPI) {
     })}\n`, "utf8");
   }
 
-  function controlGuide(state: SessionControlState): string[] {
-    const title = "Devflow 操作指引";
-    if (state.intent === "project-init" && state.phase === "planning") {
-      return [title, "初始化范围待确认：按界面完成选择；批准写入请回复“批准执行”。"];
-    }
-    if (state.intent === "requirement-draft" && state.phase === "planning") {
-      return [title, "需求梳理：直接补充需求正文、目标、边界和验收结果；此时不会推进实现。"];
-    }
-    if (state.phase === "waiting-user" || state.phase === "awaiting-approval") {
-      return [title, "当前节点等待审查：批准请回复“批准执行”；需修改请直接描述修改项。", "状态说明：/devflow explain-state"];
-    }
-    if (state.phase === "executing") {
-      return [title, `正在处理：${state.label}`, "请等待当前步骤输出；完成后会提示你审查。"];
+  type ProjectControlUi = {
+    setStatus(key: string, text: string | undefined): void;
+    setWidget?(key: string, content: string[] | undefined, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
+  };
+
+  let projectControlRefreshRevision = 0;
+
+  function workflowSteps(snapshot: Record<string, unknown>): Array<{ id: string; label: string; status: string }> {
+    if (!Array.isArray(snapshot.workflow_steps)) return [];
+    return snapshot.workflow_steps.flatMap(step => {
+      if (!step || typeof step !== "object") return [];
+      const record = step as Record<string, unknown>;
+      const id = typeof record.id === "string" ? record.id : "";
+      if (!id) return [];
+      return [{
+        id,
+        label: typeof record.label === "string" && record.label ? record.label : id,
+        status: typeof record.status === "string" ? record.status : "unknown",
+      }];
+    });
+  }
+
+  function workflowStepIcon(status: string): string {
+    if (status === "completed") return "✓";
+    if (status === "current") return "●";
+    if (status === "waiting_review") return "◆";
+    if (status === "blocked") return "!";
+    return "○";
+  }
+
+  function projectActionLabel(snapshot: Record<string, unknown>): string {
+    switch (snapshot.action) {
+      case "run_next_step":
+      case "run_parallel_window":
+      case "route_failure_branch":
+        return "可启动当前步骤";
+      case "await_user_confirmation":
+        return "审查产物后批准推进";
+      case "recover_artifact_registry":
+        return "可执行安全恢复（仅 registry）";
+      case "workflow_complete":
+        return "当前 Feature 已完成";
+      case "workflow_cancelled":
+        return "当前 Feature 已取消";
+      case "blocked":
+        return "先处理阻塞证据";
+      default:
+        return "正在重新确定可执行操作";
     }
-    if (state.phase === "blocked") {
-      return [title, "当前步骤被阻塞：使用 /devflow explain-state 查看证据与可恢复路径。", "仅在系统给出安全恢复计划后使用 /devflow recover。"];
+  }
+
+  function projectExecutionLabel(state: SessionControlState, snapshot: Record<string, unknown>): string {
+    if (state.phase === "executing") return `执行中：${state.label}`;
+    if (state.phase === "waiting-user" || state.phase === "awaiting-approval") return "等待人工审查";
+    if (state.phase === "blocked") return `已阻塞：${state.label}`;
+    if (snapshot.action === "await_user_confirmation") return "等待人工审查";
+    if (snapshot.action === "blocked") return "已阻塞";
+    return "当前会话未运行 Agent";
+  }
+
+  function projectControlPanel(snapshot: Record<string, unknown> | null, state: SessionControlState): string[] {
+    if (!snapshot) {
+      return ["Devflow 当前 Feature 交付链路", "尚未读取到有效控制面状态。"];
     }
-    return [title, "初始化项目：/devflow project-init", "创建功能：/devflow start <功能名>    查看状态：/devflow explain-state"];
+    const steps = workflowSteps(snapshot);
+    const completedCount = steps.filter(step => step.status === "completed").length;
+    const current = compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
+    const recovery = snapshot.recovery_plan && typeof snapshot.recovery_plan === "object"
+      ? snapshot.recovery_plan as Record<string, unknown>
+      : undefined;
+    const recoveryLabel = recovery?.classification === "safe_repairable"
+      ? "已提供安全恢复方案（不推进步骤）"
+      : snapshot.action === "blocked"
+        ? "没有可自动执行的重置方案；请先查看阻塞证据。"
+        : "当前无需恢复或重置。";
+    const chain = steps.length > 0
+      ? steps.map(step => `${workflowStepIcon(step.status)} ${step.label}`).join(" → ")
+      : "尚无可展示的已知工作流步骤。";
+    return [
+      `Devflow 当前 Feature 交付链路 · ${String(snapshot.current_feature ?? "未开始")}`,
+      `阶段：${String(snapshot.current_phase ?? "unknown")}    Revision：${String(snapshot.revision ?? "unknown")}`,
+      `链路：${chain}`,
+      `进度：已完成 ${completedCount} / 当前已知 ${steps.length} 步`,
+      `当前节点：${current?.label ? String(current.label) : String(current?.id ?? "未开始")}`,
+      `工作流状态：${String(snapshot.status ?? "unknown")}    执行状态：${projectExecutionLabel(state, snapshot)}`,
+      `当前可执行操作：${projectActionLabel(snapshot)}`,
+      `恢复与重置：${recoveryLabel}`,
+    ];
+  }
+
+  function refreshProjectControlPanel(ctx: { cwd: string; ui: ProjectControlUi }): void {
+    const request = ++projectControlRefreshRevision;
+    void inspectWorkflow(ctx.cwd).then(({ result, snapshot }) => {
+      if (request !== projectControlRefreshRevision) return;
+      const content = result.ok
+        ? projectControlPanel(snapshot, controlState)
+        : ["Devflow 当前 Feature 交付链路", "状态读取失败；未执行任何恢复或状态迁移。"];
+      ctx.ui.setWidget?.("devflow-project-control", content, { placement: "aboveEditor" });
+    }).catch(() => {
+      if (request !== projectControlRefreshRevision) return;
+      ctx.ui.setWidget?.("devflow-project-control", ["Devflow 当前 Feature 交付链路", "状态读取失败；未执行任何恢复或状态迁移。"], { placement: "aboveEditor" });
+    });
   }
 
   function setControlState(ctx: {
+    cwd: string;
     ui: {
       setStatus(key: string, text: string | undefined): void;
       setWidget?(key: string, content: string[] | undefined, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
@@ -1152,7 +1240,7 @@ export default function devflowCore(pi: ExtensionAPI) {
   }, state: SessionControlState) {
     controlState = state;
     ctx.ui.setStatus("devflow-control", statusText(state));
-    ctx.ui.setWidget?.("devflow-operation-guide", controlGuide(state), { placement: "aboveEditor" });
+    refreshProjectControlPanel(ctx);
   }
 
   function normalizeContractSegment(value: string, label: string): string {
@@ -1776,6 +1864,127 @@ export default function devflowCore(pi: ExtensionAPI) {
     return true;
   }
 
+  type ProjectControlCommandContext = {
+    cwd: string;
+    sessionManager: { getSessionId(): string };
+    ui: ProjectControlUi & {
+      select(title: string, options: string[]): Promise<string | undefined>;
+      confirm(title: string, body: string): Promise<boolean>;
+      input(title: string, placeholder?: string): Promise<string | undefined>;
+      notify(message: string, level: "info" | "error"): void;
+    };
+  };
+
+  function hasSafeRecoveryPlan(snapshot: Record<string, unknown>): boolean {
+    const plan = snapshot.recovery_plan;
+    return Boolean(plan && typeof plan === "object" && (plan as Record<string, unknown>).classification === "safe_repairable");
+  }
+
+  async function executeSafeRecoveryFromPanel(ctx: ProjectControlCommandContext): Promise<void> {
+    // Do not use inspectWorkflowWithRegistryRecovery here. A view action must
+    // never silently repair the control plane before the user sees and accepts
+    // the currently inspected recovery plan.
+    const inspected = await inspectWorkflow(ctx.cwd);
+    const plan = inspected.snapshot?.recovery_plan as Record<string, unknown> | undefined;
+    const revision = plan?.expected_revision;
+    if (!inspected.result.ok || !inspected.snapshot || !hasSafeRecoveryPlan(inspected.snapshot) || typeof revision !== "number") {
+      ctx.ui.notify("当前没有可执行的安全恢复方案。", "error");
+      return;
+    }
+    const confirmed = await ctx.ui.confirm(
+      "确认执行安全恢复",
+      "将只同步已存在文件对应的 artifact registry；不会推进步骤、确认 checkpoint、重试或重置当前节点。继续吗？",
+    );
+    if (!confirmed) return;
+    const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/repair_control_plane.rb", [
+      "--write", "--confirm", "--expected-revision", String(revision), "--json",
+    ]);
+    if (!controlPlaneSucceeded(result)) {
+      ctx.ui.notify(`安全恢复失败：${result.stderr || result.stdout}`, "error");
+      return;
+    }
+    setControlState(ctx, initialControlState());
+    ctx.ui.notify("控制面 registry 已安全恢复；工作流未推进。", "info");
+  }
+
+  async function cancelFeatureFromPanel(ctx: ProjectControlCommandContext): Promise<void> {
+    const inspected = await inspectWorkflow(ctx.cwd);
+    const snapshot = inspected.snapshot;
+    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;
+    if (!inspected.result.ok || revision === undefined || !feature || !status || ["completed", "cancelled", "failed"].includes(status)) {
+      ctx.ui.notify("当前没有可取消的进行中 Feature。", "error");
+      return;
+    }
+    const reason = await ctx.ui.input("取消当前 Feature", "请输入取消原因");
+    if (!reason?.trim()) return;
+    const confirmed = await ctx.ui.confirm(
+      "确认取消当前 Feature",
+      `Feature：${feature}\n原因：${reason.trim()}\n\n将结束当前 Feature、释放项目占用并保留现有工件；未完成步骤不会被标记为完成。继续吗？`,
+    );
+    if (!confirmed) return;
+    const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
+      "--write", "--json", "--cancel", "--cancel-reason", reason.trim(), "--expected-revision", String(revision),
+    ]);
+    if (!controlPlaneSucceeded(result)) {
+      ctx.ui.notify(`取消当前 Feature 失败：${result.stderr || result.stdout}`, "error");
+      return;
+    }
+    activeContract = undefined;
+    contractAgentCalls = 0;
+    setControlState(ctx, initialControlState());
+    ctx.ui.notify(`Feature“${feature}”已取消；现有工件已保留。`, "info");
+  }
+
+  async function openProjectControlPanel(ctx: ProjectControlCommandContext): Promise<void> {
+    for (;;) {
+      // The control panel is a read-only projection. Each action below reads a
+      // fresh snapshot again before it can mutate anything.
+      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;
+      }
+      const snapshot = inspected.snapshot;
+      const options = ["刷新状态", "查看状态说明"];
+      if (["run_next_step", "run_parallel_window", "route_failure_branch"].includes(String(snapshot.action))) options.push("启动当前可执行步骤");
+      if (snapshot.action === "await_user_confirmation") options.push("审查并批准推进…");
+      if (hasSafeRecoveryPlan(snapshot)) options.push("执行安全恢复…");
+      if (typeof snapshot.current_feature === "string" && !["completed", "cancelled", "failed"].includes(String(snapshot.status))) options.push("取消当前 Feature…");
+      options.push("关闭");
+
+      const selected = await ctx.ui.select(projectControlPanel(snapshot, controlState).join("\n"), options);
+      if (!selected || selected === "关闭") return;
+      if (selected === "刷新状态") continue;
+      if (selected === "查看状态说明") {
+        ctx.ui.notify(explainWorkflowSnapshot(snapshot), "info");
+        return;
+      }
+      if (selected === "启动当前可执行步骤") {
+        const fresh = await inspectWorkflow(ctx.cwd);
+        if (!fresh.result.ok || !fresh.snapshot) {
+          ctx.ui.notify(`启动前状态读取失败：${fresh.result.stderr || fresh.result.stdout}`, "error");
+          return;
+        }
+        await resumeInspectedWorkflow(ctx, fresh.snapshot);
+        return;
+      }
+      if (selected === "审查并批准推进…") {
+        await confirmAndAdvanceWorkflowStep(ctx);
+        return;
+      }
+      if (selected === "执行安全恢复…") {
+        await executeSafeRecoveryFromPanel(ctx);
+        return;
+      }
+      if (selected === "取消当前 Feature…") {
+        await cancelFeatureFromPanel(ctx);
+        return;
+      }
+    }
+  }
+
   async function reconcileParallelLifecycle(event: Partial<SubagentLifecyclePayload>, context: { branch_id: string; attempt: number; branch_revision: number } | undefined): Promise<void> {
     if (!context || !projectRoot || !event.status || event.status === "started") return;
     const workflowInspection = await inspectWorkflow(projectRoot);
@@ -3409,6 +3618,10 @@ export default function devflowCore(pi: ExtensionAPI) {
         ctx.ui.notify((result.stdout || result.stderr).slice(0, 6000), result.ok ? "info" : "error");
         return;
       }
+      if (trimmed === "control") {
+        await openProjectControlPanel(ctx);
+        return;
+      }
       if (trimmed === "explain-state") {
         const inspected = await inspectWorkflowWithRegistryRecovery(ctx.cwd);
         ctx.ui.notify(
@@ -3660,7 +3873,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       ctx.ui.notify(
-        "Usage: /devflow doctor | status | explain-state | recover | abandon [reason] | project-init | start <feature>|<phase> | resume",
+        "Usage: /devflow doctor | status | control | explain-state | recover | abandon [reason] | project-init | start <feature>|<phase> | resume",
         "warning",
       );
     },

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

@@ -126,6 +126,39 @@ def step_payload(step, state, root, artifact_by_path)
   }
 end
 
+# This is a read model for the TUI, not a second workflow state.  In
+# particular, the current step may be waiting for human review or blocked,
+# while it remains in pending_steps in STATE.md.  The inspector action is the
+# authority for that distinction.
+def workflow_steps_payload(steps, state, result)
+  completed_ids = Array(state["completed_steps"])
+  pending_ids = Array(state["pending_steps"])
+  current_id = state["current_step"]
+  action = result[:action] || result["action"]
+
+  Array(steps).map do |step|
+    id = step["id"]
+    status = if completed_ids.include?(id)
+               "completed"
+             elsif id == current_id && action == "await_user_confirmation"
+               "waiting_review"
+             elsif id == current_id && action == "blocked"
+               "blocked"
+             elsif id == current_id
+               "current"
+             elsif pending_ids.include?(id)
+               "pending"
+             else
+               "unknown"
+             end
+    {
+      "id" => id,
+      "label" => step["label"] || id,
+      "status" => status
+    }
+  end
+end
+
 def dependencies_satisfied?(step, completed_ids)
   Array(step["depends_on"]).all? { |dependency| completed_ids.include?(dependency) }
 end
@@ -617,6 +650,9 @@ if defined?(state) && state.is_a?(Hash) && result.is_a?(Hash)
     source_flow: state["source_flow"],
     source_workflow_config: state["source_workflow_config"]
   )
+  # Include the declared, currently known workflow chain so a presentation
+  # layer never has to infer it from filenames or raw control-plane files.
+  result["workflow_steps"] = workflow_steps_payload(steps, state, result) if defined?(steps) && steps.is_a?(Array)
 end
 
 if options[:json]

package/src/constants.ts

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