@leing2021/super-pi 0.22.1 → 0.23.1

package/extensions/ce-core/index.ts

@@ -4,23 +4,25 @@ import type { ExtensionAPI } from "@mariozechner/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"
 import { createPlanDiffTool } from "./tools/plan-diff"
 import { createSessionHistoryTool } from "./tools/session-history"
 import { createPatternExtractorTool } from "./tools/pattern-extractor"
+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 { AsyncMutex } from "./tools/async-mutex"
+import type { SubagentExecOptions, SubagentRunner } from "./tools/subagent"
 
-// NOTE: subagent and parallel_subagent tool registration removed.
-// Subagent capabilities are provided by the pi-subagents package.
-// super-pi focuses on CE-specific tools only.
-
+const _subagentEnvMutex = new AsyncMutex()
 const PIPELINE_STAGE_KEYS = new Set([
   "01-brainstorm",
   "02-plan",
@@ -29,15 +31,46 @@ const PIPELINE_STAGE_KEYS = new Set([
   "05-learn",
 ])
 
-interface ModelStrategySettings {
+interface StrategySettings {
   modelStrategy?: Record<string, string>
+  thinkingStrategy?: Record<string, string>
 }
 
-async function readProjectSettings(cwd: string): Promise<ModelStrategySettings | null> {
-  const settingsPath = path.join(cwd, ".pi", "settings.json")
+/**
+ * Read settings from two locations:
+ * 1. Project-level: {cwd}/.pi/settings.json (highest priority)
+ * 2. Global-level: ~/.pi/agent/settings.json (fallback)
+ *
+ * Project-level takes precedence; global-level is used as fallback.
+ */
+async function readSettings(cwd: string): Promise<StrategySettings | null> {
+  // Try project-level first
+  const projectPath = path.join(cwd, ".pi", "settings.json")
   try {
-    const content = await readFile(settingsPath, "utf8")
-    return JSON.parse(content) as ModelStrategySettings
+    const content = await readFile(projectPath, "utf8")
+    const projectSettings = JSON.parse(content) as StrategySettings
+    // If project has modelStrategy or thinkingStrategy, use it
+    if (projectSettings.modelStrategy || projectSettings.thinkingStrategy) {
+      return projectSettings
+    }
+  } catch {
+    // Project settings not found, continue to global
+  }
+
+  // Fallback to global-level
+  const globalPath = path.join(process.env.HOME || "~", ".pi", "agent", "settings.json")
+  try {
+    const content = await readFile(globalPath, "utf8")
+    return JSON.parse(content) as StrategySettings
+  } catch {
+    // Global settings not found either
+  }
+
+  // Try ~/.pi/settings.json as another fallback
+  const altGlobalPath = path.join(process.env.HOME || "~", ".pi", "settings.json")
+  try {
+    const content = await readFile(altGlobalPath, "utf8")
+    return JSON.parse(content) as StrategySettings
   } catch {
     return null
   }
@@ -81,6 +114,47 @@ function parseModelRef(
   }
 }
 
+/**
+ * Create a subagent runner that handles env injection with mutex protection
+ * for concurrency safety when multiple parallel subagents share the process.
+ */
+function createSubagentRunner(
+  pi: ExtensionAPI,
+  signal?: AbortSignal,
+): SubagentRunner {
+  return async (prompt: string, options?: SubagentExecOptions) => {
+    const args = ["--no-session", ...(options?.extraFlags ?? []), "-p", prompt]
+    const release = await _subagentEnvMutex.acquire()
+    const savedEnv: Record<string, string | undefined> = {}
+    const extraEnv = options?.extraEnv ?? {}
+    for (const [key, value] of Object.entries(extraEnv)) {
+      savedEnv[key] = process.env[key]
+      process.env[key] = value
+    }
+    try {
+      const execResult = await pi.exec("pi", args, {
+        signal,
+        timeout: 10 * 60 * 1000,
+      })
+
+      if (execResult.code !== 0) {
+        throw new Error(execResult.stderr || execResult.stdout || `Subagent failed for prompt: ${prompt}`)
+      }
+
+      return (execResult.stdout || "").trim()
+    } finally {
+      for (const [key, oldValue] of Object.entries(savedEnv)) {
+        if (oldValue === undefined) {
+          delete process.env[key]
+        } else {
+          process.env[key] = oldValue
+        }
+      }
+      release()
+    }
+  }
+}
+
 const artifactHelperParams = Type.Object({
   repoRoot: Type.String({ description: "Repository root where workflow artifacts should be created" }),
   artifactType: Type.Union([
@@ -103,6 +177,18 @@ 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" }),
 })
@@ -125,6 +211,19 @@ 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: false" })),
+})
+
 const sessionCheckpointParams = Type.Object({
   operation: Type.Union([
     Type.Literal("save"),
@@ -205,6 +304,30 @@ const patternSchema = Type.Object({
   sources: Type.Array(Type.String(), { description: "Artifact sources" }),
 })
 
+const contextHandoffParams = Type.Object({
+  operation: Type.Union([
+    Type.Literal("save"),
+    Type.Literal("load"),
+    Type.Literal("latest"),
+    Type.Literal("status"),
+  ], { description: "Handoff operation" }),
+  repoRoot: Type.String({ description: "Repository root" }),
+  currentStage: Type.Optional(Type.String({ description: "Current pipeline stage (e.g. 02-plan)" })),
+  nextStage: Type.Optional(Type.String({ description: "Next pipeline stage" })),
+  contextHealth: Type.Optional(Type.Union([
+    Type.Literal("good"),
+    Type.Literal("watch"),
+    Type.Literal("heavy"),
+    Type.Literal("critical"),
+  ], { description: "Context health assessment" })),
+  activeFiles: Type.Optional(Type.Array(Type.String(), { description: "1-5 must-know active file paths" })),
+  blocker: Type.Optional(Type.String({ description: "Current blocker description" })),
+  verification: Type.Optional(Type.String({ description: "Latest verification command + result" })),
+  artifacts: Type.Optional(Type.Record(Type.String(), Type.Optional(Type.String()), { description: "Artifact paths (requirements, plan, checkpoint, proof)" })),
+  handoffMarkdown: Type.Optional(Type.String({ description: "Custom handoff markdown content" })),
+  handoffPath: Type.Optional(Type.String({ description: "Specific handoff file path to load" })),
+})
+
 const patternExtractorParams = Type.Object({
   operation: Type.Union([
     Type.Literal("extract"),
@@ -227,47 +350,61 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
       return { action: "continue" as const }
     }
 
-    const settings = await readProjectSettings(ctx.cwd)
+    const settings = await readSettings(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")
+    const thinkingStrategy = settings?.thinkingStrategy
+
+    // Model switching
+    if (modelStrategy) {
+      const targetModelRef = modelStrategy[stageKey] ?? modelStrategy.default
+      if (targetModelRef) {
+        const parsed = parseModelRef(targetModelRef, ctx.model?.provider)
+        if (parsed) {
+          // Skip if already using the same model
+          if (ctx.model?.provider !== parsed.provider || ctx.model?.id !== parsed.id) {
+            const model = ctx.modelRegistry.find(parsed.provider, parsed.id)
+            if (model) {
+              const switched = await pi.setModel(model)
+              if (switched) {
+                if (ctx.hasUI) {
+                  ctx.ui.notify(`Switched model for ${stageKey}: ${model.provider}/${model.id}`, "info")
+                }
+              } else {
+                if (ctx.hasUI) {
+                  ctx.ui.notify(`No API key for ${stageKey}: ${model.provider}/${model.id}`, "warning")
+                }
+              }
+            } else if (ctx.hasUI) {
+              ctx.ui.notify(`Model not found for ${stageKey}: ${targetModelRef}`, "warning")
+            }
+          }
+        } else if (ctx.hasUI) {
+          ctx.ui.notify(`Invalid modelStrategy 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")
+    // Thinking level switching
+    if (thinkingStrategy) {
+      const targetThinking = thinkingStrategy[stageKey] ?? thinkingStrategy.default
+      if (targetThinking) {
+        const levelMap: Record<string, "low" | "medium" | "high"> = {
+          low: "low",
+          medium: "medium",
+          high: "high",
+          "0": "low",
+          "1": "medium",
+          "2": "high",
+        }
+        const normalized = levelMap[targetThinking.toLowerCase()] ?? "medium"
+        const currentLevel = ctx.getThinkingLevel?.() ?? "medium"
+        if (currentLevel !== normalized) {
+          ctx.setThinkingLevel?.(normalized)
+          if (ctx.hasUI) {
+            ctx.ui.notify(`Switched thinking level for ${stageKey}: ${normalized}`, "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 }
@@ -275,15 +412,18 @@ 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()
   const planDiff = createPlanDiffTool()
   const sessionHistory = createSessionHistoryTool()
   const patternExtractor = createPatternExtractorTool()
+  const contextHandoff = createContextHandoffTool()
 
   pi.registerTool({
     name: artifactHelper.name,
@@ -350,6 +490,29 @@ 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),
+      )
+
+      return {
+        content: [{ type: "text", text: result.outputs[result.outputs.length - 1] ?? "" }],
+        details: result,
+      }
+    },
+  })
+
   pi.registerTool({
     name: workflowState.name,
     label: "Workflow State",
@@ -421,6 +584,39 @@ 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) {
+      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),
+      )
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        details: result,
+      }
+    },
+  })
+
   pi.registerTool({
     name: sessionCheckpoint.name,
     label: "Session Checkpoint",
@@ -544,6 +740,33 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     },
   })
 
+  pi.registerTool({
+    name: contextHandoff.name,
+    label: "Context Handoff",
+    description: "Manage cross-stage context handoffs with evidence-first templates. Supports save (write handoff + state), load (read handoff + state), latest (read latest dated handoff), and status (read current state).",
+    parameters: contextHandoffParams,
+    async execute(_toolCallId, params) {
+      const result = await contextHandoff.execute({
+        operation: params.operation,
+        repoRoot: params.repoRoot,
+        currentStage: params.currentStage,
+        nextStage: params.nextStage,
+        contextHealth: params.contextHealth,
+        activeFiles: params.activeFiles,
+        blocker: params.blocker,
+        verification: params.verification,
+        artifacts: params.artifacts as Record<string, string | undefined> | undefined,
+        handoffMarkdown: params.handoffMarkdown,
+        handoffPath: params.handoffPath,
+      })
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        details: result,
+      }
+    },
+  })
+
   // Bash output smart filter — reduces context waste from verbose command output
   pi.on("tool_result", async (event, _ctx) => {
     if (event.toolName !== "bash") return undefined
@@ -587,8 +810,8 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     if (event.toolName !== "read") return undefined
 
     // Extract path from input
-    const filePath = (event.input as any)?.path ?? ""
-    if (!filePath) return undefined
+    const path = (event.input as any)?.path ?? ""
+    if (!path) return undefined
 
     // Extract text content from tool result
     const textBlocks = (event.content as Array<any>)?.filter((b: any) => b.type === "text") ?? []
@@ -598,7 +821,7 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     const isImage = (event.content as Array<any>)?.some((b: any) => b.type === "image") ?? false
 
     const result = filterReadOutput({
-      path: filePath,
+      path,
       output,
       isError: event.isError ?? false,
       isImage,
@@ -631,15 +854,20 @@ 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 { 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"
 export { createPlanDiffTool } from "./tools/plan-diff"
 export { createSessionHistoryTool } from "./tools/session-history"
 export { createPatternExtractorTool } from "./tools/pattern-extractor"
+export { createContextHandoffTool } from "./tools/context-handoff"
 export {
   getBrainstormArtifactPath,
   getPlanArtifactPath,

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

@@ -1,5 +1,5 @@
 /**
- * Parallel subagent tool — runs multiple skill-based subagent tasks concurrently.
+ * CE parallel subagent tool — runs multiple CE skill-based subagent tasks concurrently.
  *
  * Features:
  *   - Recursion depth guard (PI_SUBAGENT_DEPTH / PI_SUBAGENT_MAX_DEPTH)
@@ -40,7 +40,7 @@ function buildPrompt(agent: string, task: string): string {
 
 export function createParallelSubagentTool() {
   return {
-    name: "parallel_subagent",
+    name: "ce_parallel_subagent",
     async execute(input: ParallelSubagentInput, runner: SubagentRunner): Promise<ParallelSubagentResult> {
       // Recursion depth guard
       const depthCheck = checkSubagentDepth()
@@ -49,7 +49,7 @@ export function createParallelSubagentTool() {
       }
 
       if (!input.tasks || input.tasks.length === 0) {
-        throw new Error("parallel_subagent requires at least one task")
+        throw new Error("ce_parallel_subagent requires at least one task")
       }
 
       // Default: parallel workers get a slim context (no inherited skills)

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

@@ -1,5 +1,5 @@
 /**
- * Subagent tool — runs a single skill-based subagent or a serial chain.
+ * CE subagent tool — runs a single CE skill-based subagent or a serial chain.
  *
  * Features:
  *   - Recursion depth guard (PI_SUBAGENT_DEPTH / PI_SUBAGENT_MAX_DEPTH)
@@ -43,7 +43,7 @@ export type SubagentRunner = (
 
 export function createSubagentTool() {
   return {
-    name: "subagent",
+    name: "ce_subagent",
     async execute(input: SubagentInput, runner: SubagentRunner): Promise<SubagentResult> {
       // Recursion depth guard
       const depthCheck = checkSubagentDepth()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "private": false,
   "type": "module",
   "description": "Pi-native Compound Engineering package for iterative development workflows",
@@ -25,8 +25,6 @@
     "skills",
     "extensions",
     "rules",
-    "THIRD-PARTY-NOTICES.md",
-    "LICENSE",
     "README.md",
     "package.json"
   ],
@@ -37,10 +35,8 @@
     "test": "bun test"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
-  },
-  "dependencies": {
-    "typebox": "^1.1.24"
+    "@mariozechner/pi-coding-agent": ">=0.69.0",
+    "typebox": ">=1.0.0"
   },
   "devDependencies": {
     "@mariozechner/pi-coding-agent": "0.69.0",
@@ -51,19 +47,7 @@
       "./skills"
     ],
     "extensions": [
-      "./extensions",
-      "./extensions/super-pi-extension",
-      "./extensions/subagent"
-    ],
-    "agents": [
-      "./extensions/super-pi-extension/agents",
-      "./extensions/subagent/agents"
-    ],
-    "prompts": [
-      "./extensions/subagent/prompts"
-    ],
-    "chains": [
-      "./extensions/super-pi-extension/chains"
+      "./extensions"
     ]
   }
 }