@leing2021/super-pi 0.19.2 → 0.19.4

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
 
 ---
 
@@ -180,7 +178,7 @@ Single `npm install` output filtered once pays for the entire overhead. Full eva
 
 ## Code Scale
 
-~2800 lines of TypeScript implementing 16 tools, 22 Markdown reference files + 78 rule files driving 10 skills, 170 tests covering all tool logic.
+~2800 lines of TypeScript implementing 16 tools, 22 Markdown reference files + 78 rule files driving 10 skills, 175 tests covering all tool logic.
 
 Not a heavy framework. Each tool has a single responsibility, each skill works independently, and together they form a complete workflow.
 
@@ -383,6 +381,20 @@ Not a fork. Not a wrapper. Methodologies extracted and rebuilt with Pi's native
 
 ## Changelog
 
+### 0.19.4 — Read output filter markdown truncation fix
+- Fixed `read-output-filter` over-truncating markdown files: raised markdown threshold from 2KB → 8KB.
+- Improved `filterMarkdown()` to fully preserve list items (`-`, `*`, numbered) and keep first 3 lines of paragraphs (was 1).
+- Filter notice now includes actual file path in actionable guidance (`bash cat <path>`).
+- Added 5 new tests covering list preservation, markdown threshold gate, and path-in-notice.
+- 175 tests passing.
+
+### 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 +403,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/extensions/ce-core/tools/read-output-filter.ts

@@ -9,7 +9,7 @@
 // 1. Lock / generated files → extreme compression (summary only)
 // 2. package.json → keep scripts + dep summary, drop full version lists
 // 3. Large code files → keep signatures/structure, collapse bodies
-// 4. Large markdown → keep headings + first paragraph per section
+// 4. Large markdown → keep headings + code blocks + lists + expanded paragraphs per section
 // 5. Generic → head/tail truncation for very large files
 
 // ============================================================================
@@ -93,6 +93,9 @@ function classifyFile(path: string): FileCategory {
 /** Minimum output size (bytes) to trigger any filtering */
 const MIN_FILTER_THRESHOLD = 2048 // 2KB
 
+/** Minimum output size (bytes) to trigger markdown filtering */
+const MARKDOWN_FILTER_THRESHOLD = 8192 // 8KB — markdown docs are dense, don't filter small ones
+
 /** Maximum size for structural code compression trigger */
 const CODE_COMPRESS_THRESHOLD = 8192 // 8KB
 
@@ -308,6 +311,9 @@ function filterMarkdown(output: string): string {
   let inParagraph = false
   let paragraphLineCount = 0
   let inCodeBlock = false
+  let omitMarkerPlaced = false
+
+  const MAX_PARAGRAPH_LINES = 3 // Keep first N lines of each paragraph (vs 1 before)
 
   for (const line of lines) {
     const trimmed = line.trim()
@@ -322,6 +328,7 @@ function filterMarkdown(output: string): string {
     // Keep all lines inside code blocks
     if (inCodeBlock) {
       kept.push(line)
+      omitMarkerPlaced = false
       continue
     }
 
@@ -330,27 +337,43 @@ function filterMarkdown(output: string): string {
       kept.push(line)
       inParagraph = false
       paragraphLineCount = 0
+      omitMarkerPlaced = false
       continue
     }
 
-    // Empty lines
+    // Empty lines — reset paragraph state
     if (trimmed === "") {
       kept.push(line)
       inParagraph = false
       paragraphLineCount = 0
+      omitMarkerPlaced = false
+      continue
+    }
+
+    // Always keep list items (-, *, numbered) — they often contain key definitions
+    if (/^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed)) {
+      kept.push(line)
+      omitMarkerPlaced = false
+      // List items don't count as paragraph continuation
       continue
     }
 
-    // Keep first paragraph line after heading, skip the rest
+    // Keep first N lines of each paragraph
     if (!inParagraph) {
       kept.push(line)
       inParagraph = true
       paragraphLineCount = 1
+      omitMarkerPlaced = false
     } else {
       paragraphLineCount++
-      // Skip subsequent paragraph lines
-      if (paragraphLineCount === 2) {
-        kept.push(`  [... additional paragraph content omitted]`)
+      if (paragraphLineCount <= MAX_PARAGRAPH_LINES) {
+        kept.push(line)
+      } else {
+        // Place omit marker once per paragraph
+        if (!omitMarkerPlaced) {
+          kept.push(`  [... additional paragraph content omitted]`)
+          omitMarkerPlaced = true
+        }
       }
     }
   }
@@ -400,9 +423,11 @@ function appendFilterNotice(
   originalBytes: number,
   filteredBytes: number,
   strategy: string,
+  path?: string,
 ): string {
   const saved = formatBytes(originalBytes - filteredBytes)
-  return `${output}\n\n[Read output filtered: ${formatBytes(originalBytes)} → ${formatBytes(filteredBytes)} (${saved} saved, strategy: ${strategy})]`
+  const pathHint = path ? `: bash cat ${path}` : ": bash cat <path>"
+  return `${output}\n\n[Read output filtered: ${formatBytes(originalBytes)} → ${formatBytes(filteredBytes)} (${saved} saved, strategy: ${strategy}). If you need the full content, use${pathHint}]`
 }
 
 // ============================================================================
@@ -464,8 +489,12 @@ export function filterReadOutput(input: ReadOutputFilterInput): ReadOutputFilter
       break
 
     case "markdown":
-      filtered = filterMarkdown(output)
-      strategyName = "markdown (headings + first paragraph)"
+      if (originalBytes >= MARKDOWN_FILTER_THRESHOLD) {
+        filtered = filterMarkdown(output)
+        strategyName = "markdown (headings + code + lists + expanded paragraphs)"
+      } else {
+        return { output, filtered: false, originalBytes, filteredBytes: originalBytes, strategy: "none (markdown below 8KB threshold)" }
+      }
       break
 
     case "config":
@@ -497,7 +526,7 @@ export function filterReadOutput(input: ReadOutputFilterInput): ReadOutputFilter
   }
 
   return {
-    output: appendFilterNotice(filtered, originalBytes, filteredBytes, strategyName),
+    output: appendFilterNotice(filtered, originalBytes, filteredBytes, strategyName, path),
     filtered: true,
     originalBytes,
     filteredBytes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.19.2",
+  "version": "0.19.4",
   "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):