@leing2021/super-pi 0.23.13 → 0.25.0

package/extensions/ce-core/tools/ask-user-question.ts

@@ -14,7 +14,70 @@ export interface AskUserQuestionResult {
   mode: "input" | "select" | "custom" | "cancelled"
 }
 
-const CUSTOM_OPTION = "Other"
+/** Sentinel label used to offer a free-text custom answer. */
+export const CUSTOM_SENTINEL = "Other"
+
+/**
+ * Maximum display width for a normalized option label. Long labels overflow the
+ * selector row in the built-in `ctx.ui.select()` renderer (see
+ * `docs/bug/ask-user-question-long-options-truncated.md`), so labels are kept
+ * to a single line and truncated to this width.
+ */
+export const MAX_OPTION_LABEL_WIDTH = 60
+
+/**
+ * Build the single-line display label for one option.
+ *
+ * Rules:
+ * - Take only the first line (drop embedded `\n`).
+ * - Trim surrounding whitespace.
+ * - Truncate to {@link MAX_OPTION_LABEL_WIDTH} with an ellipsis when needed.
+ */
+export function toOptionDisplayLabel(option: string): string {
+  const firstLine = option.split("\n", 1)[0] ?? ""
+  const trimmed = firstLine.trim()
+  if (trimmed.length <= MAX_OPTION_LABEL_WIDTH) {
+    return trimmed
+  }
+  return trimmed.slice(0, MAX_OPTION_LABEL_WIDTH - 1) + "…"
+}
+
+/**
+ * Build display labels for all options, disambiguating collisions with a
+ * numeric suffix so the selector never shows two identical rows.
+ *
+ * @returns A map from display label back to the original full option string.
+ *          When collisions exist, labels become `<label> (#<n>)`.
+ */
+export function normalizeQuestionOptions(options: string[]): Map<string, string> {
+  const labelToOriginal = new Map<string, string>()
+  const labelCounts = new Map<string, number>()
+
+  for (const original of options) {
+    const baseLabel = toOptionDisplayLabel(original)
+    const count = (labelCounts.get(baseLabel) ?? 0) + 1
+    labelCounts.set(baseLabel, count)
+
+    const label = count === 1 ? baseLabel : `${baseLabel} (#${count})`
+    // Guard against the extremely unlikely suffix collision by re-checking.
+    const finalLabel = labelToOriginal.has(label) ? `${label} (#${count})` : label
+    labelToOriginal.set(finalLabel, original)
+  }
+
+  return labelToOriginal
+}
+
+/** Choose a display label for the custom-answer sentinel that never collides. */
+export function resolveCustomSentinelLabel(labelToOriginal: Map<string, string>): string {
+  if (!labelToOriginal.has(CUSTOM_SENTINEL)) {
+    return CUSTOM_SENTINEL
+  }
+  let index = 2
+  while (labelToOriginal.has(`${CUSTOM_SENTINEL} (#${index})`)) {
+    index += 1
+  }
+  return `${CUSTOM_SENTINEL} (#${index})`
+}
 
 export function createAskUserQuestionTool() {
   return {
@@ -33,21 +96,31 @@ export function createAskUserQuestionTool() {
       }
 
       const allowCustom = input.allowCustom ?? true
-      const selectOptions = allowCustom ? [...options, CUSTOM_OPTION] : options
-      const selected = await ui.select(input.question, selectOptions)
+      const labelToOriginal = normalizeQuestionOptions(options)
+      const customLabel = allowCustom
+        ? resolveCustomSentinelLabel(labelToOriginal)
+        : null
+      const displayOptions = customLabel
+        ? [...labelToOriginal.keys(), customLabel]
+        : [...labelToOriginal.keys()]
+
+      const selected = await ui.select(input.question, displayOptions)
 
       if (selected === null) {
         return { answer: null, mode: "cancelled" }
       }
 
-      if (allowCustom && selected === CUSTOM_OPTION) {
+      if (allowCustom && customLabel && selected === customLabel) {
         const customAnswer = await ui.input("Your answer")
         return customAnswer === null
           ? { answer: null, mode: "cancelled" }
           : { answer: customAnswer, mode: "custom" }
       }
 
-      return { answer: selected, mode: "select" }
+      return {
+        answer: labelToOriginal.get(selected) ?? selected,
+        mode: "select",
+      }
     },
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.23.13",
+  "version": "0.25.0",
   "private": false,
   "type": "module",
   "description": "Pi-native Compound Engineering package for iterative development workflows",
@@ -35,11 +35,11 @@
     "test": "bun test"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": ">=0.69.0",
+    "@earendil-works/pi-coding-agent": ">=0.74.0",
     "typebox": ">=1.0.0"
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "0.69.0",
+    "@earendil-works/pi-coding-agent": "^0.76.0",
     "bun-types": "^1.3.12"
   },
   "pi": {

package/skills/02-plan/references/ceo-review-mode.md

@@ -23,7 +23,7 @@ Re-examine the plan's assumptions:
 - What is the actual user/business outcome? Is the plan the most direct path?
 - What happens if we do nothing? Real pain or hypothetical?
 
-Present findings as premises the user must agree with. Use `ask_user_question` for each.
+Present findings as premises the user must agree with. Use `ask_user_question` for each — **one at a time, sequentially** (never two `ask_user_question` calls in the same assistant message; Pi selectors are serialized and parallel calls silently fail).
 
 ### 2. Dream State Mapping
 

package/skills/03-work/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: 03-work
-description: "Execute plan units with parallel subagents, TDD enforcement, and checkpoint resume. Use when a plan path is ready for implementation."
+description: "Execute plan units with TDD enforcement and checkpoint resume. Use when a plan path is ready for implementation."
 ---
 
 # Work
@@ -19,16 +19,14 @@ See [shared pipeline instructions](../references/pipeline-config.md) for model r
 2. **Priority:** project-level `{repo-root}/rules/` overrides package defaults
 3. **Distinguish input:** plan path vs bare prompt
 4. Derive tasks from plan **implementation units**
-5. **Execution mode:**
-   - **Inline mode** is the default execution path
-   - **`ce_parallel_subagent`** only for bounded, non-interactive, easily verifiable leaf tasks
-   - **`ce_subagent`** only for rare dependent serial chains of leaf tasks
-   - Never use either tool to invoke pipeline-stage skills (`01-brainstorm through 05-learn`). Run those stages directly with `/skill:<stage>`.
+5. **Execution mode:** **inline mode** — all plan units execute inline in the current session. No built-in subagent tools.
 6. Use **`session_checkpoint`** to track progress and enable resume
 7. Use **`task_splitter`** to analyze dependencies before execution
 8. If in **worktree** (via `07-worktree`), execute inside it
 9. End by recommending `04-review`
 
+> **Advanced:** If you need external child agent delegation (background runs, parallel audits), install `pi-subagents` separately. Super Pi does not require it.
+
 ## Hard gates — TDD enforcement
 
 Every step follows **RED → GREEN → REFACTOR**:
@@ -76,7 +74,7 @@ If the same tool, command, or implementation unit fails 3 consecutive times, sto
 3. Read implementation units if plan path
 4. Load `session_checkpoint` to skip completed units
 5. Use `task_splitter` for dependency analysis
-6. Execute: **inline mode** by default; use subagents only for bounded, non-interactive, easily verifiable leaf tasks
+6. Execute: **inline mode** — all units run in the current session
 7. Follow TDD per unit: RED → minimal code → GREEN → refactor → unit-level **verification**
 8. **Source-driven gate:** Before implementing framework/library-specific code, verify the API or pattern against official documentation. Flag unverified patterns as UNVERIFIED in output.
 9. Record progress via `references/progress-update-format.md`

package/extensions/ce-core/tools/async-mutex.ts

@@ -1,28 +0,0 @@
-/**
- * Async mutex for serializing critical sections that mutate shared state
- * (e.g. process.env) across concurrent async operations.
- */
-export class AsyncMutex {
-  private queue: (() => void)[] = []
-  private locked = false
-
-  async acquire(): Promise<() => void> {
-    return new Promise<() => void>((resolve) => {
-      const tryAcquire = () => {
-        if (!this.locked) {
-          this.locked = true
-          resolve(() => this.release())
-        } else {
-          this.queue.push(tryAcquire)
-        }
-      }
-      tryAcquire()
-    })
-  }
-
-  private release(): void {
-    this.locked = false
-    const next = this.queue.shift()
-    if (next) next()
-  }
-}

package/extensions/ce-core/tools/parallel-subagent.ts

@@ -1,196 +0,0 @@
-/**
- * CE parallel subagent tool — runs multiple CE skill-based subagent tasks concurrently.
- *
- * Features:
- *   - Recursion depth guard (PI_SUBAGENT_DEPTH / PI_SUBAGENT_MAX_DEPTH)
- *   - Optional context slimming via --no-skills flag
- *   - Concurrency limit via mapWithConcurrencyLimit (from pi official example)
- *   - Live TUI updates with running placeholders and per-task status
- *   - Promise.allSettled semantics: one failure does NOT cancel others
- */
-
-import {
-  checkSubagentDepth,
-  getChildDepthEnv,
-} from "./subagent-depth-guard"
-import {
-  type SingleResult,
-  makeInitialResult,
-  isFailedResult,
-  getFinalOutput,
-  makeFailedResult,
-  invokeRunner,
-  type AnyRunner,
-} from "./subagent-events"
-import {
-  assertNonPipelineStageSkill,
-  type SubagentLiveRunner,
-  type SubagentLiveExecOptions,
-  type SubagentRunner,
-} from "./subagent"
-
-// ---------------------------------------------------------------------------
-// Constants (from pi official example)
-// ---------------------------------------------------------------------------
-
-const MAX_PARALLEL_TASKS = 8
-const MAX_CONCURRENCY = 4
-
-// ---------------------------------------------------------------------------
-// mapWithConcurrencyLimit (directly from pi official subagent example)
-// ---------------------------------------------------------------------------
-
-async function mapWithConcurrencyLimit<TIn, TOut>(
-  items: TIn[],
-  concurrency: number,
-  fn: (item: TIn, index: number) => Promise<TOut>,
-): Promise<TOut[]> {
-  if (items.length === 0) return []
-  const limit = Math.max(1, Math.min(concurrency, items.length))
-  const results: TOut[] = new Array(items.length)
-  let nextIndex = 0
-  const workers = new Array(limit).fill(null).map(async () => {
-    while (true) {
-      const current = nextIndex++
-      if (current >= items.length) return
-      results[current] = await fn(items[current], current)
-    }
-  })
-  await Promise.all(workers)
-  return results
-}
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-export interface ParallelSubagentTask {
-  agent: string
-  task: string
-}
-
-export interface ParallelSubagentInput {
-  tasks: ParallelSubagentTask[]
-  /** Whether subagents should inherit skills. Default: true */
-  inheritSkills?: boolean
-}
-
-export interface ParallelSubagentLiveDetails {
-  mode: "parallel"
-  results: SingleResult[]
-}
-
-// ---------------------------------------------------------------------------
-// Tool factory
-// ---------------------------------------------------------------------------
-
-export function createParallelSubagentTool() {
-  return {
-    name: "ce_parallel_subagent" as const,
-
-    async execute(
-      input: ParallelSubagentInput,
-      runner: SubagentLiveRunner | SubagentRunner,
-      toolCtx?: { onUpdate?: (details: ParallelSubagentLiveDetails) => void },
-    ): Promise<ParallelSubagentLiveDetails> {
-      // Recursion depth guard
-      const depthCheck = checkSubagentDepth()
-      if (!depthCheck.allowed) {
-        throw new Error(depthCheck.reason!)
-      }
-
-      if (!input.tasks || input.tasks.length === 0) {
-        throw new Error("ce_parallel_subagent requires at least one task")
-      }
-
-      if (input.tasks.length > MAX_PARALLEL_TASKS) {
-        throw new Error(
-          `Too many parallel tasks (${input.tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`,
-        )
-      }
-
-      for (const task of input.tasks) {
-        assertNonPipelineStageSkill(task.agent, "ce_parallel_subagent")
-      }
-
-      const execOptions = buildParallelExecOptions(input.inheritSkills)
-
-      // Initialize all results as running placeholders
-      const allResults: SingleResult[] = input.tasks.map(({ agent, task }) =>
-        makeInitialResult(agent, task),
-      )
-
-      // Emit initial state (all running)
-      emitParallelUpdate(allResults, toolCtx)
-
-      // Run tasks with concurrency limit
-      await mapWithConcurrencyLimit(input.tasks, MAX_CONCURRENCY, async (t, index) => {
-        const liveOptions: SubagentLiveExecOptions = {
-          ...execOptions,
-          onUpdate: (partial: SingleResult) => {
-            allResults[index] = partial
-            emitParallelUpdate(allResults, toolCtx)
-          },
-        }
-
-        try {
-          const result = await invokeRunner(runner, `/skill:${t.agent} ${t.task}`, liveOptions)
-          allResults[index] = result
-        } catch (e) {
-          // Preserve allSettled semantics: one failure does not cancel others
-          allResults[index] = makeFailedResult(t.agent, t.task, e instanceof Error ? e.message : String(e))
-        }
-        emitParallelUpdate(allResults, toolCtx)
-        return allResults[index]
-      })
-
-      return { mode: "parallel", results: allResults }
-    },
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function emitParallelUpdate(
-  results: SingleResult[],
-  toolCtx?: { onUpdate?: (details: ParallelSubagentLiveDetails) => void },
-) {
-  if (toolCtx?.onUpdate) {
-    toolCtx.onUpdate({ mode: "parallel", results: [...results] })
-  }
-}
-
-function buildParallelExecOptions(inheritSkills?: boolean): { extraFlags?: string[]; extraEnv: Record<string, string> } {
-  const flags: string[] = []
-  const env: Record<string, string> = {}
-
-  if (inheritSkills === false) {
-    flags.push("--no-skills")
-  }
-
-  Object.assign(env, getChildDepthEnv())
-
-  return {
-    extraFlags: flags.length > 0 ? flags : undefined,
-    extraEnv: env,
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Legacy backward-compat types and exports
-// ---------------------------------------------------------------------------
-
-/** @deprecated Use ParallelSubagentLiveDetails instead */
-export interface ParallelResultItem {
-  status: "fulfilled" | "rejected"
-  value?: string
-  reason?: string
-}
-
-/** @deprecated Use ParallelSubagentLiveDetails instead */
-export interface ParallelSubagentResult {
-  mode: "parallel"
-  outputs: ParallelResultItem[]
-}

package/extensions/ce-core/tools/subagent-depth-guard.ts

@@ -1,86 +0,0 @@
-/**
- * Subagent recursion depth guard.
- *
- * Prevents uncontrolled recursive subagent spawning by tracking depth
- * via environment variables. Inspired by pi-subagents' depth control
- * but implemented as a minimal, standalone module.
- *
- * Environment variables:
- *   PI_SUBAGENT_DEPTH     — current nesting depth (default: 0)
- *   PI_SUBAGENT_MAX_DEPTH — maximum allowed depth (default: 2)
- */
-
-/** Default maximum subagent nesting depth */
-export const DEFAULT_MAX_SUBAGENT_DEPTH = 2
-
-/**
- * Read the current subagent depth from environment.
- * Returns 0 if unset or invalid.
- */
-export function getCurrentDepth(): number {
-  const raw = process.env.PI_SUBAGENT_DEPTH
-  if (!raw) return 0
-  const depth = parseInt(raw, 10)
-  return Number.isNaN(depth) ? 0 : depth
-}
-
-/**
- * Read the maximum allowed depth from environment.
- * Falls back to DEFAULT_MAX_SUBAGENT_DEPTH if unset or invalid.
- */
-export function getMaxDepth(): number {
-  const raw = process.env.PI_SUBAGENT_MAX_DEPTH
-  if (!raw) return DEFAULT_MAX_SUBAGENT_DEPTH
-  const max = parseInt(raw, 10)
-  return Number.isNaN(max) || max < 0 ? DEFAULT_MAX_SUBAGENT_DEPTH : max
-}
-
-/**
- * Check whether subagent execution is allowed at the current depth.
- * Returns an object with:
- *   allowed — whether execution can proceed
- *   depth   — the current depth
- *   max     — the maximum depth
- *   reason  — human-readable explanation if blocked
- */
-export function checkSubagentDepth(): {
-  allowed: boolean
-  depth: number
-  max: number
-  reason?: string
-} {
-  const depth = getCurrentDepth()
-  const max = getMaxDepth()
-
-  if (depth >= max) {
-    return {
-      allowed: false,
-      depth,
-      max,
-      reason: `Subagent recursion depth limit reached (depth=${depth}, max=${max}). ` +
-        `Set PI_SUBAGENT_MAX_DEPTH to increase the limit.`,
-    }
-  }
-
-  return { allowed: true, depth, max }
-}
-
-/**
- * Build environment variables to pass to a child subagent process.
- * Increments the depth counter so the child can guard its own spawns.
- *
- * @param overrides — optional overrides for max depth per-agent
- */
-export function getChildDepthEnv(overrides?: {
-  maxDepth?: number
-}): Record<string, string> {
-  const currentDepth = getCurrentDepth()
-  const childDepth = currentDepth + 1
-  let maxDepth = overrides?.maxDepth ?? getMaxDepth()
-  if (maxDepth < 0) maxDepth = DEFAULT_MAX_SUBAGENT_DEPTH
-
-  return {
-    PI_SUBAGENT_DEPTH: String(childDepth),
-    PI_SUBAGENT_MAX_DEPTH: String(maxDepth),
-  }
-}