@leing2021/super-pi 0.19.2 → 0.19.3

package/README.md

@@ -35,7 +35,7 @@ Super Pi's answers:
 
 Each step has a dedicated skill + tool pair. Not just prompts — structured toolchains.
 
-### New: Stage model routing + optional auto-continue
+### New: Stage model routing
 
 Configure once in `.pi/settings.json`:
 
@@ -48,24 +48,22 @@ Configure once in `.pi/settings.json`:
     "04-review": "claude-sonnet-4-20250514",
     "05-learn": "claude-haiku-4-20250414",
     "default": "claude-sonnet-4-20250514"
-  },
-  "pipeline": {
-    "autoContinue": false
   }
 }
 ```
 
 How it works:
-- Each stage picks `modelStrategy[stage]`, or `modelStrategy.default` as fallback.
+- Model switching is handled automatically by the ce-core extension `input` hook — no manual `/model` needed.
+- When you type `/skill:01-brainstorm` through `/skill:05-learn`, the extension reads `modelStrategy[stage]` (or `modelStrategy.default`) and switches before the skill runs.
+- Supported formats: full reference (`"anthropic/claude-opus-4-1"`) or bare model id (`"claude-opus-4-1"`, reuses current provider).
 - Every stage prints a `📊 Pipeline Status` block with `Current / Output / Next`.
-- If `pipeline.autoContinue=true`, super-pi can trigger the next stage automatically.
-- Auto-continue is gate-aware: it will NOT skip required approvals (brainstorm approval, plan/review A/B/C choices).
+- A `Switched model for <stage>: <provider>/<model>` notification appears when the model changes.
 
 Quick example:
-1. Run `/skill:01-brainstorm`
+1. Run `/skill:01-brainstorm` — model auto-switches to the configured brainstorm model
 2. Approve the design
-3. If `autoContinue=true`, it moves to `/skill:02-plan` automatically
-4. If `autoContinue=false`, it stops after status output and waits for your command
+3. Run `/skill:02-plan` — model auto-switches to the configured plan model
+4. Continue through each stage — model switches automatically at each step
 
 ---
 
@@ -383,6 +381,13 @@ Not a fork. Not a wrapper. Methodologies extracted and rebuilt with Pi's native
 
 ## Changelog
 
+### 0.19.3 — Terminate fix + runtime model routing + autoContinue removal
+- Fixed 6 ce-core tools (`brainstorm_dialog`, `workflow_state`, `review_router`, `session_checkpoint`, `session_history`, `pattern_extractor`) incorrectly returning `terminate: true`, which caused agent turns to end prematurely (brainstorm questions not shown, "type continue to proceed" interruptions).
+- Implemented runtime stage model routing via ce-core extension `input` hook: reads `.pi/settings.json` `modelStrategy`, auto-switches model before skill execution. Supports full reference (`anthropic/claude-opus-4-1`) and bare model id (`claude-opus-4-1`).
+- Removed `pipeline.autoContinue` configuration (never had runtime implementation; Pi lacks `skill_end` event for auto-continue).
+- Updated `skills/references/pipeline-config.md`, `README.md`, `README_CN.md` to reflect runtime model routing behavior.
+- Added 4 new tests covering terminate regression, input hook model routing, and bare model id parsing.
+
 ### 0.19.2 — Evidence-first handoff-lite + docs tracking rule
 - Added `context_handoff` with evidence-first default handoff-lite generation when markdown is omitted.
 - Standardized the shared handoff-lite template across 01-05 workflow handoffs via `skills/references/pipeline-config.md`.
@@ -391,8 +396,7 @@ Not a fork. Not a wrapper. Methodologies extracted and rebuilt with Pi's native
 
 ### 0.19.1 — Pipeline config + typecheck baseline fix
 - Added shared pipeline config (`skills/references/pipeline-config.md`) for stage model routing via `.pi/settings.json`.
-- Added gated auto-continue rules (`pipeline.autoContinue`) so automation does not skip required approval/review-choice steps.
-- Added explicit README usage examples for `modelStrategy` and `pipeline.autoContinue`.
+- Added runtime stage model routing via ce-core extension `input` hook (reads `modelStrategy` from `.pi/settings.json`, auto-switches model before skill execution).
 - Fixed TypeScript baseline issues so `bunx tsc --noEmit` passes.
 
 ### 0.19.0 — 0.69.0 alignment + learn rename

package/extensions/ce-core/index.ts

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises"
+import path from "node:path"
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
 import { Type } from "typebox"
 import { createArtifactHelperTool, type ArtifactType } from "./tools/artifact-helper"
@@ -20,6 +22,65 @@ import { AsyncMutex } from "./tools/async-mutex"
 import type { SubagentExecOptions, SubagentRunner } from "./tools/subagent"
 
 const _subagentEnvMutex = new AsyncMutex()
+const PIPELINE_STAGE_KEYS = new Set([
+  "01-brainstorm",
+  "02-plan",
+  "03-work",
+  "04-review",
+  "05-learn",
+])
+
+interface ModelStrategySettings {
+  modelStrategy?: Record<string, string>
+}
+
+async function readProjectSettings(cwd: string): Promise<ModelStrategySettings | null> {
+  const settingsPath = path.join(cwd, ".pi", "settings.json")
+  try {
+    const content = await readFile(settingsPath, "utf8")
+    return JSON.parse(content) as ModelStrategySettings
+  } catch {
+    return null
+  }
+}
+
+function parseStageSkillName(text: string): string | null {
+  const trimmed = text.trim()
+  const match = trimmed.match(/^\/skill:([^\s]+)/)
+  if (!match) {
+    return null
+  }
+
+  const skillName = match[1]
+  return PIPELINE_STAGE_KEYS.has(skillName) ? skillName : null
+}
+
+function parseModelRef(
+  modelRef: string,
+  currentProvider?: string,
+): { provider: string, id: string } | null {
+  const trimmed = modelRef.trim()
+  if (!trimmed) {
+    return null
+  }
+
+  const slashIndex = trimmed.indexOf("/")
+  if (slashIndex > 0 && slashIndex < trimmed.length - 1) {
+    return {
+      provider: trimmed.slice(0, slashIndex),
+      id: trimmed.slice(slashIndex + 1),
+    }
+  }
+
+  if (!currentProvider) {
+    return null
+  }
+
+  return {
+    provider: currentProvider,
+    id: trimmed,
+  }
+}
 
 /**
  * Create a subagent runner that handles env injection with mutex protection
@@ -223,6 +284,62 @@ const patternExtractorParams = Type.Object({
 })
 
 export default function ceCoreExtension(pi: ExtensionAPI) {
+  pi.on("input", async (event, ctx) => {
+    if (event.source === "extension") {
+      return { action: "continue" as const }
+    }
+
+    const stageKey = parseStageSkillName(event.text)
+    if (!stageKey) {
+      return { action: "continue" as const }
+    }
+
+    const settings = await readProjectSettings(ctx.cwd)
+    const modelStrategy = settings?.modelStrategy
+    if (!modelStrategy) {
+      return { action: "continue" as const }
+    }
+
+    const targetModelRef = modelStrategy[stageKey] ?? modelStrategy.default
+    if (!targetModelRef) {
+      return { action: "continue" as const }
+    }
+
+    const parsed = parseModelRef(targetModelRef, ctx.model?.provider)
+    if (!parsed) {
+      if (ctx.hasUI) {
+        ctx.ui.notify(`Invalid modelStrategy entry for ${stageKey}: ${targetModelRef}`, "warning")
+      }
+      return { action: "continue" as const }
+    }
+
+    if (ctx.model?.provider === parsed.provider && ctx.model?.id === parsed.id) {
+      return { action: "continue" as const }
+    }
+
+    const model = ctx.modelRegistry.find(parsed.provider, parsed.id)
+    if (!model) {
+      if (ctx.hasUI) {
+        ctx.ui.notify(`Configured model not found for ${stageKey}: ${targetModelRef}`, "warning")
+      }
+      return { action: "continue" as const }
+    }
+
+    const switched = await pi.setModel(model)
+    if (switched) {
+      if (ctx.hasUI) {
+        ctx.ui.notify(`Switched model for ${stageKey}: ${model.provider}/${model.id}`, "info")
+      }
+      return { action: "continue" as const }
+    }
+
+    if (ctx.hasUI) {
+      ctx.ui.notify(`No API key available for configured model: ${model.provider}/${model.id}`, "warning")
+    }
+
+    return { action: "continue" as const }
+  })
+
   const artifactHelper = createArtifactHelperTool()
   const askUserQuestion = createAskUserQuestionTool()
   const subagent = createSubagentTool()
@@ -338,7 +455,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         details: result,
-        terminate: true,
       }
     },
   })
@@ -393,7 +509,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         details: result,
-        terminate: true,
       }
     },
   })
@@ -449,7 +564,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         details: result,
-        terminate: true,
       }
     },
   })
@@ -489,7 +603,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         details: result,
-        terminate: true,
       }
     },
   })
@@ -531,7 +644,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         details: result,
-        terminate: true,
       }
     },
   })
@@ -553,7 +665,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         details: result,
-        terminate: true,
       }
     },
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "private": false,
   "type": "module",
   "description": "Pi-native Compound Engineering package for iterative development workflows",

package/skills/references/pipeline-config.md

@@ -4,21 +4,21 @@ Use these rules in all Phase 1 skills: `01-brainstorm` → `02-plan` → `03-wor
 
 ## Start of skill: model routing
 
