@leing2021/super-pi 0.23.13 → 0.24.0

package/README.md

@@ -73,18 +73,22 @@ You: /skill:03-work docs/plans/plan.md
 |-------|-------------|-----------|
 | **01-brainstorm** | Structured multi-round discovery, domain vocabulary persistence | `brainstorm_dialog` |
 | **02-plan** | TDD-gated implementation units, optional CEO Review | `plan_diff` |
-| **03-work** | Inline-first execution, bounded subagents, checkpoint resume, strict TDD, stop-the-line | `ce_subagent`, `ce_parallel_subagent` |
+| **03-work** | Inline-first execution, checkpoint resume, strict TDD, stop-the-line | `session_checkpoint`, `task_splitter` |
 | **04-review** | Auto-assigned reviewers, five-axis findings, autofix loop | `review_router` |
 | **05-learn** | Pattern extraction → searchable solution artifacts | `pattern_extractor` |
 | **06-next** | Next-step recommendation + workflow status | `workflow_state` |
 | **07-worktree** | Isolated git worktree development | `worktree_manager` |
 | **08-help** | Phase 1 skill explainer | — |
 
-### Subagent tool namespace
+### Optional: External subagent delegation
 
-Super Pi ships CE-specific tools named `ce_subagent` and `ce_parallel_subagent`. They are intentionally namespaced so they can coexist with the compatible third-party `pi-subagents` extension without tool-name collisions.
+For generic child agent delegation (background jobs, parallel audits, scout/worker/oracle agents), install the community extension `pi-subagents` separately. Super Pi does not require it.
 
-These tools are helpers, not the core workflow. Use inline execution by default. Use CE subagents only for bounded, non-interactive, easily verifiable leaf tasks. Do not use them to invoke pipeline-stage skills (`01-brainstorm` through `05-learn`); run those stages directly with `/skill:<stage>`.
+```bash
+pi install npm:pi-subagents
+```
+
+Super Pi focuses on inline workflow execution. Use subagents only when you need true process isolation or background runs.
 
 ### Model & Thinking Routing
 

package/extensions/ce-core/index.ts

@@ -1,14 +1,12 @@
 import { readFile } from "node:fs/promises"
 import path from "node:path"
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import { Type } from "typebox"
 import { createArtifactHelperTool, type ArtifactType } from "./tools/artifact-helper"
 import { createAskUserQuestionTool } from "./tools/ask-user-question"
-import { createSubagentTool } from "./tools/subagent"
 import { createWorkflowStateTool } from "./tools/workflow-state"
 import { createWorktreeManagerTool } from "./tools/worktree-manager"
 import { createReviewRouterTool } from "./tools/review-router"
-import { createParallelSubagentTool } from "./tools/parallel-subagent"
 import { createSessionCheckpointTool } from "./tools/session-checkpoint"
 import { createTaskSplitterTool } from "./tools/task-splitter"
 import { createBrainstormDialogTool } from "./tools/brainstorm-dialog"
@@ -19,11 +17,6 @@ import { createContextHandoffTool } from "./tools/context-handoff"
 import { filterBashOutput } from "./tools/bash-output-filter"
 import { filterReadOutput } from "./tools/read-output-filter"
 import { COMPACTION_FOCUS_INSTRUCTIONS } from "./tools/compaction-optimizer"
