@guanlin4924/devflow-pi 0.1.50 → 0.1.52

package/package.json

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

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

@@ -4,6 +4,7 @@ import { appendFile, mkdir, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { Box, Text } from "@oh-my-pi/pi-tui";
 import {
   TASK_SUBAGENT_LIFECYCLE_CHANNEL,
   type SubagentLifecyclePayload,
@@ -27,6 +28,96 @@ type ProjectInitializationRequest = {
   mode: ProjectInitializationMode;
 };
 
+const workflowStepNames: Record<string, string> = {
+  "requirement-triage": "需求梳理",
+  "requirement-wayfinder": "需求路径规划",
+  "domain-modeling": "领域建模",
+  "requirement-feasibility-review": "需求可行性审查",
+  "requirement-baseline": "需求基线确认",
+  "wireframe-proposal": "原型方案",
+  "wireframe-validate": "原型校验",
+  "wireframe-render": "原型预览生成",
+  "wireframe-review": "原型审查",
+  "api-contract": "接口契约",
+  "architecture-feasibility": "架构可行性评估",
+  "ui-spec": "界面规格",
+  "feature-breakdown": "功能拆分",
+  "frontend-tech-spec": "前端技术方案",
+  "backend-tech-spec": "后端技术方案",
+  "api-call-guide": "接口调用说明",
+  "api-supplement": "接口补充设计",
+  "integration-verify": "集成验证",
+  "change-plan": "变更计划",
+  "acceptance-test-design": "验收测试设计",
+  "phase-structure": "阶段结构确认",
+  "execute": "实现执行",
+  "code-index-refresh": "代码索引刷新",
+  "code-review": "代码审查",
+  "generate-mainflow-cases": "主流程用例生成",
+  "run-acceptance-tests": "冻结验收测试执行",
+  "release-closeout": "发布收尾与里程碑归档",
+  "dual-track-design": "前后端并行设计",
+  "acceptance-failed-remediation": "验收失败修复",
+  "diagnose": "验收失败诊断",
+  "execute-fix": "修复执行",
+};
+
+const workflowStatusNames: Record<string, string> = {
+  completed: "已完成",
+  current: "进行中",
+  pending: "未开始",
+  waiting_review: "等待审查",
+  blocked: "已阻塞",
+  failed: "执行失败",
+  cancelled: "已取消",
+  unknown: "未知",
+};
+
+const workflowActionNames: Record<string, string> = {
+  run_next_step: "执行下一步骤",
+  run_parallel_window: "执行并行步骤",
+  route_failure_branch: "进入失败处理分支",
+  await_user_confirmation: "等待人工确认",
+  recover_artifact_registry: "恢复工件登记",
+  workflow_complete: "功能交付已完成",
+  workflow_cancelled: "功能交付已取消",
+  blocked: "处理阻塞项",
+};
+
+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 workflowStepName(id: string | undefined, fallback?: string): string {
+  if (id && workflowStepNames[id]) return workflowStepNames[id];
+  return fallback || id || "未开始";
+}
+
+function workflowStatusName(status: unknown): string {
+  return typeof status === "string" ? workflowStatusNames[status] ?? status : "未知";
+}
+
+function workflowActionName(action: unknown): string {
+  return typeof action === "string" ? workflowActionNames[action] ?? action : "正在确认";
+}
+
+function workflowPhaseName(phase: unknown): string {
+  if (typeof phase !== "string" || !phase) return "未开始";
+  if (phase.startsWith("feature-")) return "功能交付";
+  return phase;
+}
+
 type ActiveExecutionContract = {
   contractId: string;
   feature: string;
@@ -278,7 +369,7 @@ export function isRequirementDraftToolAllowed(toolName: string, input: unknown,
   return normalized === "task" && taskAgents.length > 0 && taskAgents.every(agent => PLANNING_AGENTS.has(agent));
 }
 
-type InternalDevflowControlResource = "contract" | "state" | "mainflow";
+type InternalDevflowControlResource = "contract" | "state" | "mainflow" | "requirement_graph";
 
 /** Resolve an xdev target only when all supplied target aliases agree.
  * A direct/eval caller can otherwise provide `path` for a real file plus an
@@ -303,6 +394,7 @@ export function internalDevflowControlResource(toolName: string, input: unknown)
   if (target === "xd://devflow_contract") return "contract";
   if (target === "xd://devflow_state") return "state";
   if (target === "xd://devflow_mainflow") return "mainflow";
+  if (target === "xd://devflow_requirement_graph") return "requirement_graph";
   return undefined;
 }
 
@@ -897,20 +989,21 @@ function projectInitializationDirective(summary: string): string {
 }
 
 function explainWorkflowSnapshot(snapshot: Record<string, unknown> | null): string {
-  if (!snapshot) return "Devflow 当前没有可解释的工作流状态。可使用 /devflow start <feature> 创建新 Feature。";
+  if (!snapshot) return "Devflow 当前没有可解释的工作流状态。可使用 /devflow start <功能名> 创建新功能。";
   const step = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
   const lines = [
-    `Feature：${String(snapshot.current_feature ?? "未开始")}`,
-    `状态：${String(snapshot.status ?? "unknown")}`,
-    `动作：${String(snapshot.action ?? "unknown")}`,
-    `Revision：${String(snapshot.revision ?? "unknown")}`,
+    `功能：${String(snapshot.current_feature ?? "未开始")}`,
+    `阶段：${workflowPhaseName(snapshot.current_phase)}`,
+    `状态：${workflowStatusName(snapshot.status)}`,
+    `动作：${workflowActionName(snapshot.action)}`,
+    `版本：${String(snapshot.revision ?? "未知")}`,
   ];
-  if (step?.id) lines.push(`当前/下一步骤：${String(step.id)}${step.label ? `（${String(step.label)}）` : ""}`);
-  if (snapshot.checkpoint) lines.push(`Checkpoint：${String(snapshot.checkpoint)}`);
+  if (step?.id) lines.push(`当前/下一节点：${workflowStepName(step.id, step.label)}`);
+  if (snapshot.checkpoint) lines.push(`检查点：${String(snapshot.checkpoint)}`);
   if (snapshot.action === "workflow_complete") {
-    lines.push("结论：上一 Feature 已完成；可以使用 /devflow start <新功能名> 创建下一 Feature。");
+    lines.push("结论：上一功能已完成；可以使用 /devflow start <功能名> 创建下一功能。");
   } else {
-    lines.push("结论：这是只读解释；未执行任何状态迁移或文件写入。");
+    lines.push("结论：这是只读说明；未执行任何状态迁移或文件写入。");
   }
   return lines.join("\n");
 }
@@ -1129,33 +1222,13 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   type ProjectControlUi = {
     setStatus(key: string, text: string | undefined): void;
-    setWidget?(key: string, content: string[] | undefined, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
+    // OMP widgets accept either plain lines or a component factory. Keep this
+    // interface structural because command contexts are supplied by OMP.
+    setWidget?(key: string, content: unknown, 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) {
@@ -1166,11 +1239,11 @@ export default function devflowCore(pi: ExtensionAPI) {
       case "await_user_confirmation":
         return "审查产物后批准推进";
       case "recover_artifact_registry":
-        return "可执行安全恢复（仅 registry）";
+        return "可执行安全恢复（仅工件登记）";
       case "workflow_complete":
-        return "当前 Feature 已完成";
+        return "当前功能已完成";
       case "workflow_cancelled":
-        return "当前 Feature 已取消";
+        return "当前功能已取消";
       case "blocked":
         return "先处理阻塞证据";
       default:
@@ -1184,59 +1257,78 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (state.phase === "blocked") return `已阻塞：${state.label}`;
     if (snapshot.action === "await_user_confirmation") return "等待人工审查";
     if (snapshot.action === "blocked") return "已阻塞";
-    return "当前会话未运行 Agent";
+    return "当前会话未运行智能体";
   }
 
   function projectControlPanel(snapshot: Record<string, unknown> | null, state: SessionControlState): string[] {
     if (!snapshot) {
-      return ["Devflow 当前 Feature 交付链路", "尚未读取到有效控制面状态。"];
+      return ["Devflow 当前功能交付", "── 项目状态 ──", "尚未读取到有效控制面状态。"];
     }
     const steps = workflowSteps(snapshot);
     const completedCount = steps.filter(step => step.status === "completed").length;
-    const current = compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
+    const selectedStep = compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
+    const currentStep = selectedStep
+      ? workflowStepName(selectedStep.id, selectedStep.label)
+      : "未开始";
+    const nextStep = steps.find(step => step.status !== "completed" && step.id !== selectedStep?.id)
+      ?? steps.find(step => step.status !== "completed");
     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}`,
+      `Devflow 当前功能交付 · ${String(snapshot.current_feature ?? "未开始")}`,
+      `阶段：${workflowPhaseName(snapshot.current_phase)}    版本：${String(snapshot.revision ?? "未知")}`,
+      "── 交付链路 ──",
+      `进度：已完成 ${completedCount} / 当前已知 ${steps.length} 步    工作流：${workflowStatusName(snapshot.status)}`,
+      `当前：${currentStep}${nextStep ? `    后续：${workflowStepName(nextStep.id, nextStep.label)}` : ""}`,
+      "── 当前节点 ──",
+      `节点状态：${workflowStatusName(selectedStep?.status)}    执行状态：${projectExecutionLabel(state, snapshot)}`,
+      `节点动作：${workflowActionName(snapshot.action)}`,
+      "── 下一步执行 ──",
+      `可执行操作：${projectActionLabel(snapshot)}`,
+      "── 恢复与重置 ──",
+      `处理建议：${recoveryLabel}`,
     ];
   }
 
+  function projectControlWidget(lines: string[]) {
+    return (_tui: unknown, theme: { fg(color: "accent" | "muted" | "dim", text: string): string; bold(text: string): string }) => {
+      const panel = new Box(1, 0, undefined, {
+        chars: { topLeft: "╭", topRight: "╮", bottomLeft: "╰", bottomRight: "╯", horizontal: "─", vertical: "│" },
+        color: text => theme.fg("dim", text),
+      });
+      const content = lines.map((line, index) => {
+        if (index === 0) return theme.bold(theme.fg("accent", line));
+        if (line.startsWith("──")) return theme.fg("accent", line);
+        return theme.fg("muted", line);
+      }).join("\n");
+      panel.addChild(new Text(content, 0, 0));
+      return panel;
+    };
+  }
+
   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" });
+        : ["Devflow 当前功能交付", "── 项目状态 ──", "状态读取失败；未执行任何恢复或状态迁移。"];
+      ctx.ui.setWidget?.("devflow-project-control", projectControlWidget(content), { placement: "aboveEditor" });
     }).catch(() => {
       if (request !== projectControlRefreshRevision) return;
-      ctx.ui.setWidget?.("devflow-project-control", ["Devflow 当前 Feature 交付链路", "状态读取失败；未执行任何恢复或状态迁移。"], { placement: "aboveEditor" });
+      ctx.ui.setWidget?.("devflow-project-control", projectControlWidget(["Devflow 当前功能交付", "── 项目状态 ──", "状态读取失败；未执行任何恢复或状态迁移。"]), { 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;
-    };
+    ui: ProjectControlUi;
   }, state: SessionControlState) {
     controlState = state;
     ctx.ui.setStatus("devflow-control", statusText(state));
@@ -1690,8 +1782,9 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (!controlPlaneSucceeded(synced)) {
       throw new Error(synced.stderr || synced.stdout || "artifact registry sync after rollover prepare failed");
     }
-    await enqueueControlledRolloverRequest(ctx.cwd, rolloverId, ctx.sessionManager.getSessionId());
+    // The runtime can observe the request immediately; arm the switch handler first.
     pendingRollover = { snapshot, preparedRevision: payload.revision, rolloverId };
+    await enqueueControlledRolloverRequest(ctx.cwd, rolloverId, ctx.sessionManager.getSessionId());
   }
 
   function parallelBranches(snapshot: Record<string, unknown>): Array<{ workflow_step: string; track: string }> {
@@ -1914,27 +2007,27 @@ export default function devflowCore(pi: ExtensionAPI) {
     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");
+      ctx.ui.notify("当前没有可取消的进行中功能。", "error");
       return;
     }
-    const reason = await ctx.ui.input("取消当前 Feature", "请输入取消原因");
+    const reason = await ctx.ui.input("取消当前功能", "请输入取消原因");
     if (!reason?.trim()) return;
     const confirmed = await ctx.ui.confirm(
-      "确认取消当前 Feature",
-      `Feature：${feature}\n原因：${reason.trim()}\n\n将结束当前 Feature、释放项目占用并保留现有工件；未完成步骤不会被标记为完成。继续吗？`,
+      "确认取消当前功能",
+      `功能：${feature}\n原因：${reason.trim()}\n\n将结束当前功能、释放项目占用并保留现有工件；未完成步骤不会被标记为完成。继续吗？`,
     );
     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");
+      ctx.ui.notify(`取消当前功能失败：${result.stderr || result.stdout}`, "error");
       return;
     }
     activeContract = undefined;
     contractAgentCalls = 0;
     setControlState(ctx, initialControlState());
-    ctx.ui.notify(`Feature“${feature}”已取消；现有工件已保留。`, "info");
+    ctx.ui.notify(`功能“${feature}”已取消；现有工件已保留。`, "info");
   }
 
   async function openProjectControlPanel(ctx: ProjectControlCommandContext): Promise<void> {
@@ -1951,10 +2044,10 @@ export default function devflowCore(pi: ExtensionAPI) {
       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…");
+      if (typeof snapshot.current_feature === "string" && !["completed", "cancelled", "failed"].includes(String(snapshot.status))) options.push("取消当前功能…");
       options.push("关闭");
 
-      const selected = await ctx.ui.select(projectControlPanel(snapshot, controlState).join("\n"), options);
+      const selected = await ctx.ui.select("项目控制操作", options);
       if (!selected || selected === "关闭") return;
       if (selected === "刷新状态") continue;
       if (selected === "查看状态说明") {
@@ -1978,7 +2071,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         await executeSafeRecoveryFromPanel(ctx);
         return;
       }
-      if (selected === "取消当前 Feature…") {
+      if (selected === "取消当前功能…") {
         await cancelFeatureFromPanel(ctx);
         return;
       }
@@ -2759,7 +2852,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         propagation: z.enum(["one_hop", "full"]).optional(),
       }).optional(),
     }),
-    approval: (args) => args.action === "propose" || args.action === "confirm" ? "write" : "read",
+    approval: (args) => args.action === "propose" || args.action === "confirm" || (args.action === "context" && args.write === true) ? "write" : "read",
     async execute(_id, params, _signal, _onUpdate, ctx) {
       const graphWrite = params.action === "propose" || params.action === "confirm" || (params.action === "context" && params.write === true);
       if (graphWrite) {

package/src/constants.ts

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

package/src/runtime.ts

@@ -209,7 +209,7 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
   // authority remains STATE.rollover, which the extension verifies and claims
   // during session_switch before it starts the next workflow turn.
   const consumeControlledRollover = async (): Promise<void> => {
-    if (rolloverConsumptionInFlight) return;
+    if (rolloverConsumptionInFlight || interactiveSubmissionInFlight || runtime.session.isStreaming) return;
     rolloverConsumptionInFlight = true;
     try {
     const requestPath = path.join(project.root, ".planning", "rollover-request.json");
@@ -238,6 +238,8 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
     // already durable and STATE remains frozen until the target consumes it.
     let switched = false;
     for (let attempt = 0; attempt < 3 && !switched; attempt += 1) {
+      // newSession aborts a running turn; leave the durable request for the poller.
+      if (interactiveSubmissionInFlight || runtime.session.isStreaming) return;
       switched = await runtime.session.newSession();
       if (!switched && attempt < 2) await new Promise(resolve => setTimeout(resolve, 100));
     }
@@ -259,8 +261,11 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
       rolloverConsumptionInFlight = false;
       mode.showWarning(`Devflow 会话轮换运行时异常，将自动重试：${String(error)}`);
       scheduleControlledRolloverRetry();
+    } finally {
+      rolloverConsumptionInFlight = false;
     }
   };
+  let interactiveSubmissionInFlight = false;
   let rolloverConsumptionInFlight = false;
   let rolloverRetryTimer: ReturnType<typeof setTimeout> | undefined;
   let rolloverRetryAttempt = 0;
@@ -287,7 +292,12 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
   await consumeControlledRollover();
   while (true) {
     const input = await mode.getUserInput();
-    await omp.submitInteractiveInput(mode, runtime.session, input);
+    interactiveSubmissionInFlight = true;
+    try {
+      await omp.submitInteractiveInput(mode, runtime.session, input);
+    } finally {
+      interactiveSubmissionInFlight = false;
+    }
     await consumeControlledRollover();
     // The submitted turn may create a durable rollover request after the
     // immediate check above returns. Poll once while the UI is waiting for the