@guanlin4924/devflow-pi 0.1.49 → 0.1.51

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.49",
+  "version": "0.1.51",
   "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;
@@ -897,20 +988,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");
 }
@@ -1127,35 +1219,119 @@ 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}`, "请等待当前步骤输出；完成后会提示你审查。"];
-    }
-    if (state.phase === "blocked") {
-      return [title, "当前步骤被阻塞：使用 /devflow explain-state 查看证据与可恢复路径。", "仅在系统给出安全恢复计划后使用 /devflow recover。"];
+  type ProjectControlUi = {
+    setStatus(key: string, text: string | undefined): 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 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 "可执行安全恢复（仅工件登记）";
+      case "workflow_complete":
+        return "当前功能已完成";
+      case "workflow_cancelled":
+        return "当前功能已取消";
+      case "blocked":
+        return "先处理阻塞证据";
+      default:
+        return "正在重新确定可执行操作";
     }
-    return [title, "初始化项目：/devflow project-init", "创建功能：/devflow start <功能名>    查看状态：/devflow explain-state"];
   }
 
-  function setControlState(ctx: {
-    ui: {
-      setStatus(key: string, text: string | undefined): void;
-      setWidget?(key: string, content: string[] | undefined, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
+  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 "当前会话未运行智能体";
+  }
+
+  function projectControlPanel(snapshot: Record<string, unknown> | null, state: SessionControlState): string[] {
+    if (!snapshot) {
+      return ["Devflow 当前功能交付", "── 项目状态 ──", "尚未读取到有效控制面状态。"];
+    }
+    const steps = workflowSteps(snapshot);
+    const completedCount = steps.filter(step => step.status === "completed").length;
+    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"
+        ? "暂无自动重置方案，请先查看阻塞证据"
+        : "当前无需恢复或重置";
+    return [
+      `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 当前功能交付", "── 项目状态 ──", "状态读取失败；未执行任何恢复或状态迁移。"];
+      ctx.ui.setWidget?.("devflow-project-control", projectControlWidget(content), { placement: "aboveEditor" });
+    }).catch(() => {
+      if (request !== projectControlRefreshRevision) return;
+      ctx.ui.setWidget?.("devflow-project-control", projectControlWidget(["Devflow 当前功能交付", "── 项目状态 ──", "状态读取失败；未执行任何恢复或状态迁移。"]), { placement: "aboveEditor" });
+    });
+  }
+
+  function setControlState(ctx: {
+    cwd: string;
+    ui: ProjectControlUi;
   }, 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 {
@@ -1779,6 +1955,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("当前没有可取消的进行中功能。", "error");
+      return;
+    }
+    const reason = await ctx.ui.input("取消当前功能", "请输入取消原因");
+    if (!reason?.trim()) return;
+    const confirmed = await ctx.ui.confirm(
+      "确认取消当前功能",
+      `功能：${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(`取消当前功能失败：${result.stderr || result.stdout}`, "error");
+      return;
+    }
+    activeContract = undefined;
+    contractAgentCalls = 0;
+    setControlState(ctx, initialControlState());
+    ctx.ui.notify(`功能“${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("取消当前功能…");
+      options.push("关闭");
+
+      const selected = await ctx.ui.select("项目控制操作", 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 === "取消当前功能…") {
+        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);
@@ -3412,6 +3709,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(
@@ -3663,7 +3964,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.49";
+export const PRODUCT_VERSION = "0.1.51";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";