pi-bmad-flow 0.1.3 → 0.1.4

package/README.md

@@ -107,5 +107,71 @@ Current behavior:
 - BMAD-specific compaction summaries
 - lightweight BMAD status widget and footer state
 - optional LLM access to deterministic BMAD state through the `bmad_orchestrator` tool
+- workflow-aware model and thinking presets for routing, story prep, story start, review, and gates
 
 This package does not replace official BMAD workflows. It reduces routing overhead around them.
+
+## Optional model policy override
+
+By default, the overlay uses a GPT-only policy aimed at:
+
+- `openai-codex/gpt-5.4-mini` for routing and status
+- `openai-codex/gpt-5.4` for story prep, story start, review, and gates
+- thinking level as the main optimization knob
+
+The policy is applied both for overlay commands and for common BMAD workflow inputs such as:
+
+- `bmad-create-story`
+- `bmad-dev-story`
+- `bmad-create-prd`
+- `bmad-create-architecture`
+- `bmad-create-epics-and-stories`
+- `bmad-code-review`
+- `bmad-testarch-test-review`
+- `bmad-testarch-trace`
+- `bmad-testarch-nfr`
+
+You can override the default preset behavior with:
+
+```text
+.pi/bmad/model-policy.json
+```
+
+Shape:
+
+```json
+{
+  "presets": {
+    "routing": {
+      "model": "openai-codex/gpt-5.4-mini",
+      "thinking": "minimal"
+    },
+    "story-prep": {
+      "model": "openai-codex/gpt-5.4",
+      "thinking": "low"
+    },
+    "story-start-lean": {
+      "model": "openai-codex/gpt-5.4",
+      "thinking": "low"
+    },
+    "story-start-full": {
+      "model": "openai-codex/gpt-5.4",
+      "thinking": "medium"
+    },
+    "review": {
+      "model": "openai-codex/gpt-5.4",
+      "thinking": "low"
+    },
+    "gate-light": {
+      "model": "openai-codex/gpt-5.4",
+      "thinking": "low"
+    },
+    "gate-strong": {
+      "model": "openai-codex/gpt-5.4",
+      "thinking": "medium"
+    }
+  }
+}
+```
+
+If you omit `model`, the overlay falls back to tier-based matching.

package/extensions/bmad-orchestrator/commands.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { detectBmadInstall, detectBmadProjectState } from "./detector.js";
 import { decideGate } from "./gates.js";
 import { buildStoryPacket, packetHint, selectPacketMode } from "./packets.js";
+import { applyPreset, presetForNextCommand } from "./policy.js";
 import { decideNextAction } from "./router.js";
 import { updateStoryStatus } from "./sprint.js";
 import type { GatePlan, StoryPacket } from "./types.js";
@@ -45,6 +46,11 @@ function formatPacketLaunchMessage(story: string, packet: StoryPacket): string {
   return lines.join("\n");
 }
 
+function currentModelLabel(ctx: { model?: { provider: string; id: string } }): string | undefined {
+  if (!ctx.model) return undefined;
+  return `${ctx.model.provider}/${ctx.model.id}`;
+}
+
 function formatGateMessage(plan: GatePlan): string {
   const lines = [
     `Gate level: ${plan.level}`,
@@ -66,6 +72,7 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
   pi.registerCommand("bmad-status", {
     description: "Show BMAD install, phase, and story queue status",
     handler: async (_args, ctx) => {
+      await applyPreset(pi, ctx, cwd, "routing");
       const install = detectBmadInstall(cwd);
       const state = detectBmadProjectState(cwd);
       const next = decideNextAction(state);
@@ -93,7 +100,11 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
       }
       ctx.ui.notify(`Next: ${next.command} - ${next.summary}`, "info");
 
-      refreshBmadUi(ctx, state, next);
+      refreshBmadUi(ctx, state, next, {
+        preset: "routing",
+        model: currentModelLabel(ctx),
+        thinking: pi.getThinkingLevel(),
+      });
       appendBmadState(pi, { event: "status", nextCommand: next.command });
     },
   });
@@ -101,6 +112,7 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
   pi.registerCommand("bmad-phase", {
     description: "Show current workflow phase and recommended route",
     handler: async (_args, ctx) => {
+      await applyPreset(pi, ctx, cwd, "routing");
       const state = detectBmadProjectState(cwd);
       const next = decideNextAction(state);
       ctx.ui.notify(`Current phase: ${state.phase}`, "info");
@@ -115,7 +127,11 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
         ctx.ui.notify(`Story location: ${state.activeStoryLocation}`, "info");
       }
       ctx.ui.notify(`Recommended: ${next.command} (${next.reason})`, "info");
-      refreshBmadUi(ctx, state, next);
+      refreshBmadUi(ctx, state, next, {
+        preset: "routing",
+        model: currentModelLabel(ctx),
+        thinking: pi.getThinkingLevel(),
+      });
       appendBmadState(pi, { event: "status", nextCommand: next.command });
     },
   });
