@guanlin4924/devflow-pi 0.1.26 → 0.1.28

package/README.md

@@ -11,7 +11,7 @@ Devflow Pi 是一个面向项目研发交付的独立 OMP 产品入口，内置
 安装与启动：
 
 ```bash
-npm install -g @guanlin4924/devflow-pi@0.1.26
+npm install -g @guanlin4924/devflow-pi@0.1.28
 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.26",
+  "version": "0.1.28",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",
@@ -12,7 +12,8 @@
     "doctor": "bun run src/cli.ts doctor",
     "test:devflow-pi": "bun test tests/devflow-pi",
     "test": "bun test tests/devflow-pi && python3 -m unittest discover -s tests -p 'test_*.py'",
-    "check": "bun test tests/devflow-pi && python3 -m unittest discover -s tests -p 'test_*.py'"
+    "check": "bun test tests/devflow-pi && python3 -m unittest discover -s tests -p 'test_*.py'",
+    "release": "bash scripts/release-npm.sh"
   },
   "engines": {
     "bun": ">=1.3.14"

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

@@ -1599,7 +1599,13 @@ export default function devflowCore(pi: ExtensionAPI) {
     ) {
       return { block: true, reason: planningToolBlockReason(toolName) };
     }
-    if (isStateMutationTool(toolName)) {
+    const toolInput = event.input && typeof event.input === "object" ? event.input as Record<string, unknown> : undefined;
+    // Registry reconciliation is intentionally the one write operation an
+    // agent may request while a step is blocked: it changes only derived
+    // artifact metadata and never advances STATE, checkpoints, or ownership.
+    const isRegistryReconciliation =
+      toolName === "devflow_artifact" && toolInput?.action === "sync" && toolInput?.preserve === false;
+    if (isStateMutationTool(toolName) && !isRegistryReconciliation) {
       return {
         block: true,
         reason:
@@ -2403,9 +2409,11 @@ export default function devflowCore(pi: ExtensionAPI) {
     label: "Devflow Transition",
     description: "Apply one validated delivery-state transition. This is the only supported STATE.md mutation path.",
     parameters: z.object({
-      action: z.enum(["complete-step", "confirm-checkpoint", "checkpoint-decision", "enter-failure-branch"]),
+      action: z.enum(["complete-step", "confirm-checkpoint", "checkpoint-decision", "enter-failure-branch", "cancel-feature"]),
       step: z.string().optional(),
       decision: z.string().optional(),
+      reason: z.string().optional(),
+      confirm: z.literal(true).optional(),
       state: z.string().optional(),
       expectedRevision: z.number().int().min(0),
     }),
@@ -2438,6 +2446,19 @@ export default function devflowCore(pi: ExtensionAPI) {
           return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "decision is required" });
         }
         args.push("--checkpoint-decision", params.decision);
+      } else if (params.action === "cancel-feature") {
+        const inspected = await inspectWorkflow(ctx.cwd);
+        const snapshot = inspected.snapshot;
+        const feature = typeof snapshot?.current_feature === "string" ? snapshot.current_feature : "当前需求";
+        const revision = typeof snapshot?.revision === "number" ? snapshot.revision : undefined;
+        if (!inspected.result.ok || revision === undefined) return renderResult(inspected.result, { action: params.action });
+        if (!params.reason?.trim()) return renderResult({ ok: false, exitCode: 2, stdout: "", stderr: "reason is required" });
+        const confirmed = await ctx.ui.confirm(
+          "确认弃用当前需求",
+          `需求：${feature}\n原因：${params.reason.trim()}\n\n将结束当前需求、释放项目占用并保留现有工件；不会把未完成步骤标记为完成。继续吗？`,
+        );
+        if (!confirmed) return renderResult({ ok: false, exitCode: 1, stdout: "", stderr: "User declined feature cancellation." });
+        args.push("--cancel", "--cancel-reason", params.reason.trim());
       } else {
         args.push("--enter-failure-branch");
       }
@@ -2601,6 +2622,42 @@ export default function devflowCore(pi: ExtensionAPI) {
         ctx.ui.notify("控制面 registry 已修复；未推进工作流。请审查当前步骤产物后明确回复“批准执行”或提出修改意见。", "info");
         return;
       }
+      if (trimmed === "abandon" || trimmed.startsWith("abandon ") || trimmed === "cancel" || trimmed.startsWith("cancel ")) {
+        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) {
+          ctx.ui.notify(`无法读取当前需求状态：${inspected.result.stderr || inspected.result.stdout}`, "error");
+          return;
+        }
+        if (!status || ["completed", "cancelled", "failed"].includes(status)) {
+          ctx.ui.notify(`当前没有可弃用的进行中需求（status=${status || "unknown"}）。`, "info");
+          return;
+        }
+        const reason = trimmed.split(/\s+/, 2)[1]?.trim() || "用户主动终止当前需求";
+        const confirmed = await ctx.ui.confirm(
+          "确认弃用当前需求",
+          `需求：${feature}\n原因：${reason}\n\n将结束当前需求、释放项目占用并保留现有工件；不会把未完成步骤标记为完成。继续吗？`,
+        );
+        if (!confirmed) {
+          ctx.ui.notify("已取消弃用操作；状态保持不变。", "info");
+          return;
+        }
+        const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
+          "--write", "--json", "--cancel", "--cancel-reason", reason, "--expected-revision", String(revision),
+        ]);
+        if (!result.ok) {
+          ctx.ui.notify(`弃用当前需求失败：${result.stderr || result.stdout}`, "error");
+          return;
+        }
+        activeContract = undefined;
+        contractAgentCalls = 0;
+        setControlState(ctx, initialControlState());
+        ctx.ui.notify(`需求“${feature}”已弃用；现有工件已保留。现在可以创建新需求。`, "info");
+        return;
+      }
       if (trimmed === "project-init") {
         const initialization = await collectProjectInitialization(ctx);
         if (!initialization) return;
@@ -2672,7 +2729,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         }
         const existing = await inspectWorkflow(ctx.cwd);
         const existingFeature = existing.snapshot?.current_feature;
-        const previousWorkflowComplete = existing.snapshot?.action === "workflow_complete";
+        const previousWorkflowComplete = ["workflow_complete", "workflow_cancelled"].includes(existing.snapshot?.action as string);
         if (
           !previousWorkflowComplete &&
           typeof existingFeature === "string" &&
@@ -2753,7 +2810,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       ctx.ui.notify(
-        "Usage: /devflow doctor | status | explain-state | recover | project-init | start <feature>|<phase> | resume",
+        "Usage: /devflow doctor | status | explain-state | recover | abandon [reason] | project-init | start <feature>|<phase> | resume",
         "warning",
       );
     },

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

@@ -21,6 +21,8 @@ options = {
   checkpoint_decision: nil,
   enter_failure_branch: false,
   exit_failure_branch: false,
+  cancel: false,
+  cancel_reason: nil,
   expected_revision: nil,
   json: false
 }
@@ -34,6 +36,8 @@ OptionParser.new do |opts|
   opts.on("--checkpoint-decision VALUE", "Set checkpoint decision, e.g. approved, rejected, needs_fix") { |value| options[:checkpoint_decision] = value }
   opts.on("--enter-failure-branch", "Transition into the configured failure branch for the current step") { options[:enter_failure_branch] = true }
   opts.on("--exit-failure-branch", "Return from a completed failure branch to its configured source flow") { options[:exit_failure_branch] = true }
+  opts.on("--cancel", "Cancel the active feature without marking pending steps completed") { options[:cancel] = true }
+  opts.on("--cancel-reason REASON", "Record why the active feature was cancelled") { |reason| options[:cancel_reason] = reason }
   opts.on("--expected-revision REVISION", Integer, "Reject a stale write unless STATE.md has this revision") { |value| options[:expected_revision] = value }
   opts.on("--json", "Print JSON output") { options[:json] = true }
 end.parse!
@@ -527,6 +531,31 @@ result =
         action_description = "Checkpoint decision set to: #{options[:checkpoint_decision]}"
       end
 
+      if result.nil? && options[:cancel]
+        if %w[completed cancelled failed].include?(state["status"])
+          result = fail_result("feature_not_active", "status" => state["status"])
+        elsif options[:cancel_reason].to_s.strip.empty?
+          result = fail_result("cancel_reason_required")
+        else
+          state["status"] = "cancelled"
+          state["cancel_reason"] = options[:cancel_reason].to_s.strip
+          state["cancelled_at"] = Date.today.to_s
+          # A cancelled feature is terminal. Preserve completed steps and the
+          # previous step for history, but clear current/pending work so the
+          # inspector can expose a terminal state and ownership can be released.
+          state["cancelled_step"] = state["current_step"]
+          state["current_step"] = nil
+          state["pending_steps"] = []
+          state.delete("checkpoint")
+          state.delete("checkpoint_label")
+          state.delete("checkpoint_decision")
+          state.delete("rollover")
+          changed = true
+          actions << "feature_cancelled"
+          action_description = "Feature cancelled: #{state["current_feature"]}. Reason: #{state["cancel_reason"]}."
+        end
+      end
+
       if result.nil? && options[:complete_step]
         step_id = options[:complete_step]
         step = step_by_id[step_id]

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

@@ -473,6 +473,28 @@ result =
                 action: "workflow_complete",
                 reason: "completed_status_with_no_pending_steps"
               }
+            elsif pending_ids.empty? && %w[cancelled failed].include?(state["status"])
+              {
+                current_flow: state["current_flow"],
+                current_feature: state["current_feature"],
+                current_phase: state["current_phase"],
+                status: state["status"],
+                cancel_reason: state["cancel_reason"],
+                cancelled_step: state["cancelled_step"],
+                completed_steps: completed_ids,
+                pending_steps: pending_ids,
+                current_step: state["current_step"] && step_payload(step_by_id[state["current_step"]], state, root, artifact_by_path),
+                next_step: nil,
+                workflow_config: workflow_path,
+                artifact_registry: artifact_registry_summary(root, artifact_by_path).merge(
+                  "path" => artifact_registry_path,
+                  "error" => artifact_registry_error,
+                  "recovery" => artifact_registry_error ? "Call devflow_artifact with action=sync." : nil,
+                  "current_outputs_registered" => 0
+                ),
+                action: state["status"] == "cancelled" ? "workflow_cancelled" : "workflow_failed",
+                reason: "terminal_status_with_no_pending_steps"
+              }
             else
               fail_result("unknown_current_step", current_step: state["current_step"])
             end

package/src/constants.ts

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

package/src/platform-extension.ts

@@ -10,6 +10,8 @@ export interface PlatformExtensionOptions {
   sessionRoot: string;
   ompSessionRoot: string;
   projectId: string;
+  /** Read the persisted role assignment so optional roles can fail closed. */
+  getConfiguredRole?: (role: string) => string | undefined;
 }
 
 type UsageFormat = "table" | "json" | "html";
@@ -55,6 +57,45 @@ export function createPlatformExtension(options: PlatformExtensionOptions) {
   return function devflowPlatform(pi: ExtensionAPI) {
     const { z } = pi.zod;
     pi.setLabel("Devflow Platform Runtime");
+    let modelBeforeVisionTurn: Parameters<ExtensionAPI["setModel"]>[0] | undefined;
+    let visionTurnActive = false;
+
+    pi.on("input", async (event, ctx) => {
+      if (event.source !== "interactive" || !event.images?.length) return;
+
+      const configuredVision = options.getConfiguredRole?.("vision")?.trim();
+      if (!configuredVision) {
+        ctx.ui.notify("检测到图片，但尚未配置 VISION 模型。请先在 /model 中配置 VISION，再重新提交。", "warning");
+        if (ctx.hasUI) await ctx.ui.input("VISION 未配置", "请先在 /model 中配置 VISION，完成后重新提交本次图片");
+        return { handled: true };
+      }
+
+      const visionModel = ctx.models.resolve("@vision");
+      if (!visionModel || !visionModel.input.includes("image")) {
+        ctx.ui.notify(`VISION 配置无法解析为支持图片输入的模型：${configuredVision}`, "error");
+        if (ctx.hasUI) await ctx.ui.input("VISION 配置无效", "请选择支持图片输入的模型后重新提交");
+        return { handled: true };
+      }
+
+      modelBeforeVisionTurn = ctx.models.current();
+      if (!(await pi.setModel(visionModel))) {
+        modelBeforeVisionTurn = undefined;
+        ctx.ui.notify(`无法切换到 VISION 模型：${visionModel.provider}/${visionModel.id}`, "error");
+        return { handled: true };
+      }
+      visionTurnActive = true;
+      ctx.ui.notify(`本回合已切换到 VISION：${visionModel.provider}/${visionModel.id}`, "info");
+      return;
+    });
+
+    pi.on("turn_end", async (_event, ctx) => {
+      if (!visionTurnActive || !modelBeforeVisionTurn) return;
+      const previousModel = modelBeforeVisionTurn;
+      modelBeforeVisionTurn = undefined;
+      visionTurnActive = false;
+      await pi.setModel(previousModel);
+      ctx.ui.notify(`图片回合结束，已恢复模型：${previousModel.provider}/${previousModel.id}`, "info");
+    });
     const usageParameters = z.object({
       source: z.enum(["project", "omp"]).default("project"),
       session: z.string().optional(),

package/src/runtime.ts

@@ -37,7 +37,9 @@ const MANAGED_SETTINGS: Record<string, unknown> = {
   // The interactive session is the high-capability Planner. Low-cost agents
   // are dispatched only through explicit Devflow steps, one at a time by
   // default, so background work cannot silently widen a user's request.
-  "modelRoles.default": "@slow",
+  // Keep ordinary interactive turns on the user's DEFAULT role. In particular,
+  // do not inherit SLOW just because a thinking model is configured.
+  "defaultThinkingLevel": "low",
   "task.batch": false,
   "task.maxConcurrency": 1,
   "task.maxRecursionDepth": 1,
@@ -140,6 +142,7 @@ export async function createEmbeddedRuntime(project: ProjectContext, options: Ru
         sessionRoot: sessionDir,
         ompSessionRoot: path.join(sharedAgentDir, "sessions"),
         projectId: project.manifest.projectId,
+        getConfiguredRole: role => settings.getModelRole(role),
       }),
     ],
     hasUI: options.hasUI ?? true,

package/templates/omp/AGENTS.md

@@ -8,6 +8,8 @@ This repository uses an OMP-native, project-scoped software delivery runtime.
 - 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`.
+- To abandon an active feature, use the runtime-confirmed `devflow_transition`
+  `cancel-feature` operation or `/devflow abandon`; never edit control files.
 - Never directly edit `.planning/STATE.md`, `.planning/.next-intent`, `.planning/workflows/`, or `.planning/artifacts/index.yaml`.
 - The parent session is the only workflow-state writer. Task agents return evidence or patches and never advance state.
 

package/templates/omp/config.yml

@@ -1,6 +1,9 @@
 # Devflow owns this project-local OMP profile. Model ids stay in the user's
 # global config; only role storage and development policy are project-scoped.
 modelRoleStorage: project
+# Ordinary turns stay on DEFAULT and use only low automatic thinking. Agent
+# frontmatter may still opt into medium/high for explicitly routed work.
+defaultThinkingLevel: low
 
 # Do not import competing editor/harness configuration into this dedicated Pi.
 # These are discovery-source ids, not model-provider ids.