@oh-my-pi/subagents 1.3.375 → 1.3.377

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oh-my-pi/subagents",
-  "version": "1.3.375",
+  "version": "1.3.377",
   "description": "Task delegation system with specialized subagents (task, planner, explore, reviewer, browser)",
   "keywords": [
     "omp-plugin",

package/tools/index.ts

@@ -27,13 +27,21 @@
  */
 
 import { spawn, spawnSync } from 'node:child_process'
+
+/** pi command: 'pi.cmd' on Windows, 'pi' elsewhere */
+const PI_CMD = process.platform === 'win32' ? 'pi.cmd' : 'pi'
+/** Windows shell option for spawn/spawnSync when using PI_CMD */
+const PI_SHELL_OPT = process.platform === 'win32'
+/** Env var set to inhibit subagent spawning (prevents infinite recursion) */
+const PI_NO_SUBAGENTS_ENV = 'PI_NO_SUBAGENTS'
+
 import * as crypto from 'node:crypto'
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import * as readline from 'node:readline'
 import { StringEnum } from '@mariozechner/pi-ai'
-import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { CustomAgentTool, CustomToolFactory, ToolAPI, ToolSessionEvent } from '@mariozechner/pi-coding-agent'
 import { Text } from '@mariozechner/pi-tui'
 import { Type } from '@sinclair/typebox'
 import runtime from './runtime.json'
@@ -49,9 +57,10 @@ function getAvailableModels(): string[] {
    if (cachedModels !== null) return cachedModels
 
    try {
-      const result = spawnSync('pi', ['--list-models'], {
+      const result = spawnSync(PI_CMD, ['--list-models'], {
          encoding: 'utf-8',
          timeout: 5000,
+         shell: PI_SHELL_OPT,
       })
 
       if (result.status !== 0 || !result.stdout) {
@@ -111,6 +120,22 @@ const MAX_PARALLEL_TASKS = runtime.options.maxParallelTasks ?? 32
 const MAX_CONCURRENCY = runtime.options.maxConcurrency ?? 16
 const MAX_AGENTS_IN_DESCRIPTION = runtime.options.maxAgentsInDescription ?? 10
 
+const PERSIST_SESSIONS = runtime.options.persistSessions ?? false
+
+/**
+ * Derive a session artifacts directory from a session file path.
+ * /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid.jsonl
+ *   → /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid/
+ */
+function getSessionArtifactsDir(sessionFile: string | null): string | null {
+   if (!sessionFile) return null
+   // Strip .jsonl extension to get directory path
+   if (sessionFile.endsWith('.jsonl')) {
+      return sessionFile.slice(0, -6)
+   }
+   return sessionFile
+}
+
 type AgentScope = 'user' | 'project' | 'both'
 
 interface AgentConfig {
@@ -119,6 +144,8 @@ interface AgentConfig {
    tools?: string[]
    model?: string
    forkContext?: boolean
+   /** If true, this agent can spawn subagents. Default: false (subagents inhibited) */
+   recursive?: boolean
    systemPrompt: string
    source: 'user' | 'project'
    filePath: string
@@ -245,12 +272,15 @@ function loadAgentsFromDir(dir: string, source: 'user' | 'project'): AgentConfig
       const forkContext =
          frontmatter.forkContext === undefined ? undefined : frontmatter.forkContext === 'true' || frontmatter.forkContext === '1'
 
+      const recursive = frontmatter.recursive === undefined ? undefined : frontmatter.recursive === 'true' || frontmatter.recursive === '1'
+
       agents.push({
          name: frontmatter.name,
          description: frontmatter.description,
          tools: tools && tools.length > 0 ? tools : undefined,
          model: frontmatter.model,
          forkContext,
+         recursive,
          systemPrompt: body,
          source,
          filePath,
@@ -463,25 +493,15 @@ async function mapWithConcurrencyLimit<TIn, TOut>(
    return results
 }
 
-function writePromptToTempFile(agentName: string, prompt: string): { dir: string; filePath: string } {
-   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-task-agent-'))
-   const safeName = agentName.replace(/[^\w.-]+/g, '_')
-   const filePath = path.join(tmpDir, `prompt-${safeName}.md`)
-   try {
-      // mode: 0o600 restricts file permissions on Unix; ignored on Windows
-      fs.writeFileSync(filePath, prompt, { encoding: 'utf-8', mode: 0o600 })
-   } catch (err) {
-      fs.rmSync(tmpDir, { recursive: true, force: true })
-      throw err
-   }
-   return { dir: tmpDir, filePath }
-}
-
 interface RunAgentOptions {
    onProgress?: (progress: AgentProgress) => void
    index?: number
    signal?: AbortSignal
    model?: string
+   /** Session file path. If provided, uses --session flag; otherwise --no-session. */
+   sessionFile?: string
+   /** Input file path. If provided, task is written here (persistent); otherwise uses temp file. */
+   inputFile?: string
 }
 
 async function runSingleAgent(
@@ -524,7 +544,14 @@ async function runSingleAgent(
       }
    }
 
-   const args: string[] = ['-p', '--no-session', '--mode', 'json']
+   const args: string[] = ['-p', '--mode', 'json']
+
+   // Session persistence: use --session <file> if provided, otherwise --no-session
+   if (options?.sessionFile) {
+      args.push('--session', options.sessionFile)
+   } else {
+      args.push('--no-session')
+   }
 
    // "default" means no model override - use pi's configured default
    const modelOverride = options?.model
@@ -538,18 +565,32 @@ async function runSingleAgent(
       args.push('--tools', agent.tools.join(','))
    }
 
+   // Use provided inputFile (persistent) or create temp file
    let tmpPromptDir: string | null = null
-   let tmpPromptPath: string | null = null
+   let taskFilePath: string
+
+   if (options?.inputFile) {
+      // Persistent: write to provided path
+      taskFilePath = options.inputFile
+      fs.writeFileSync(taskFilePath, task, { encoding: 'utf-8' })
+   } else {
+      // Ephemeral: use temp directory (cleaned up after)
+      tmpPromptDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-task-agent-'))
+      taskFilePath = path.join(tmpPromptDir, `task-${agent.name.replace(/[^\w.-]+/g, '_')}.md`)
+      fs.writeFileSync(taskFilePath, task, { encoding: 'utf-8', mode: 0o600 })
+   }
 
    try {
       if (agent.systemPrompt.trim()) {
-         const tmp = writePromptToTempFile(agent.name, agent.systemPrompt)
-         tmpPromptDir = tmp.dir
-         tmpPromptPath = tmp.filePath
-         args.push('--append-system-prompt', tmpPromptPath)
+         // System prompt always goes to temp (not worth persisting)
+         if (!tmpPromptDir) tmpPromptDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-task-agent-'))
+         const systemFilePath = path.join(tmpPromptDir, `system-${agent.name.replace(/[^\w.-]+/g, '_')}.md`)
+         fs.writeFileSync(systemFilePath, agent.systemPrompt, { encoding: 'utf-8', mode: 0o600 })
+         args.push('--append-system-prompt', systemFilePath)
       }
 
-      args.push(`Task: ${task}`)
+      // Pass task file via @file syntax
+      args.push(`@${taskFilePath.replace(/\\/g, '/')}`)
 
       // Emit initial "Initializing" state
       options?.onProgress?.({
@@ -571,9 +612,14 @@ async function runSingleAgent(
       })
 
       return await new Promise<SingleResult>(resolve => {
-         const proc = spawn('pi', args, {
+         // Unless agent has recursive: true, set env var to inhibit nested subagents
+         const spawnEnv = agent.recursive ? process.env : { ...process.env, [PI_NO_SUBAGENTS_ENV]: '1' }
+
+         const proc = spawn(PI_CMD, args, {
             cwd,
             stdio: ['ignore', 'pipe', 'pipe'],
+            shell: PI_SHELL_OPT,
+            env: spawnEnv,
          })
 
          let toolCount = 0
@@ -782,16 +828,10 @@ async function runSingleAgent(
          })
       })
    } finally {
-      if (tmpPromptPath) {
-         try {
-            fs.unlinkSync(tmpPromptPath)
-         } catch {
-            /* ignore */
-         }
-      }
+      // Clean up temp directory (contains system prompt and task files)
       if (tmpPromptDir) {
          try {
-            fs.rmdirSync(tmpPromptDir)
+            fs.rmSync(tmpPromptDir, { recursive: true, force: true })
          } catch {
             /* ignore */
          }
@@ -968,8 +1008,28 @@ function nanoid(size = 12): string {
 }
 
 const factory: CustomToolFactory = pi => {
+   // Check if subagent spawning is inhibited (we're inside a non-recursive subagent)
+   if (process.env[PI_NO_SUBAGENTS_ENV]) {
+      return [] // No Task tool available in this context
+   }
+
    const runId = nanoid(8)
-   const outputDir = path.join(os.tmpdir(), `pi-task-${runId}`)
+
+   // Session artifacts directory (sibling to .jsonl file, without extension)
+   // e.g., /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid/
+   let artifactsDir: string | null = null
+   const tempDir = path.join(os.tmpdir(), `pi-task-${runId}`)
+
+   const updateSessionDir = (event: ToolSessionEvent) => {
+      if (PERSIST_SESSIONS && event.sessionFile) {
+         // Artifacts go in folder matching session file (without .jsonl)
+         // e.g., /path/to/2026-01-01T14-28-11-636Z_uuid/
+         artifactsDir = getSessionArtifactsDir(event.sessionFile)
+         if (artifactsDir) fs.mkdirSync(artifactsDir, { recursive: true })
+      } else {
+         artifactsDir = null
+      }
+   }
 
    const tool: CustomAgentTool<typeof TaskParams, TaskDetails> = {
       name: 'task',
@@ -1066,15 +1126,31 @@ const factory: CustomToolFactory = pi => {
             model: t.model,
          }))
 
-         // Generate output paths
-         fs.mkdirSync(outputDir, { recursive: true })
-         const outputPaths = params.tasks.map((t, i) => path.join(outputDir, `task_${sanitizeAgentName(t.agent)}_${i}.md`))
+         // Generate paths for each agent invocation
+         // Persisted:  <artifactsDir>/<agent>_<nanoid>.{jsonl,out.md,in.md}
+         // Ephemeral:  <tempDir>/task_<agent>_<idx>.md
+         const agentIds = params.tasks.map(t => `${sanitizeAgentName(t.agent)}_${nanoid(8)}`)
+
+         let outputPaths: string[]
+         let sessionFiles: string[] | undefined
+         let inputFiles: string[] | undefined
+
+         if (artifactsDir) {
+            outputPaths = agentIds.map(id => path.join(artifactsDir!, `${id}.out.md`))
+            sessionFiles = agentIds.map(id => path.join(artifactsDir!, `${id}.jsonl`))
+            inputFiles = agentIds.map(id => path.join(artifactsDir!, `${id}.in.md`))
+         } else {
+            fs.mkdirSync(tempDir, { recursive: true })
+            outputPaths = params.tasks.map((t, i) => path.join(tempDir, `task_${sanitizeAgentName(t.agent)}_${i}.md`))
+         }
 
          const results = await mapWithConcurrencyLimit(tasksWithContext, MAX_CONCURRENCY, async (t, idx) => {
             const result = await runSingleAgent(pi.cwd, agents, t.agent, t.task, undefined, {
                index: idx,
                signal,
                model: t.model,
+               sessionFile: sessionFiles?.[idx],
+               inputFile: inputFiles?.[idx],
                onProgress: progress => {
                   progressMap.set(idx, progress)
                   emitProgress()
@@ -1122,6 +1198,9 @@ const factory: CustomToolFactory = pi => {
          }
       },
 
+      // Track parent session for subagent persistence
+      onSession: updateSessionDir,
+
       renderCall(args, theme) {
          // Return minimal - renderResult handles the full display
          if (!args.tasks || args.tasks.length === 0) {

package/tools/runtime.json

@@ -4,6 +4,7 @@
     "maxOutputBytes": 500000,
     "maxParallelTasks": 32,
     "maxConcurrency": 16,
-    "maxAgentsInDescription": 10
+    "maxAgentsInDescription": 10,
+    "persistSessions": true
   }
 }