@@ -123,6 +139,7 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
   pi.registerCommand("bmad-next", {
     description: "Determine next action from BMAD artifacts",
     handler: async (_args, ctx) => {
+      await applyPreset(pi, ctx, cwd, "routing");
       const install = detectBmadInstall(cwd);
       if (!install.installed) {
         ctx.ui.notify("No BMAD installation detected at _bmad/_config/manifest.yaml", "warning");
@@ -133,12 +150,17 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
       const next = decideNextAction(state);
       ctx.ui.notify(next.summary, "info");
       ctx.ui.notify(`Recommended command: ${next.command}`, "info");
-      refreshBmadUi(ctx, state, next);
+      refreshBmadUi(ctx, state, next, {
+        preset: "routing",
+        model: currentModelLabel(ctx),
+        thinking: pi.getThinkingLevel(),
+      });
       appendBmadState(pi, { event: "next", nextCommand: next.command });
 
       if (!ctx.hasUI) return;
       const shouldLaunch = await ctx.ui.confirm("Launch recommended workflow?", next.command);
       if (shouldLaunch) {
+        await applyPreset(pi, ctx, cwd, presetForNextCommand(next.command));
         pi.sendUserMessage(next.command, { source: "extension" });
       }
     },
@@ -162,6 +184,7 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
       }
 
       const mode = selectPacketMode(state);
+      await applyPreset(pi, ctx, cwd, mode === "full" ? "story-start-full" : "story-start-lean");
       const packet = buildStoryPacket(state, story, mode);
       const statusUpdated = updateStoryStatus(install.paths.sprintStatusPath, story, "in-progress");
       if (!statusUpdated) {
@@ -198,7 +221,11 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
 
       const refreshedState = detectBmadProjectState(cwd);
       const refreshedNext = decideNextAction(refreshedState);
-      refreshBmadUi(ctx, refreshedState, refreshedNext);
+      refreshBmadUi(ctx, refreshedState, refreshedNext, {
+        preset: mode === "full" ? "story-start-full" : "story-start-lean",
+        model: currentModelLabel(ctx),
+        thinking: pi.getThinkingLevel(),
+      });
       pi.sendUserMessage(formatPacketLaunchMessage(story, packet), { source: "extension" });
     },
   });
@@ -206,6 +233,7 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
   pi.registerCommand("bmad-review", {
     description: "Run review workflow for active story",
     handler: async (_args, ctx) => {
+      await applyPreset(pi, ctx, cwd, "review");
       const state = detectBmadProjectState(cwd);
       const story = state.activeStory ?? state.nextReadyStory;
       if (!story) {
@@ -215,7 +243,11 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
 
       ctx.ui.notify(`Running review for ${story}`, "info");
       appendBmadState(pi, { event: "review", storyKey: story });
-      refreshBmadUi(ctx, state, decideNextAction(state));
+      refreshBmadUi(ctx, state, decideNextAction(state), {
+        preset: "review",
+        model: currentModelLabel(ctx),
+        thinking: pi.getThinkingLevel(),
+      });
       pi.sendUserMessage(`bmad-code-review ${story}`, { source: "extension" });
     },
   });
@@ -231,6 +263,7 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
         return;
       }
       const decision = decideGate(state, install.modules.includes("tea"));