-Run this checklist before normal skill workflow:
-
-1. Read `.pi/settings.json` from the project root.
-2. Parse `modelStrategy` (if missing, skip switching).
-3. Resolve current stage key:
-   - `01-brainstorm`
-   - `02-plan`
-   - `03-work`
-   - `04-review`
-   - `05-learn`
-4. Pick `targetModel = modelStrategy[stageKey] ?? modelStrategy.default`.
-5. If `targetModel` exists and differs from the current model, run `/model <targetModel>`.
-6. If switching fails, continue with current model and mention the failure once.
-
-## End of skill: status + context + optional auto-continue
+Model routing is handled automatically by the ce-core extension's `input` hook.
+When a user types `/skill:01-brainstorm` through `/skill:05-learn`, the extension:
+
+1. Reads `.pi/settings.json` from the project root.
+2. Parses `modelStrategy[stageKey]` or falls back to `modelStrategy.default`.
+3. If the target model differs from the current model, calls `pi.setModel()`.
+4. If switching fails, notifies the user and continues with the current model.
+
+No manual `/model` command is needed. The skill itself does not need to handle model switching.
+
+Supported `modelStrategy` formats in `.pi/settings.json`:
+- Full reference: `"02-plan": "anthropic/claude-opus-4-1"`
+- Bare model id (reuses current provider): `"02-plan": "claude-opus-4-1"`
+
+## End of skill: status + context
 
 Before final completion, always output these blocks (replace placeholders with real values, never output angle-bracket placeholders literally):
 
@@ -45,16 +45,6 @@ Next step mapping:
 - `04-review` → `/skill:05-learn`
 - `05-learn` → `Completed`
 
-Then read `.pi/settings.json` → `pipeline.autoContinue`:
-- If `false` or missing, stop after the status block and wait for user input.
-- If current stage is `05-learn`, stop after status block.
-- If `true` and current stage is not `05-learn`, auto-continue is allowed only after stage-specific gates are satisfied:
-  - `01-brainstorm`: user has explicitly approved the design handoff.
-  - `02-plan`: review choice is resolved (A/B/C flow completed) and user confirmed to proceed.
-  - `04-review`: optional QA choice is resolved (A/B/C flow completed) and user confirmed to proceed.
-  - Any unclear/ambiguous state: do not auto-continue; stop and ask.
-- When gates are satisfied, automatically trigger the mapped next skill command.
-
 ### Handoff-lite template
 
 When a stage produces or updates handoff-lite, use this evidence-first structure and keep it concise (target <= 1500 tokens):