-import { createJsonRunner, type JsonRunConfig } from "./tools/subagent-json-runner"
-import { getFinalOutput, isFailedResult, type SingleResult } from "./tools/subagent-events"
-import { renderSubagentCall, renderSubagentResult } from "./tools/subagent-renderer"
-import type { SubagentLiveRunner, SubagentLiveExecOptions, SubagentLiveDetails } from "./tools/subagent"
-import type { ParallelSubagentLiveDetails } from "./tools/parallel-subagent"
 
 const PIPELINE_STAGE_KEYS = new Set([
   "01-brainstorm",
@@ -116,34 +109,6 @@ function parseModelRef(
   }
 }
 
-/**
- * Create a spawn-based subagent runner that uses pi --mode json
- * with per-process env (no global process.env mutation).
- */
-function createSubagentRunner(
-  pi: ExtensionAPI,
-  signal?: AbortSignal,
-): SubagentLiveRunner {
-  const jsonRunner = createJsonRunner()
-  return async (prompt: string, options?: SubagentLiveExecOptions) => {
-    const config: JsonRunConfig = {
-      prompt,
-      agent: "",
-      task: "",
-      cwd: (pi as any).cwd ?? process.cwd(),
-      extraFlags: options?.extraFlags,
-      extraEnv: options?.extraEnv,
-      signal,
-      onUpdate: options?.onUpdate,
-    }
-    const result = await jsonRunner.run(config)
-    if (isFailedResult(result) || result.exitCode !== 0) {
-      throw new Error(result.errorMessage || result.stderr || `Subagent failed for prompt: ${prompt}`)
-    }
-    return result
-  }
-}
-
 const artifactHelperParams = Type.Object({
   repoRoot: Type.String({ description: "Repository root where workflow artifacts should be created" }),
   artifactType: Type.Union([
@@ -166,18 +131,6 @@ const askUserQuestionParams = Type.Object({
   allowCustom: Type.Optional(Type.Boolean({ description: "Allow a custom answer when options are present" })),
 })
 
-const subagentTaskSchema = Type.Object({
-  agent: Type.String({ description: "Skill name to invoke via /skill:<name>" }),
-  task: Type.String({ description: "Task text passed to the subagent" }),
-})
-
-const subagentParams = Type.Object({
-  agent: Type.Optional(Type.String({ description: "Single subagent skill name" })),
-  task: Type.Optional(Type.String({ description: "Single subagent task" })),
-  chain: Type.Optional(Type.Array(subagentTaskSchema, { description: "Serial subagent chain with optional {previous} placeholder" })),
-  inheritSkills: Type.Optional(Type.Boolean({ description: "Whether the subagent should inherit skills. Default: true" })),
-})
-
 const workflowStateParams = Type.Object({
   repoRoot: Type.String({ description: "Repository root to scan for workflow artifacts" }),
 })
@@ -200,19 +153,6 @@ const reviewRouterParams = Type.Object({
   deletions: Type.Number({ description: "Number of lines removed" }),
 })
 
-const parallelSubagentTaskSchema = Type.Object({
-  agent: Type.String({ description: "Skill name to invoke via /skill:<name>" }),
-  task: Type.String({ description: "Task text passed to the subagent" }),
-})
-
-const parallelSubagentParams = Type.Object({
-  tasks: Type.Union([
-    Type.Array(parallelSubagentTaskSchema),
-    Type.String({ description: "JSON stringified array of tasks" }),
-  ], { description: "Array of independent tasks to run concurrently (can be a JSON string)" }),
-  inheritSkills: Type.Optional(Type.Boolean({ description: "Whether subagents should inherit skills. Default: true" })),
-})
-
 const sessionCheckpointParams = Type.Object({
   operation: Type.Union([
     Type.Literal("save"),
@@ -346,9 +286,18 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return { action: "continue" as const }
     }
 
+    // Skip model/thinking switching during streaming steers — these are
+    // mid-stream interrupts, not new pipeline invocations.
+    if (event.streamingBehavior === "steer") {
+      return { action: "continue" as const }
+    }
+
     const settings = await readSettings(ctx.cwd)
     const modelStrategy = settings?.modelStrategy
     const thinkingStrategy = settings?.thinkingStrategy
+    // Notification guard: only notify in interactive (TUI) or RPC modes.
+    // For interactive input capability checks (askUserQuestion), use ctx.hasUI directly.
+    const shouldNotify = ctx.mode === "tui" || ctx.mode === "rpc"
 
     // Model switching
     if (modelStrategy) {
@@ -362,19 +311,19 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
             if (model) {
               const switched = await pi.setModel(model)
               if (switched) {
-                if (ctx.hasUI) {
+                if (shouldNotify) {
                   ctx.ui.notify(`Switched model for ${stageKey}: ${model.provider}/${model.id}`, "info")
                 }
               } else {
-                if (ctx.hasUI) {
+                if (shouldNotify) {
                   ctx.ui.notify(`No API key for ${stageKey}: ${model.provider}/${model.id}`, "warning")
                 }
               }
-            } else if (ctx.hasUI) {
+            } else if (shouldNotify) {
               ctx.ui.notify(`Model not found for ${stageKey}: ${targetModelRef}`, "warning")
             }
           }
-        } else if (ctx.hasUI) {
+        } else if (shouldNotify) {
           ctx.ui.notify(`Invalid modelStrategy for ${stageKey}: ${targetModelRef}`, "warning")
         }
       }
@@ -399,7 +348,7 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
         const currentLevel = pi.getThinkingLevel()
         if (currentLevel !== normalized) {
           pi.setThinkingLevel(normalized)
-          if (ctx.hasUI) {
+          if (shouldNotify) {
             ctx.ui.notify(`Switched thinking level for ${stageKey}: ${normalized}`, "info")
           }
         }
@@ -411,11 +360,9 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
 
   const artifactHelper = createArtifactHelperTool()
   const askUserQuestion = createAskUserQuestionTool()
-  const subagent = createSubagentTool()
   const workflowState = createWorkflowStateTool()
   const worktreeManager = createWorktreeManagerTool()
   const reviewRouter = createReviewRouterTool()
-  const parallelSubagent = createParallelSubagentTool()
   const sessionCheckpoint = createSessionCheckpointTool()
   const taskSplitter = createTaskSplitterTool()
   const brainstormDialog = createBrainstormDialogTool()
@@ -489,45 +436,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     },
   })
 
-  pi.registerTool({
-    name: subagent.name,
-    label: "CE Subagent",
-    description: "Run a single CE skill-based subagent or a serial chain in an isolated Pi process.",
-    parameters: subagentParams,
-    async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      const result = await subagent.execute(
-        {
-          agent: params.agent,
-          task: params.task,
-          chain: params.chain,
-          inheritSkills: params.inheritSkills,
-        },
-        createSubagentRunner(pi, signal),
-        { onUpdate: onUpdate ? (details) => onUpdate({ content: [], details }) : undefined },
-      )
-
-      // Build final content from results
-      const lastResult = result.results[result.results.length - 1]
-      const finalText = lastResult ? getFinalOutput(lastResult.messages) : ""
-      const isError = lastResult ? isFailedResult(lastResult) : false
-
-      return {
-        content: [{ type: "text", text: finalText || "(no output)" }],
-        details: result,
-        isError: isError || undefined,
-      }
-    },
-    renderCall(args, theme, _context) {
-      return renderSubagentCall(args, theme)
-    },
-    renderResult(result, renderContext, theme, _context) {
-      // Handle partial updates where data is at top level (from onUpdate)
-      // rather than nested in .details (from final result return value)
-      const data = (result.details || result) as SubagentLiveDetails
-      return renderSubagentResult(data, renderContext, theme)
-    },
-  })
-
   pi.registerTool({
     name: workflowState.name,
     label: "Workflow State",
@@ -599,73 +507,6 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     },
   })
 
-  pi.registerTool({
-    name: parallelSubagent.name,
-    label: "CE Parallel Subagent",
-    description: "Run multiple CE skill-based subagent tasks concurrently. IMPORTANT: Provide 'tasks' as a clean JSON array object. If the environment forces a string, provide a valid JSON array string.",
-    parameters: parallelSubagentParams,
-    async execute(_toolCallId, params, signal, onUpdate) {
-      let tasks: any[]
-      if (typeof params.tasks === "string") {
-        try {
-          const cleaned = params.tasks.replace(/^```json\s*|```$/g, "").trim()
-          tasks = JSON.parse(cleaned)
-        } catch (e) {
-          throw new Error(`Failed to parse tasks string as JSON: ${e instanceof Error ? e.message : String(e)}`)
-        }
-      } else {
-        tasks = params.tasks
-      }
-
-      const result = await parallelSubagent.execute(
-        {
-          tasks,
-          inheritSkills: params.inheritSkills,
-        },
-        createSubagentRunner(pi, signal),
-        { onUpdate: onUpdate ? (details) => onUpdate({ content: [], details }) : undefined },
-      )
-
-      // Build compact summary content for LLM consumption
-      const successCount = result.results.filter(r => r.exitCode === 0).length
-      const failCount = result.results.filter(r => isFailedResult(r)).length
-      const summaries = result.results.map((r, i) => {
-        const icon = isFailedResult(r) ? "✗" : "✓"
-        const output = getFinalOutput(r.messages) || r.errorMessage || r.stderr || "(no output)"
-        // Compact: first non-empty line, stripped of markdown formatting
-        const summaryLine = output.split("\n").find((l: string) => l.trim().length > 0) || ""
-        const cleaned = summaryLine.replace(/^#+\s*/, "").replace(/\*\*/g, "").trim()
-        const oneLine = cleaned.length > 200 ? cleaned.slice(0, 199) + "…" : cleaned
-        return `${i + 1}. ${icon} ${r.agent} — ${oneLine}`
-      })
-
-      // Full outputs available in details for expanded view
-      const fullOutputs = result.results.map(r => {
-        const output = getFinalOutput(r.messages) || ""
-        return output
-      })
-
-      return {
-        content: [{
-          type: "text",
-          text: `Parallel: ${successCount}/${result.results.length} succeeded${failCount > 0 ? `, ${failCount} failed` : ""}\n${summaries.join("\n")}`,
-        }],
-        details: result,
-      }
-    },
-    renderCall(args, theme, _context) {
-      return renderSubagentCall({
-        tasks: typeof args.tasks === "string" ? [] : args.tasks,
-      }, theme)
-    },
-    renderResult(result, renderContext, theme, _context) {
-      // Handle partial updates where data is at top level (from onUpdate)
-      // rather than nested in .details (from final result return value)
-      const data = (result.details || result) as ParallelSubagentLiveDetails
-      return renderSubagentResult(data, renderContext, theme)
-    },
-  })
-
   pi.registerTool({
     name: sessionCheckpoint.name,
     label: "Session Checkpoint",
@@ -909,31 +750,9 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
 
 export { createArtifactHelperTool } from "./tools/artifact-helper"
 export { createAskUserQuestionTool } from "./tools/ask-user-question"
-export { createSubagentTool } from "./tools/subagent"
-export { checkSubagentDepth, getChildDepthEnv, DEFAULT_MAX_SUBAGENT_DEPTH } from "./tools/subagent-depth-guard"
-export { AsyncMutex } from "./tools/async-mutex"
-export { createJsonRunner } from "./tools/subagent-json-runner"
-export {
-  parseJsonEvent,
-  applyEventToResult,
-  type SingleResult as SingleResultType,
-  type UsageStats,
-  type ParsedEvent,
-  isFailedResult as isFailedSingleResult,
-  formatUsageStats,
-  makeInitialResult,
-  getFinalOutput as getFinalOutputFromMessages,
-  getDisplayItems,
-} from "./tools/subagent-events"
-export {
-  formatToolCall,
-  renderSubagentCall,
-  renderSubagentResult,
-} from "./tools/subagent-renderer"
 export { createWorkflowStateTool } from "./tools/workflow-state"
 export { createWorktreeManagerTool } from "./tools/worktree-manager"
 export { createReviewRouterTool } from "./tools/review-router"
-export { createParallelSubagentTool } from "./tools/parallel-subagent"
 export { createSessionCheckpointTool } from "./tools/session-checkpoint"
 export { createTaskSplitterTool } from "./tools/task-splitter"
 export { createBrainstormDialogTool } from "./tools/brainstorm-dialog"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.23.13",
+  "version": "0.24.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/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/skills/08-help/references/workflow-sequence.md

@@ -41,10 +41,10 @@ Use `07-worktree` for isolated feature development on a separate branch.
 ### 03-work
 **Use when:** plan is ready or task is tightly scoped.
 
-**Execution modes:**
-- Inline execution for small units
-- `ce_parallel_subagent` for independent CE skill units
-- `ce_subagent` only for dependent serial chains
+**Execution mode:**
+- Inline execution for all units in the current session
+
+**Advanced:** For external child agent delegation, install `pi-subagents` separately.
 
 **Key outputs:**
 - Completion report with verification evidence

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[]
-}