+      await applyPreset(pi, ctx, cwd, decision.level === "strong" ? "gate-strong" : "gate-light");
       const plan: GatePlan = {
         storyKey: story,
         level: decision.level,
@@ -246,7 +279,11 @@ export function registerBmadCommands(pi: ExtensionAPI, cwd: string): void {
         ctx.ui.notify(`Evidence files: ${decision.evidenceFiles.length}`, "info");
       }
       appendBmadState(pi, { event: "gate", storyKey: story, gateLevel: decision.level });
-      refreshBmadUi(ctx, state, decideNextAction(state));
+      refreshBmadUi(ctx, state, decideNextAction(state), {
+        preset: decision.level === "strong" ? "gate-strong" : "gate-light",
+        model: currentModelLabel(ctx),
+        thinking: pi.getThinkingLevel(),
+      });
       pi.sendUserMessage(formatGateMessage(plan), { source: "extension" });
     },
   });

package/extensions/bmad-orchestrator/index.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { detectBmadInstall, detectBmadProjectState } from "./detector.js";
 import { registerBmadCommands } from "./commands.js";
 import { decideNextAction } from "./router.js";
+import { applyPreset, presetForWorkflowInput } from "./policy.js";
 import { registerBmadTool } from "./tool.js";
 import { clearBmadUi, refreshBmadUi } from "./ui.js";
 
