pi-code 1.0.4 → 1.0.5

package/extensions/status-line.ts

@@ -21,6 +21,7 @@
 
 import * as fs from 'node:fs'
 import * as os from 'node:os'
+import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 
 import { hookFiles, runHookCommand } from './hooks.js'
@@ -31,6 +32,15 @@ import { readActiveStyleName, settingsFiles } from './output-styles.js'
 const COMMAND_TIMEOUT_MS = 5_000
 const DEBOUNCE_MS = 300
 
+/** Claude sends its CLI version; pi-code's own version is the honest analogue. */
+const PACKAGE_VERSION = (() => {
+  try {
+    return String(JSON.parse(fs.readFileSync(path.join(import.meta.dirname, '..', 'package.json'), 'utf-8')).version ?? '')
+  } catch {
+    return ''
+  }
+})()
+
 interface UsageEntry {
   type: string
   message?: { usage?: { cost?: { total?: number } } }
@@ -84,6 +94,17 @@ export default function statusLine(pi: ExtensionAPI) {
   let commandLine: string | undefined
   let permissionMode = 'default'
   let projectApproved = false
+  let sessionStartMs = Date.now()
+  // Lines changed, counted from successful edit/write inputs: newText and content
+  // lines add, oldText lines remove. An approximation of Claude's counters, which
+  // is honest for the tools pi has; bash-side changes are invisible to both.
+  let linesAdded = 0
+  let linesRemoved = 0
+  // API timing and the last message's token usage, from provider/message events:
+  // the fields ctx.getContextUsage() does not expose (output/cache tokens, API time).
+  let apiDurationMs = 0
+  let requestStartMs: number | undefined
+  let lastUsage: { input: number; output: number; cacheRead: number; cacheWrite: number; totalTokens: number } | undefined
   let refreshTimer: ReturnType<typeof setInterval> | undefined
   let debounceTimer: ReturnType<typeof setTimeout> | undefined
   let running = false
@@ -109,19 +130,52 @@ export default function statusLine(pi: ExtensionAPI) {
     // so reporting it here would describe a style the session is not using.
     const styleName = readActiveStyleName(settingsFiles(ctx.cwd, os.homedir(), projectApproved))
     const payload: Record<string, unknown> = {
+      hook_event_name: 'Status',
       session_id: ctx.sessionManager.getSessionId(),
       cwd: ctx.cwd,
+      version: PACKAGE_VERSION,
       workspace: { current_dir: ctx.cwd, project_dir: ctx.cwd },
       // Both fields, per Claude's documented contract: published statusline scripts
       // read .model.display_name and render the literal "null" when it is missing.
       model: { id: model?.id ?? '', display_name: model?.name ?? model?.id ?? '' },
-      cost: { total_cost_usd: sessionCost(ctx) },
-      context_window: { context_window_size: usage.contextWindow, used_percentage: usage.percent, total_input_tokens: usage.tokens },
+      cost: {
+        total_cost_usd: sessionCost(ctx),
+        total_duration_ms: Date.now() - sessionStartMs,
+        total_api_duration_ms: apiDurationMs,
+        total_lines_added: linesAdded,
+        total_lines_removed: linesRemoved,
+      },
+      context_window: {
+        context_window_size: usage.contextWindow,
+        used_percentage: usage.percent,
+        remaining_percentage: usage.percent === null ? null : 100 - usage.percent,
+        total_input_tokens: usage.tokens,
+        // The per-component breakdown from the last message's usage, which
+        // ctx.getContextUsage() (input-side estimate only) cannot provide.
+        ...(lastUsage
+          ? {
+              total_output_tokens: lastUsage.output,
+              current_usage: {
+                input_tokens: lastUsage.input,
+                output_tokens: lastUsage.output,
+                cache_read_input_tokens: lastUsage.cacheRead,
+                cache_creation_input_tokens: lastUsage.cacheWrite,
+              },
+            }
+          : {}),
+      },
+      // The true combined total when a message usage is known, else the input-side estimate.
+      exceeds_200k_tokens: (lastUsage?.totalTokens ?? usage.tokens ?? 0) > 200_000,
       permission_mode: permissionMode,
     }
     const transcript = ctx.sessionManager.getSessionFile()
     if (transcript) payload.transcript_path = transcript
-    if (ctx.thinkingLevel) payload.effort = { level: ctx.thinkingLevel }
+    const sessionName = ctx.sessionManager.getSessionName?.()
+    if (sessionName) payload.session_name = sessionName
+    if (ctx.thinkingLevel) {
+      payload.effort = { level: ctx.thinkingLevel }
+      payload.thinking = { enabled: ctx.thinkingLevel !== 'off' }
+    }
     if (styleName) payload.output_style = { name: styleName }
     return payload
   }
@@ -170,11 +224,47 @@ export default function statusLine(pi: ExtensionAPI) {
     scheduleRefresh()
   })
 
+  // Counted here rather than in buildPayload so the numbers accumulate across the
+  // session the way Claude's counters do.
+  pi.on('tool_result', async (event) => {
+    if (event.isError) return
+    const input = event.input as Record<string, unknown>
+    const lines = (text: unknown): number => (typeof text === 'string' && text.length > 0 ? text.split('\n').length : 0)
+    if (event.toolName === 'write') linesAdded += lines(input.content)
+    if (event.toolName === 'edit' && Array.isArray(input.edits)) {
+      for (const edit of input.edits as Array<{ oldText?: unknown; newText?: unknown }>) {
+        linesAdded += lines(edit.newText)
+        linesRemoved += lines(edit.oldText)
+      }
+    }
+  })
+
+  // API round-trip timing: the window between the request and its response, summed
+  // across the session. ctx exposes no API-duration getter, so it is measured here.
+  pi.on('before_provider_request', async () => {
+    requestStartMs = Date.now()
+  })
+  pi.on('after_provider_response', async () => {
+    if (requestStartMs !== undefined) apiDurationMs += Date.now() - requestStartMs
+    requestStartMs = undefined
+  })
+  // The last message's token usage, for the breakdown getContextUsage() omits.
+  pi.on('message_end', async (event) => {
+    const usage = (event as { message?: { usage?: typeof lastUsage } }).message?.usage
+    if (usage) lastUsage = usage
+  })
+
   pi.on('session_start', async (_event, ctx) => {
     // One instance serves every session, so a fresh session must not inherit state.
     turnCount = 0
     commandLine = undefined
     sessionCtx = ctx
+    sessionStartMs = Date.now()
+    linesAdded = 0
+    linesRemoved = 0
+    apiDurationMs = 0
+    requestStartMs = undefined
+    lastUsage = undefined
     clearInterval(refreshTimer)
     // Reading config must never open a trust dialog: several extensions resolve
     // approval at session start, and a second prompt stacks over the first and eats

package/extensions/subagent/agents.ts

@@ -10,22 +10,31 @@ import { getAgentDir, parseFrontmatter, stripFrontmatter } from '@earendil-works
 // The same mapping a command's `allowed-tools` gets: an agent's `tools:` is the same
 // Claude field, and `--tools` is an exact-name allowlist, so a name pi has no tool for
 // is not merely ignored, it narrows the child's registry.
-import { parseToolList } from '../internal/command-file.js'
+import { parseToolGrants } from '../internal/command-file.js'
+import { installedPlugins } from '../internal/plugins.js'
+import { findNearestDir } from '../internal/project-root.js'
 
 /**
  * `tools:` may be a comma-separated string (the Claude Code format) or a YAML block
  * list. Anything else returns null: a restriction that failed to parse must not run
  * the agent unrestricted.
+ *
+ * An argument-scoped grant (`Bash(git log:*)`) cannot be expressed in the child's
+ * --tools allowlist, and the parent cannot reach into the child process to enforce
+ * it at call time the way commands.ts does, so on the granting side it is rejected
+ * like any other unexpressable restriction. A scoped *disallow* only denies more
+ * than the file asked for, which is the safe direction, so it stands.
  */
-function parseToolsField(raw: unknown): string[] | undefined | null {
+function parseToolsField(raw: unknown, granting: boolean): string[] | undefined | null {
   if (raw === undefined) return undefined
   // Shares the command parser's splitting, so a comma inside an argument scope stays
   // inside it here too: `Bash(mv, write, cp)` used to hand the child pi's real `write`.
   if (raw !== null && !Array.isArray(raw) && typeof raw !== 'string') return null
   if (Array.isArray(raw) && raw.some((item) => typeof item !== 'string')) return null
-  const tools = parseToolList(raw)
-  if (!tools) return null
-  return tools.length > 0 ? tools : undefined
+  const grants = parseToolGrants(raw)
+  if (!grants) return null
+  if (granting && grants.scopedEntries.length > 0) return null
+  return grants.tools.length > 0 ? grants.tools : undefined
 }
 
 /**
@@ -35,7 +44,7 @@ function parseToolsField(raw: unknown): string[] | undefined | null {
  * (Claude's `inherit`) is the degradation that works everywhere; users who want a
  * tier pinned should name a concrete model id.
  */
-const CLAUDE_MODEL_ALIASES = new Set(['sonnet', 'opus', 'haiku', 'inherit'])
+const CLAUDE_MODEL_ALIASES = new Set(['sonnet', 'opus', 'haiku', 'fable', 'inherit'])
 
 function parseModelField(raw: unknown): string | undefined {
   if (typeof raw !== 'string') return undefined
@@ -70,6 +79,20 @@ function parseEffortField(raw: unknown): string | undefined {
   return THINKING_LEVELS.has(effort) ? effort : undefined
 }
 
+/** Claude's agent `memory:` scopes: a persistent per-agent store for cross-session
+ * learning, separate from the parent conversation's auto memory. */
+export type AgentMemoryScope = 'user' | 'project' | 'local'
+
+const MEMORY_SCOPES: ReadonlySet<string> = new Set(['user', 'project', 'local'])
+
+/** Anything other than the three scopes is ignored, so the agent still runs, just
+ * without memory; a typo in an optional enhancement should not drop the agent. */
+function parseMemoryField(raw: unknown): AgentMemoryScope | undefined {
+  if (typeof raw !== 'string') return undefined
+  const scope = raw.trim().toLowerCase()
+  return MEMORY_SCOPES.has(scope) ? (scope as AgentMemoryScope) : undefined
+}
+
 /** Claude's `skills` frontmatter: a comma string or YAML list of skill names. */
 function parseSkillsField(raw: unknown): string[] | undefined {
   let names: string[] = []
@@ -145,9 +168,15 @@ function parseAgentFile(content: string, source: AgentSource, filePath: string):
   const name = typeof frontmatter.name === 'string' ? frontmatter.name : ''
   const description = typeof frontmatter.description === 'string' ? frontmatter.description : ''
   if (!name || !description) return null
-  const tools = parseToolsField(frontmatter.tools)
-  if (tools === null) return null
-  const disallowedTools = parseToolsField(frontmatter.disallowedTools)
+  const tools = parseToolsField(frontmatter.tools, true)
+  if (tools === null) {
+    // A silent drop reads as "agent does not exist"; say why, since an
+    // argument-scoped grant is a shape Claude's own docs recommend but pi cannot
+    // enforce on a child process.
+    console.warn(`pi-code-subagent: ignoring agent ${filePath}: its tools: grant could not be applied (an argument scope like Bash(git log:*) cannot be enforced on a subagent; grant the whole tool or drop it)`)
+    return null
+  }
+  const disallowedTools = parseToolsField(frontmatter.disallowedTools, false)
   if (disallowedTools === null) return null
   return {
     name,
@@ -158,12 +187,20 @@ function parseAgentFile(content: string, source: AgentSource, filePath: string):
     effort: parseEffortField(frontmatter.effort),
     modelAlias: parseModelAlias(frontmatter.model),
     skills: parseSkillsField(frontmatter.skills),
+    memory: parseMemoryField(frontmatter.memory),
+    maxTurns: parseMaxTurns(frontmatter.maxTurns),
     systemPrompt: body,
     source,
     filePath,
   }
 }
 
+/** Claude's `maxTurns`: a positive integer cap on the subagent's agentic turns.
+ * Anything else (0, negative, non-number) is ignored, so the run is uncapped. */
+function parseMaxTurns(raw: unknown): number | undefined {
+  return typeof raw === 'number' && Number.isInteger(raw) && raw > 0 ? raw : undefined
+}
+
 export type AgentScope = 'user' | 'project' | 'both'
 
 export interface AgentConfig {
@@ -177,6 +214,10 @@ export interface AgentConfig {
   modelAlias?: string
   /** Skill names to inline into the child's prompt, per Claude's `skills` field. */
   skills?: string[]
+  /** Persistent per-agent memory scope, per Claude's `memory:` field. */
+  memory?: AgentMemoryScope
+  /** Cap on the child's agentic turns, enforced by killing at the turn boundary. */
+  maxTurns?: number
   systemPrompt: string
   source: AgentSource
   filePath: string
@@ -187,25 +228,27 @@ export interface AgentDiscoveryResult {
   projectAgentsDir: string | null
 }
 
+/** Claude scans .claude/agents recursively so agents can be organized into
+ * subfolders (agents/review/, agents/research/); the walk mirrors that. */
 function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
   const agents: AgentConfig[] = []
 
-  if (!fs.existsSync(dir)) {
-    return agents
-  }
-
   let entries: fs.Dirent[]
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true })
   } catch {
-    return agents
+    return agents // a missing or unreadable directory contributes nothing
   }
 
   for (const entry of entries) {
+    const filePath = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      agents.push(...loadAgentsFromDir(filePath, source))
+      continue
+    }
     if (!entry.name.endsWith('.md')) continue
     if (!entry.isFile() && !entry.isSymbolicLink()) continue
 
-    const filePath = path.join(dir, entry.name)
     let content: string
     try {
       content = fs.readFileSync(filePath, 'utf-8')
@@ -220,49 +263,6 @@ function loadAgentsFromDir(dir: string, source: AgentSource): AgentConfig[] {
   return agents
 }
 
-function isDirectory(p: string): boolean {
-  try {
-    return fs.statSync(p).isDirectory()
-  } catch {
-    return false
-  }
-}
-
-/** Project root at or above `from`. `.git` is a file in worktrees and submodules. */
-const ROOT_MARKERS = ['.git', 'package.json']
-
-function repoRoot(from: string): string | undefined {
-  let currentDir = from
-  while (true) {
-    if (ROOT_MARKERS.some((marker) => fs.existsSync(path.join(currentDir, marker)))) return currentDir
-    const parentDir = path.dirname(currentDir)
-    if (parentDir === currentDir) return undefined
-    currentDir = parentDir
-  }
-}
-
-/**
- * Nearest `relative` directory at or above `cwd`, stopping at the repository root.
- *
- * Without the boundary the search runs to the filesystem root, so an agent planted in a
- * world-writable ancestor such as /tmp is offered as a project agent for every session
- * beneath it. With no project marker (.git, package.json) the extent is unknown, so only
- * `cwd` is considered.
- */
-function findNearestDir(cwd: string, relative: string): string | null {
-  const boundary = repoRoot(cwd) ?? cwd
-  let currentDir = cwd
-  while (true) {
-    const candidate = path.join(currentDir, relative)
-    if (isDirectory(candidate)) return candidate
-
-    if (currentDir === boundary) return null
-    const parentDir = path.dirname(currentDir)
-    if (parentDir === currentDir) return null
-    currentDir = parentDir
-  }
-}
-
 function buildAgentMap(userAgents: AgentConfig[], projectAgents: AgentConfig[], scope: AgentScope): Map<string, AgentConfig> {
   const agentMap = new Map<string, AgentConfig>()
   const register = (agents: AgentConfig[]): void => {
@@ -274,19 +274,30 @@ function buildAgentMap(userAgents: AgentConfig[], projectAgents: AgentConfig[],
   return agentMap
 }
 
-export type AgentSource = 'user' | 'project' | 'builtin'
+export type AgentSource = 'user' | 'project' | 'builtin' | 'plugin'
 
 /** Bundled default agents (Explore, Plan, general-purpose), lowest precedence. */
 export const BUILTIN_AGENTS_DIR = path.join(import.meta.dirname, 'agents')
 
+/** Agent directories of every enabled plugin: `agents/` unless the manifest
+ * points elsewhere. Plugins are user-installed, so user scope only decides. */
+function pluginAgentDirs(home: string): string[] {
+  return installedPlugins(home).flatMap((plugin) => {
+    const declared = plugin.manifest.agents
+    const dirs = Array.isArray(declared) ? declared : [typeof declared === 'string' ? declared : 'agents']
+    return dirs.map((dir) => path.resolve(plugin.root, String(dir)))
+  })
+}
+
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
   const userDir = path.join(getAgentDir(), 'agents')
   const claudeUserDir = path.join(os.homedir(), '.claude', 'agents')
   const projectPiDir = findNearestDir(cwd, path.join('.pi', 'agents'))
   const projectClaudeDir = findNearestDir(cwd, path.join('.claude', 'agents'))
 
-  // ~/.claude/agents loads first so ~/.pi/agent/agents wins on name conflicts
-  const userAgents = scope === 'project' ? [] : [...loadAgentsFromDir(BUILTIN_AGENTS_DIR, 'builtin'), ...loadAgentsFromDir(claudeUserDir, 'user'), ...loadAgentsFromDir(userDir, 'user')]
+  // Plugins load after builtins and before the user's own dirs, so a user agent
+  // wins a name clash with a plugin's, and ~/.pi/agent/agents wins over ~/.claude.
+  const userAgents = scope === 'project' ? [] : [...loadAgentsFromDir(BUILTIN_AGENTS_DIR, 'builtin'), ...pluginAgentDirs(os.homedir()).flatMap((dir) => loadAgentsFromDir(dir, 'plugin')), ...loadAgentsFromDir(claudeUserDir, 'user'), ...loadAgentsFromDir(userDir, 'user')]
   // project .claude/agents loads first so project .pi/agents wins on name conflicts
   const projectAgents = scope === 'user' ? [] : [...(projectClaudeDir ? loadAgentsFromDir(projectClaudeDir, 'project') : []), ...(projectPiDir ? loadAgentsFromDir(projectPiDir, 'project') : [])]
 

package/extensions/subagent/background.ts

@@ -40,6 +40,8 @@ export interface BackgroundSpawn {
    * completing run deleted. Without it the resumed child is handed a path that no
    * longer exists, and pi falls back to using that path as the prompt text. */
   promptBody?: string
+  /** Claude's maxTurns: kill the child once it has produced this many turns. */
+  maxTurns?: number
 }
 
 const runs = new Map<string, BackgroundRun>()
@@ -68,7 +70,7 @@ function evictFinishedRuns(): void {
 
 /** Line-by-line parser keeping only the last assistant text and a turn count, so a
  * long run's JSONL stdout never accumulates whole in the parent's memory. */
-export function createJsonlOutputParser(): { push: (chunk: string) => void; flush: () => { text: string; turns: number } } {
+export function createJsonlOutputParser(onTurn?: (turns: number) => void): { push: (chunk: string) => void; flush: () => { text: string; turns: number } } {
   let buffer = ''
   let text = ''
   let turns = 0
@@ -82,6 +84,7 @@ export function createJsonlOutputParser(): { push: (chunk: string) => void; flus
     }
     if (event.type !== 'message_end' || event.message?.role !== 'assistant') return
     turns++
+    onTurn?.(turns)
     // The complete text of the last assistant message, matching getFinalOutput on the
     // foreground path so a multi-part message reads the same in both.
     const parts = (event.message.content ?? []).filter((p) => p.type === 'text' && p.text).map((p) => p.text as string)
@@ -230,8 +233,23 @@ function driveRun(run: BackgroundRun, invocation: BackgroundSpawn, onComplete: (
     proc.once('close', () => clearTimeout(escalate))
   }
   // Parsed as it streams: buffering the whole JSONL replays every tool result echoed
-  // by the child through the parent's memory for the life of the run.
-  const parser = createJsonlOutputParser()
+  // by the child through the parent's memory for the life of the run. A maxTurns cap
+  // kills the child at the turn boundary after its Nth turn, so the output so far is
+  // preserved and no turn is cut mid-flight.
+  const maxTurns = invocation.maxTurns
+  // A maxTurns cap kills the child with SIGTERM, so its close arrives with a null code.
+  // That is a clean boundary end (the foreground path treats the same cap as success),
+  // so remember it and do not misreport the run as failed.
+  let cappedByMaxTurns = false
+  const parser = createJsonlOutputParser(
+    maxTurns
+      ? (turns) => {
+          if (turns < maxTurns) return
+          cappedByMaxTurns = true
+          run.kill?.()
+        }
+      : undefined,
+  )
   let stderrTail = ''
   // Node fires both 'error' and 'close' on a spawn failure (ENOENT); complete once.
   let completed = false
@@ -264,9 +282,10 @@ function driveRun(run: BackgroundRun, invocation: BackgroundSpawn, onComplete: (
     const { text, turns } = parser.flush()
     run.kill = undefined
     run.live = false
-    // A cancelled run keeps that state: its non-zero exit is the cancellation.
-    if (run.state !== 'cancelled') run.state = code === 0 ? 'done' : 'failed'
-    run.exitCode = code ?? 0
+    // A cancelled run keeps that state: its non-zero exit is the cancellation. A
+    // maxTurns cap ends cleanly with output preserved, so it counts as done, not failed.
+    if (run.state !== 'cancelled') run.state = code === 0 || cappedByMaxTurns ? 'done' : 'failed'
+    run.exitCode = cappedByMaxTurns ? 0 : (code ?? 0)
     run.output = text
     run.turns = turns
     run.stderr = stderrTail.trim() || undefined