@guanlin4924/devflow-pi 0.1.11 → 0.1.13

package/README.md

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

package/package.json

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

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

@@ -41,6 +41,8 @@ const READ_ONLY_TOOLS = new Set([
   "usage_stats",
 ]);
 
+const REQUIREMENT_DRAFT_TOOLS = new Set([...READ_ONLY_TOOLS, "ask"]);
+
 const PLANNING_AGENTS = new Set(["project-scout", "requirements-auditor", "contract-auditor"]);
 
 const STATE_MUTATION_TOOLS = new Set([
@@ -96,6 +98,30 @@ export function isPlanningToolAllowed(toolName: string, taskAgents: string[] = [
   return taskAgents.length > 0 && taskAgents.every(agent => PLANNING_AGENTS.has(agent));
 }
 
+/** Requirement drafting may inspect with a shell, but never mutate a project. */
+export function isReadOnlyShellCommand(command: string): boolean {
+  return command.trim() !== "" && !shellMutationPaths(command, ".").mutating;
+}
+
+export function isRequirementDraftToolAllowed(toolName: string, input: unknown, taskAgents: string[] = []): boolean {
+  const normalized = toolName.toLowerCase();
+  if (["bash", "shell", "exec_command"].includes(normalized)) {
+    const record = input && typeof input === "object" ? input as Record<string, unknown> : {};
+    return isReadOnlyShellCommand(String(record.command ?? record.cmd ?? ""));
+  }
+  if (REQUIREMENT_DRAFT_TOOLS.has(normalized)) return true;
+  return normalized === "task" && taskAgents.length > 0 && taskAgents.every(agent => PLANNING_AGENTS.has(agent));
+}
+
+export type NaturalControlAction = "approve" | "reject";
+
+export function classifyNaturalControlAction(input: string): NaturalControlAction | null {
+  const text = input.trim();
+  if (/^(?:批准|确认|同意|通过)(?:执行|继续|推进|当前(?:方案|步骤|计划))?[。！!]?$/.test(text)) return "approve";
+  if (/^(?:拒绝|不同意|暂不|需要修改|退回)(?:执行|继续|推进|当前(?:方案|步骤|计划))?[。！!]?$/.test(text)) return "reject";
+  return null;
+}
+
 export function isStateMutationTool(toolName: string): boolean {
   return STATE_MUTATION_TOOLS.has(toolName.toLowerCase());
 }
@@ -488,7 +514,7 @@ function compactStep(value: unknown): Record<string, unknown> | null {
   };
 }
 
-function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "resume" | "continue"): string {
+function workflowDirective(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string): string {
   const selectedStep = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
   const envelope = {
     source,
@@ -502,13 +528,14 @@ function workflowDirective(snapshot: Record<string, unknown>, source: "start" |
     failure_branch: snapshot.failure_branch,
     reason: snapshot.reason,
     recovery: snapshot.recovery,
+    requirement_draft: requirementDraft,
   };
   return [
     "<devflow-runtime-directive>",
     "Devflow 已通过启动预检。读取 skill://workflow-pipeline，并只执行当前项目的一个工作流步骤。",
     "先调用 devflow_state(action=\"inspect\") 重新确认 revision，再由 workflow-orchestrator 路由当前步骤。",
     "只按 inspector 返回的当前 step 加载所需 Skill；不得调用 devflow_transition、不得推进下一步骤、不得替用户通过人工 checkpoint。",
-    "完成本步骤的真实产物后，报告证据、未决项和验证结果并停止，等待用户执行 /devflow advance。",
+    "完成本步骤的真实产物后，报告证据、未决项和验证结果并停止。请用户审查后明确回复“批准执行”才可推进；回复修改意见或“拒绝执行”则不得推进。",
     "当前步骤信封：",
     JSON.stringify(envelope, null, 2),
     "</devflow-runtime-directive>",
@@ -853,8 +880,11 @@ export default function devflowCore(pi: ExtensionAPI) {
     return { result, snapshot: parseJsonResult(result) };
   }
 
-  async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "resume" | "continue") {
-    await pi.sendUserMessage(workflowDirective(snapshot, source));
+  let activeWorkflowTurn = false;
+
+  async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string) {
+    activeWorkflowTurn = true;
+    await pi.sendUserMessage(workflowDirective(snapshot, source, requirementDraft));
   }
 
   pi.setLabel("Devflow Project Runtime");
@@ -879,8 +909,69 @@ export default function devflowCore(pi: ExtensionAPI) {
     systemPrompt: [...event.systemPrompt, DEVFLOW_CHINESE_LANGUAGE_POLICY],
   }));
 
+  pi.on("agent_end", async (event, ctx) => {
+    if (!activeWorkflowTurn || event.willContinue) return;
+    activeWorkflowTurn = false;
+    if (controlState.phase === "executing") {
+      setControlState(ctx, waitingUserState("等待用户审查步骤产物并明确决定"));
+      ctx.ui.notify("当前步骤已结束。请审查输出：明确回复“批准执行”推进，或回复修改意见/“拒绝执行”保持当前步骤。", "info");
+    }
+  });
+
   pi.on("input", async (event, ctx) => {
     if (event.source !== "interactive") return;
+    const controlAction = classifyNaturalControlAction(event.text);
+    if (controlState.intent === "requirement-draft" && controlState.phase === "planning") {
+      const requirementDraft = event.text.trim();
+      if (!requirementDraft) return { handled: true };
+      const inspected = await inspectWorkflow(ctx.cwd);
+      if (!inspected.result.ok || !inspected.snapshot) {
+        ctx.ui.notify(`需求分诊启动失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
+        return { handled: true };
+      }
+      setControlState(ctx, executingState("执行需求入口分诊"));
+      await triggerWorkflow(inspected.snapshot, "start", requirementDraft);
+      return { handled: true };
+    }
+    if (controlState.phase === "awaiting-approval" || controlState.phase === "waiting-user") {
+      if (controlAction === "reject") {
+        ctx.ui.notify("已保留当前步骤和产物。请直接说明需要修改的内容；未执行任何推进。", "info");
+        return { handled: true };
+      }
+      if (controlAction === "approve") {
+        const inspected = await inspectWorkflow(ctx.cwd);
+        if (!inspected.result.ok || !inspected.snapshot) {
+          ctx.ui.notify(`审批处理失败：${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
+          return { handled: true };
+        }
+        const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
+        const checkpoint = inspected.snapshot.status === "waiting_checkpoint";
+        const step = compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step);
+        const stepId = typeof step?.id === "string" ? step.id : undefined;
+        if (revision === undefined || (!checkpoint && !stepId)) {
+          ctx.ui.notify("当前状态缺少可确认的 revision 或步骤，拒绝推进。", "error");
+          return { handled: true };
+        }
+        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
+          "--write", "--json", "--expected-revision", String(revision),
+          ...(checkpoint ? ["--confirm-checkpoint"] : ["--complete-step", stepId!]),
+        ]);
+        if (!result.ok) {
+          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "推进校验失败" });
+          ctx.ui.notify(`未推进：${result.stderr || result.stdout}`, "error");
+          return { handled: true };
+        }
+        const after = await inspectWorkflow(ctx.cwd);
+        if (!after.result.ok || !after.snapshot || after.snapshot.action === "workflow_complete") {
+          setControlState(ctx, initialControlState());
+          ctx.ui.notify(after.snapshot?.action === "workflow_complete" ? "工作流已完成。" : "已推进，但读取下一步骤失败。", "info");
+          return { handled: true };
+        }
+        setControlState(ctx, executingState("执行已批准的下一工作流步骤"));
+        await triggerWorkflow(after.snapshot, "approval");
+        return { handled: true };
+      }
+    }
     const intent = classifyNaturalLanguageIntent(event.text);
     if (intent === "explain-state") {
       const inspected = await inspectWorkflow(ctx.cwd);
@@ -913,7 +1004,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       return {
         text: [
           "<devflow-planner-directive>",
-          "当前是需求梳理（只读）阶段。只允许澄清、收集证据、派发只读审查代理和输出计划草案。",
+          "当前是需求梳理（只读）阶段。可澄清、收集证据、派发只读审查代理，且可使用不修改文件的 shell 检查。",
           "不得开始工作流、不得写入产物、不得调用实现代理或状态迁移。",
           "把用户目标、约束、未知项、反例和下一步最少问题分开列出；缺少证据时不得猜测。",
           event.text,
@@ -944,7 +1035,10 @@ export default function devflowCore(pi: ExtensionAPI) {
       if (shadows.length > 0) {
         return { block: true, reason: `Devflow task agent shadow detected: ${shadows.join("; ")}` };
       }
-      if (controlState.phase === "planning" && !isPlanningToolAllowed(toolName, requested.names)) {
+      const allowedInDraft = controlState.intent === "requirement-draft"
+        ? isRequirementDraftToolAllowed(toolName, event.input, requested.names)
+        : isPlanningToolAllowed(toolName, requested.names);
+      if (controlState.phase === "planning" && !allowedInDraft) {
         return { block: true, reason: planningToolBlockReason(toolName) };
       }
       if (
@@ -958,7 +1052,9 @@ export default function devflowCore(pi: ExtensionAPI) {
       controlState.phase === "planning" &&
       toolName !== "devflow_contract" &&
       !(toolName === "devflow_evidence" && String((event.input as Record<string, unknown> | undefined)?.action) !== "create") &&
-      !isPlanningToolAllowed(toolName)
+      !(controlState.intent === "requirement-draft"
+        ? isRequirementDraftToolAllowed(toolName, event.input)
+        : isPlanningToolAllowed(toolName))
     ) {
       return { block: true, reason: planningToolBlockReason(toolName) };
     }
@@ -966,7 +1062,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       return {
         block: true,
         reason:
-          "Devflow state transitions are user-command-only. Use /devflow start, /devflow advance, or /devflow checkpoint; an LLM may not advance delivery state directly.",
+          "Devflow 状态迁移只能由运行时在用户明确批准已展示的步骤或 checkpoint 后执行；LLM 不得自行推进。",
       };
     }
     if (toolName.startsWith("devflow_")) return;
@@ -1444,9 +1540,9 @@ export default function devflowCore(pi: ExtensionAPI) {
           const step = compactStep(inspected.snapshot?.next_step) ?? compactStep(inspected.snapshot?.current_step);
           const stepId = typeof step?.id === "string" ? step.id : "当前步骤";
           if (inspected.result.ok && status === "in_progress") {
-            ctx.ui.notify(`控制面状态一致，无需恢复。当前步骤是 ${stepId}；请执行 /devflow continue。`, "info");
+            ctx.ui.notify(`控制面状态一致，无需恢复。当前步骤是 ${stepId}；请审查当前产物后明确回复“批准执行”或提出修改意见。`, "info");
           } else if (inspected.result.ok && status === "waiting_checkpoint") {
-            ctx.ui.notify(`控制面状态一致，无需恢复。当前正在等待 checkpoint；请审查产物后执行 /devflow checkpoint。`, "info");
+            ctx.ui.notify("控制面状态一致，无需恢复。当前正在等待 checkpoint；请审查产物后明确回复“批准执行”或提出修改意见。", "info");
           } else {
             ctx.ui.notify("当前状态没有可安全自动执行的恢复计划；请运行 /devflow explain-state，并按其中的阻塞证据处理。", "error");
           }
@@ -1471,7 +1567,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           ctx.ui.notify(`控制面恢复失败：${result.stderr || result.stdout}`, "error");
           return;
         }
-        ctx.ui.notify("控制面 registry 已修复；未推进工作流。请审查当前步骤产物后使用 /devflow advance。", "info");
+        ctx.ui.notify("控制面 registry 已修复；未推进工作流。请审查当前步骤产物后明确回复“批准执行”或提出修改意见。", "info");
         return;
       }
       if (trimmed === "project-init") {
@@ -1515,132 +1611,11 @@ export default function devflowCore(pi: ExtensionAPI) {
         }
         setControlState(ctx, waitingUserState("等待用户审查步骤产物"));
         ctx.ui.notify(
-          `Devflow 已恢复到 ${String((compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step))?.id ?? "当前步骤")}；未自动执行。请先查看状态或使用 /devflow continue 执行一个步骤。`,
+          `Devflow 已恢复到 ${String((compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step))?.id ?? "当前步骤")}；请审查当前产物后明确回复“批准执行”，或直接提出修改意见。`,
           "info",
         );
         return;
       }
-      if (trimmed === "continue") {
-        const report = await runDoctor(ctx);
-        if (!report.ok) {
-          ctx.ui.notify(formatDoctorReport(report).slice(0, 10000), "error");
-          return;
-        }
-        const inspected = await inspectWorkflow(ctx.cwd);
-        if (!inspected.result.ok || !inspected.snapshot) {
-          ctx.ui.notify(`Devflow continue failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
-          return;
-        }
-        if (inspected.snapshot.action === "workflow_complete") {
-          ctx.ui.notify("Devflow workflow is already complete.", "info");
-          return;
-        }
-        if (inspected.snapshot.status === "waiting_checkpoint") {
-          setControlState(ctx, { intent: "workflow-execute", phase: "awaiting-approval", label: "等待用户确认 checkpoint" });
-          ctx.ui.notify("当前步骤正在等待 checkpoint；请审查产物后使用 /devflow checkpoint。", "warning");
-          return;
-        }
-        setControlState(ctx, executingState("执行当前工作流步骤（完成后停止）"));
-        ctx.ui.notify("仅启动当前步骤；模型被禁止迁移状态或继续下一步骤。", "info");
-        await triggerWorkflow(inspected.snapshot, "continue");
-        return;
-      }
-      if (trimmed === "advance") {
-        const inspected = await inspectWorkflow(ctx.cwd);
-        if (!inspected.result.ok || !inspected.snapshot) {
-          ctx.ui.notify(`Devflow advance failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
-          return;
-        }
-        if (inspected.snapshot.action === "workflow_complete" && inspected.snapshot.source_flow) {
-          const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
-          if (revision === undefined) {
-            ctx.ui.notify("补救分支缺少 revision，拒绝返回主流程。", "error");
-            return;
-          }
-          const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
-            "--write",
-            "--json",
-            "--expected-revision",
-            String(revision),
-            "--exit-failure-branch",
-          ]);
-          if (!result.ok) {
-            ctx.ui.notify(`补救分支返回失败：${result.stderr || result.stdout}`, "error");
-            return;
-          }
-          ctx.ui.notify("补救分支已返回主流程；仍需审查 reverify 结果，并在 CP-4 明确确认后才能继续。", "info");
-          return;
-        }
-        if (inspected.snapshot.status === "waiting_checkpoint") {
-          ctx.ui.notify("当前状态等待 checkpoint；请使用 /devflow checkpoint。", "warning");
-          return;
-        }
-        const step = compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step);
-        const stepId = typeof step?.id === "string" ? step.id : undefined;
-        const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
-        if (!stepId || revision === undefined) {
-          ctx.ui.notify("当前状态没有可推进的步骤或 revision；请先执行 /devflow explain-state。", "error");
-          return;
-        }
-        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
-          "--write",
-          "--json",
-          "--expected-revision",
-          String(revision),
-          "--complete-step",
-          stepId,
-        ]);
-        if (!result.ok) {
-          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "推进校验失败" });
-          ctx.ui.notify(`步骤未推进：${result.stderr || result.stdout}`, "error");
-          return;
-        }
-        const after = await inspectWorkflow(ctx.cwd);
-        setControlState(
-          ctx,
-          after.snapshot?.status === "waiting_checkpoint"
-            ? { intent: "workflow-execute", phase: "awaiting-approval", label: "等待用户确认 checkpoint" }
-            : waitingUserState("等待用户审查步骤产物"),
-        );
-        ctx.ui.notify(`已完成步骤 ${stepId} 的真实产物校验并推进状态。${after.snapshot?.status === "waiting_checkpoint" ? "下一步需要 /devflow checkpoint。" : "下一步请审查后使用 /devflow continue。"}`, "info");
-        return;
-      }
-      if (trimmed === "checkpoint") {
-        const inspected = await inspectWorkflow(ctx.cwd);
-        if (!inspected.result.ok || !inspected.snapshot) {
-          ctx.ui.notify(`Devflow checkpoint failed: ${inspected.result.stderr || inspected.result.stdout || "invalid inspector JSON"}`, "error");
-          return;
-        }
-        if (inspected.snapshot.status !== "waiting_checkpoint") {
-          ctx.ui.notify("当前并不等待 checkpoint；请使用 /devflow explain-state 查看原因。", "warning");
-          return;
-        }
-        const revision = typeof inspected.snapshot.revision === "number" ? inspected.snapshot.revision : undefined;
-        if (revision === undefined) {
-          ctx.ui.notify("当前状态缺少 revision，拒绝确认 checkpoint。", "error");
-          return;
-        }
-        const confirmed = await ctx.ui.confirm("确认 Devflow checkpoint", "你已审查当前步骤产物并同意推进到下一步骤吗？");
-        if (!confirmed) {
-          ctx.ui.notify("checkpoint 未确认；状态保持不变。", "info");
-          return;
-        }
-        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
-          "--write",
-          "--json",
-          "--expected-revision",
-          String(revision),
-          "--confirm-checkpoint",
-        ]);
-        if (!result.ok) {
-          setControlState(ctx, { intent: "workflow-execute", phase: "blocked", label: "checkpoint 校验失败" });
-          ctx.ui.notify(`checkpoint 未推进：${result.stderr || result.stdout}`, "error");
-          return;
-        }
-        setControlState(ctx, waitingUserState("等待用户确认下一步骤"));
-        ctx.ui.notify("checkpoint 已由用户确认；下一步骤尚未执行，请使用 /devflow continue。", "info");
-        return;
-      }
       if (trimmed.startsWith("start ")) {
         const [feature, phase = "delivery"] = trimmed.slice(6).split("|", 2).map(value => value.trim());
         if (!feature) {
@@ -1706,14 +1681,19 @@ export default function devflowCore(pi: ExtensionAPI) {
           return;
         }
         setControlState(ctx, planningState("requirement-draft"));
-        ctx.ui.notify(
-          `Devflow 已创建 Feature ${feature}，但没有自动执行。当前步骤：${String((compactStep(inspected.snapshot.next_step) ?? compactStep(inspected.snapshot.current_step))?.id ?? "requirement-triage")}。请补充需求后使用 /devflow continue。`,
-          "info",
+        await pi.sendUserMessage(
+          [
+            "<devflow-requirement-draft-directive>",
+            `Devflow 已创建 Feature ${feature}。当前为安全的需求梳理阶段：允许澄清和只读证据收集，不得写入项目或迁移状态。`,
+            "请先基于功能名说明你需要的最少业务背景，并邀请用户直接补充目标、使用者、约束和验收结果。收到用户的下一段需求描述后，运行时会将其原文注入 requirement-triage 并启动该步骤。",
+            "不要让用户输入命令；也不要把普通需求文本当成批准或 checkpoint 确认。",
+            "</devflow-requirement-draft-directive>",
+          ].join("\n"),
         );
         return;
       }
       ctx.ui.notify(
-        "Usage: /devflow doctor | status | explain-state | recover | project-init | start <feature>|<phase> | resume | continue | advance | checkpoint",
+        "Usage: /devflow doctor | status | explain-state | recover | project-init | start <feature>|<phase> | resume",
         "warning",
       );
     },

package/src/platform-extension.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionUIContext } from "@oh-my-pi/pi-coding-agent";
 import { mkdir, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
 import path from "node:path";
 
 import { devflowHome } from "./paths.ts";
@@ -43,6 +44,13 @@ function daysAgo(days: number): string {
   return date.toISOString().slice(0, 10);
 }
 
+function openHtmlReport(file: string): void {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", file] : [file];
+  const child = spawn(command, args, { detached: true, stdio: "ignore" });
+  child.unref();
+}
+
 export function createPlatformExtension(options: PlatformExtensionOptions) {
   return function devflowPlatform(pi: ExtensionAPI) {
     const { z } = pi.zod;
@@ -86,7 +94,7 @@ export function createPlatformExtension(options: PlatformExtensionOptions) {
         ...usageTool,
       });
     }
-    async function pickUsageInput(ctx: { ui: ExtensionUIContext }): Promise<UsageInput | undefined> {
+    async function pickUsageInput(ctx: { ui: ExtensionUIContext; modelRegistry: { getAvailable(): Array<{ provider: string; id: string }> } }): Promise<UsageInput | undefined> {
       const sourceChoice = await ctx.ui.select("使用统计：数据范围", [
         { label: "当前 Devflow 项目", description: "只读取当前项目会话（推荐）" },
         { label: "OMP 历史", description: "读取 ~/.omp/agent/sessions" },
@@ -97,7 +105,10 @@ export function createPlatformExtension(options: PlatformExtensionOptions) {
       const overview = await aggregateUsageReport(root, source);
       const sessionChoice = await ctx.ui.select("使用统计：会话", ["全部会话", ...Object.keys(overview.perSession)]);
       if (!sessionChoice) return undefined;
-      const modelChoice = await ctx.ui.select("使用统计：模型", ["全部模型", ...Object.keys(overview.perModel)]);
+      // The selector is for filtering a report, so it must list every model
+      // configured in OMP — not merely the model names found in old sessions.
+      const registeredModels = [...new Set(ctx.modelRegistry.getAvailable().map(model => `${model.provider}/${model.id}`))].sort();
+      const modelChoice = await ctx.ui.select("使用统计：模型", ["全部模型", ...registeredModels]);
       if (!modelChoice) return undefined;
       const period = await ctx.ui.select("使用统计：时间范围", ["全部时间", "今天", "最近 7 天", "最近 30 天", "自定义日期"]);
       if (!period) return undefined;
@@ -129,7 +140,8 @@ export function createPlatformExtension(options: PlatformExtensionOptions) {
         const destination = path.join(reportDir, `usage-${new Date().toISOString().replaceAll(":", "-")}.html`);
         await mkdir(reportDir, { recursive: true });
         await writeFile(destination, renderUsageHtml(report), "utf8");
-        ctx.ui.notify(`已生成 HTML 使用报告：${destination}`, "info");
+        openHtmlReport(destination);
+        ctx.ui.notify(`已生成并在默认浏览器打开 HTML 使用报告：${destination}`, "info");
         return;
       }
       ctx.ui.notify(input.format === "json" ? JSON.stringify({ projectId: options.projectId, ...report }, null, 2).slice(0, 12000) : renderUsageReport(report).slice(0, 12000), "info");