@@ -55,12 +56,25 @@ export default function bmadOrchestrator(pi: ExtensionAPI): void {
   registerBmadCommands(pi, cwd);
   registerBmadTool(pi, cwd);
 
-  pi.on("input", async (event) => {
+  pi.on("input", async (event, ctx) => {
     if (event.source === "extension") return { action: "continue" };
+
     const command = routeIntent(event.text);
-    if (!command) return { action: "continue" };
-    pi.sendUserMessage(command, { source: "extension" });
-    return { action: "handled" };
+    if (command) {
+      const preset = presetForWorkflowInput(command);
+      if (preset) {
+        await applyPreset(pi, ctx, cwd, preset);
+      }
+      pi.sendUserMessage(command, { source: "extension" });
+      return { action: "handled" };
+    }
+
+    const workflowPreset = presetForWorkflowInput(event.text);
+    if (workflowPreset) {
+      await applyPreset(pi, ctx, cwd, workflowPreset);
+    }
+
+    return { action: "continue" };
   });
 
   pi.on("session_start", async (_event, ctx) => {
@@ -74,7 +88,10 @@ export default function bmadOrchestrator(pi: ExtensionAPI): void {
     const modules = install.modules.length > 0 ? install.modules.join(", ") : "none";
     const state = detectBmadProjectState(cwd);
     const next = decideNextAction(state);
-    refreshBmadUi(ctx, state, next);
+    refreshBmadUi(ctx, state, next, {
+      model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
+      thinking: pi.getThinkingLevel(),
+    });
     ctx.ui.notify(`pi-bmad-flow ready. BMAD modules: ${modules}`, "info");
   });
 
@@ -83,7 +100,10 @@ export default function bmadOrchestrator(pi: ExtensionAPI): void {
     if (!install.installed) return;
     const state = detectBmadProjectState(cwd);
     const next = decideNextAction(state);
-    refreshBmadUi(ctx, state, next);
+    refreshBmadUi(ctx, state, next, {
+      model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
+      thinking: pi.getThinkingLevel(),
+    });
   });
 
   pi.on("session_before_compact", async (event, ctx) => {

package/extensions/bmad-orchestrator/policy.ts

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionContext, ThinkingLevel } from "@mariozechner/pi-coding-agent";
+
+export type BmadPresetName =
+  | "routing"
+  | "story-prep"
+  | "story-start-lean"
+  | "story-start-full"
+  | "review"
+  | "gate-light"
+  | "gate-strong";
+
+type ModelTier = "fast" | "balanced" | "strong";
+
+interface AvailableModel {
+  provider: string;
+  id: string;
+  name?: string;
+}
+
+interface PresetConfig {
+  model?: string;
+  tier?: ModelTier;
+  thinking: ThinkingLevel;
+}
+
+interface ModelPolicyConfig {
+  tiers?: Partial<Record<ModelTier, string[]>>;
+  presets?: Partial<Record<BmadPresetName, Partial<PresetConfig>>>;
+}
+
+const DEFAULT_TIERS: Record<ModelTier, string[]> = {
+  fast: ["openai-codex/gpt-5.4-mini", "openai-codex/*mini*"],
+  balanced: ["openai-codex/gpt-5.4", "openai-codex/*gpt-5.4*", "openai-codex/*codex*"],
+  strong: ["openai-codex/gpt-5.4", "openai-codex/*gpt-5.4*", "openai-codex/*codex*"],
+};
+
+const DEFAULT_PRESETS: Record<BmadPresetName, PresetConfig> = {
+  routing: { model: "openai-codex/gpt-5.4-mini", thinking: "minimal" },
+  "story-prep": { model: "openai-codex/gpt-5.4", thinking: "low" },
+  "story-start-lean": { model: "openai-codex/gpt-5.4", thinking: "low" },
+  "story-start-full": { model: "openai-codex/gpt-5.4", thinking: "medium" },
+  review: { model: "openai-codex/gpt-5.4", thinking: "low" },
+  "gate-light": { model: "openai-codex/gpt-5.4", thinking: "low" },
+  "gate-strong": { model: "openai-codex/gpt-5.4", thinking: "medium" },
+};
+
+function loadPolicyConfig(cwd: string): ModelPolicyConfig | undefined {
+  const configPath = join(cwd, ".pi", "bmad", "model-policy.json");
+  if (!existsSync(configPath)) return undefined;
+
+  try {
+    return JSON.parse(readFileSync(configPath, "utf8")) as ModelPolicyConfig;
+  } catch {
+    return undefined;
+  }
+}
+
+function escapeRegex(value: string): string {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+
+function matchesPattern(value: string, pattern: string): boolean {
+  const regex = new RegExp(`^${escapeRegex(pattern.toLowerCase()).replace(/\*/g, ".*")}$`);
+  return regex.test(value.toLowerCase());
+}
+
+function modelKey(model: AvailableModel): string {
+  return `${model.provider}/${model.id}`.toLowerCase();
+}
+
+function resolvePresetConfig(cwd: string, preset: BmadPresetName): { config: PresetConfig; tierPatterns?: string[] } {
+  const loaded = loadPolicyConfig(cwd);
+  const base = DEFAULT_PRESETS[preset];
+  const override = loaded?.presets?.[preset];
+  const config: PresetConfig = {
+    model: override?.model ?? base.model,
+    tier: override?.tier ?? base.tier,
+    thinking: override?.thinking ?? base.thinking,
+  };
+
+  const tierPatterns = config.tier ? loaded?.tiers?.[config.tier] ?? DEFAULT_TIERS[config.tier] : undefined;
+  return { config, tierPatterns };
+}
+
+async function selectModel(
+  ctx: ExtensionContext,
+  explicitModel: string | undefined,
+  tierPatterns: string[] | undefined,
+): Promise<AvailableModel | undefined> {
+  const available = (await ctx.modelRegistry.getAvailable()) as AvailableModel[];
+  const current = ctx.model as AvailableModel | undefined;
+
+  if (explicitModel) {
+    const found = available.find((candidate) => modelKey(candidate) === explicitModel.toLowerCase());
+    if (found) return found;
+  }
+
+  if (tierPatterns) {
+    if (current) {
+      const currentKey = modelKey(current);
+      if (tierPatterns.some((pattern) => matchesPattern(currentKey, pattern))) return current;
+    }
+
+    for (const pattern of tierPatterns) {
+      const found = available.find((candidate) => matchesPattern(modelKey(candidate), pattern));
+      if (found) return found;
+    }
+  }
+
+  return current ?? available[0];
+}
+
+export async function applyPreset(pi: ExtensionAPI, ctx: ExtensionContext, cwd: string, preset: BmadPresetName): Promise<void> {
+  const { config, tierPatterns } = resolvePresetConfig(cwd, preset);
+  const selectedModel = await selectModel(ctx, config.model, tierPatterns);
+
+  if (selectedModel) {
+    const current = ctx.model as AvailableModel | undefined;
+    const currentKey = current ? modelKey(current) : undefined;
+    const selectedKey = modelKey(selectedModel);
+    if (currentKey !== selectedKey) {
+      const changed = await pi.setModel(selectedModel);
+      if (changed) {
+        ctx.ui.notify(`BMAD preset ${preset}: model ${selectedModel.provider}/${selectedModel.id}`, "info");
+      }
+    }
+  }
+
+  if (pi.getThinkingLevel() !== config.thinking) {
+    pi.setThinkingLevel(config.thinking);
+    ctx.ui.notify(`BMAD preset ${preset}: thinking ${config.thinking}`, "info");
+  }
+}
+
+export function presetForNextCommand(command: string): BmadPresetName {
+  if (command === "/bmad-start") return "story-start-lean";
+  if (command === "bmad-create-story") return "story-prep";
+  if (command === "bmad-create-prd" || command === "bmad-create-architecture") return "story-start-full";
+  return "routing";
+}
+
+export function presetForWorkflowInput(text: string): BmadPresetName | undefined {
+  const normalized = text.trim().toLowerCase();
+  if (!normalized) return undefined;
+
+  if (normalized === "/bmad-status" || normalized === "/bmad-next" || normalized === "/bmad-phase") return "routing";
+  if (normalized === "/bmad-review") return "review";
+  if (normalized === "/bmad-gate") return "gate-light";
+  if (normalized === "/bmad-start") return "story-start-lean";
+  if (/^bmad-create-story\b/.test(normalized)) return "story-prep";
+  if (/^bmad-dev-story\b/.test(normalized)) return "story-start-lean";
+  if (/^bmad-create-prd\b/.test(normalized)) return "story-start-full";
+  if (/^bmad-create-architecture\b/.test(normalized)) return "story-start-full";
+  if (/^bmad-create-epics-and-stories\b/.test(normalized)) return "story-prep";
+  if (/^bmad-create-ux-design\b/.test(normalized)) return "story-prep";
+  if (/^bmad-code-review\b/.test(normalized)) return "review";
+  if (/^bmad-testarch-(test-review|trace)\b/.test(normalized)) return "gate-light";
+  if (/^bmad-testarch-nfr\b/.test(normalized)) return "gate-strong";
+
+  return undefined;
+}

package/extensions/bmad-orchestrator/ui.ts

@@ -1,15 +1,26 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext, ThinkingLevel } from "@mariozechner/pi-coding-agent";
 import type { BmadProjectState } from "./types.js";
 import type { NextAction } from "./router.js";
 
-export function refreshBmadUi(ctx: ExtensionContext, state: BmadProjectState, next: NextAction): void {
+interface BmadUiMeta {
+  preset?: string;
+  model?: string;
+  thinking?: ThinkingLevel;
+}
+
+export function refreshBmadUi(ctx: ExtensionContext, state: BmadProjectState, next: NextAction, meta?: BmadUiMeta): void {
   const activeStory = state.activeStory ?? state.nextReadyStory ?? "none";
-  ctx.ui.setStatus("bmad", `BMAD ${state.phase} | story ${activeStory}`);
+  const modelLine = meta?.model ? ` | ${meta.model}` : "";
+  const presetLine = meta?.preset ? ` | ${meta.preset}` : "";
+  const thinkingLine = meta?.thinking ? ` | ${meta.thinking}` : "";
+
+  ctx.ui.setStatus("bmad", `BMAD ${state.phase} | story ${activeStory}${presetLine}${thinkingLine}`);
   ctx.ui.setWidget("bmad", [
     `Phase: ${state.phase}`,
     `Active: ${state.activeStory ?? "none"}`,
     `Ready: ${state.nextReadyStory ?? "none"}`,
     `Next: ${next.command} — ${next.summary}`,
+    `Preset: ${meta?.preset ?? "default"}${thinkingLine}${modelLine}`,
   ]);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bmad-flow",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "Pi-native orchestration overlay for BMAD workflows",
   "keywords": [

package/scripts/check.mjs

@@ -34,6 +34,7 @@ function main() {
     "extensions/bmad-orchestrator/commands.ts",
     "extensions/bmad-orchestrator/detector.ts",
     "extensions/bmad-orchestrator/packets.ts",
+    "extensions/bmad-orchestrator/policy.ts",
     "extensions/bmad-orchestrator/tool.ts",
     "extensions/bmad-orchestrator/ui.ts",
     "scripts/bootstrap.mjs",