pi-code 1.0.5 → 1.0.7

package/extensions/memory.ts

@@ -159,6 +159,33 @@ export function saveMemory(dir: string, indexPath: string, name: string | undefi
   return { content: [{ type: 'text', text: `Saved memory ${name}.` }], details: {} }
 }
 
+/** The read action: a memory's body, capped for context, or a not-found message. */
+function readMemory(dir: string, name: string): { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> } {
+  try {
+    const body = fs.readFileSync(path.join(dir, `${name}.md`), 'utf-8')
+    return { content: [{ type: 'text', text: capForContext(body) }], details: {} }
+  } catch {
+    return { content: [{ type: 'text', text: `No memory named ${name}.` }], details: {} }
+  }
+}
+
+/** The delete action: remove a memory file and its index line. The index is read
+ * before anything is removed: refusing on a failed read must leave both the memory
+ * file and the index as they were. */
+function deleteMemory(dir: string, indexPath: string, name: string): { content: Array<{ type: 'text'; text: string }>; details: Record<string, never> } {
+  let index: string
+  try {
+    index = readIndex(dir)
+  } catch (error) {
+    return { content: [{ type: 'text', text: `Memory delete failed: ${error instanceof Error ? error.message : String(error)}. Nothing was deleted.` }], details: {} }
+  }
+  fs.rmSync(path.join(dir, `${name}.md`), { force: true })
+  const remaining = removeIndexLine(index, name)
+  if (remaining) writeIndex(indexPath, remaining)
+  else fs.rmSync(indexPath, { force: true })
+  return { content: [{ type: 'text', text: `Deleted memory ${name}.` }], details: {} }
+}
+
 /** The index as injected into the prompt, bounded like Claude's startup load. */
 export function capIndexForPrompt(index: string): string {
   const loaded = stripNonLoaded(index)
@@ -327,29 +354,12 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
       if (params.action === 'read') {
         if (!name) return { content: [{ type: 'text' as const, text: 'read requires name.' }], details: {} }
-        try {
-          const body = fs.readFileSync(path.join(dir, `${name}.md`), 'utf-8')
-          return { content: [{ type: 'text' as const, text: capForContext(body) }], details: {} }
-        } catch {
-          return { content: [{ type: 'text' as const, text: `No memory named ${name}.` }], details: {} }
-        }
+        return readMemory(dir, name)
       }
 
       if (params.action === 'delete') {
         if (!name) return { content: [{ type: 'text' as const, text: 'delete requires name.' }], details: {} }
-        // The index is read before anything is removed: refusing on a failed read
-        // must leave both the memory file and the index as they were.
-        let index: string
-        try {
-          index = readIndex(dir)
-        } catch (error) {
-          return { content: [{ type: 'text' as const, text: `Memory delete failed: ${error instanceof Error ? error.message : String(error)}. Nothing was deleted.` }], details: {} }
-        }
-        fs.rmSync(path.join(dir, `${name}.md`), { force: true })
-        const remaining = removeIndexLine(index, name)
-        if (remaining) writeIndex(indexPath, remaining)
-        else fs.rmSync(indexPath, { force: true })
-        return { content: [{ type: 'text' as const, text: `Deleted memory ${name}.` }], details: {} }
+        return deleteMemory(dir, indexPath, name)
       }
 
       const index = readIndexQuietly(dir)

package/extensions/notify.ts

@@ -104,10 +104,9 @@ export default function notifyExtension(pi: ExtensionAPI) {
   // Claude's "appear to be away" check. Undefined until the first prompt this session.
   let lastInputAt: number | undefined
 
-  pi.on('session_start', async (_event, ctx) => {
+  pi.on('session_start', async (_event, _ctx) => {
     channel = resolveNotifChannel(readPreferredNotifChannel(os.homedir()))
     lastInputAt = undefined
-    void ctx
   })
 
   pi.on('input', async () => {

package/extensions/status-line.ts

@@ -9,6 +9,8 @@
  * analogue, off the shared bus), and on the optional `refreshInterval` timer
  * (minimum 1s). A project-defined command is arbitrary shell, so project settings
  * count only once the project is already approved, read without prompting.
+ * Claude's `disableAllHooks` setting turns the configured command off too, and
+ * the built-in segment stands in.
  *
  * Without a configured statusLine, the built-in segment shows turn state plus
  * running session cost, summed from per-message usage on the current branch so it
@@ -24,7 +26,7 @@ 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'
+import { hookFiles, readDisableAllHooks, runHookCommand } from './hooks.js'
 import { isPlanModeState, PLAN_MODE_CHANNEL } from './internal/plan-mode-state.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
 import { readActiveStyleName, settingsFiles } from './output-styles.js'
@@ -250,7 +252,7 @@ export default function statusLine(pi: ExtensionAPI) {
   })
   // 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
+    const usage = (event as { message?: { usage?: NonNullable<typeof lastUsage> } }).message?.usage
     if (usage) lastUsage = usage
   })
 
@@ -271,7 +273,10 @@ export default function statusLine(pi: ExtensionAPI) {
     // the keys meant for it. An undecided project simply skips project settings.
     const trusted = isProjectApprovedSilently(ctx)
     projectApproved = trusted
-    config = readStatusLineConfig(hookFiles(ctx.cwd, os.homedir(), trusted))
+    const files = hookFiles(ctx.cwd, os.homedir(), trusted)
+    // Claude's disableAllHooks also turns off the custom statusLine command; the
+    // built-in segment still renders as the fallback.
+    config = readDisableAllHooks(files) ? undefined : readStatusLineConfig(files)
     if (config?.refreshInterval) {
       refreshTimer = setInterval(() => scheduleRefresh(), config.refreshInterval * 1000)
     }

package/extensions/subagent/background.ts

@@ -26,6 +26,10 @@ export interface BackgroundRun {
   /** True until the child process actually closes: a cancelled child that ignores
    * SIGTERM is still alive and must keep holding its concurrency slot. */
   live?: boolean
+  /** Monotonic finish order, stamped when the run completes. Eviction drops the
+   * earliest-finished runs by this, not Map insertion (start) order: a long run
+   * started first but finished last must not vanish the instant it completes. */
+  finishedAt?: number
   /** pi session the child ran under, so a follow-up can continue its context. */
   sessionId: string
   /** How the child was spawned, so a follow-up can repeat it with a new task. */
@@ -63,8 +67,13 @@ export function activeBackgroundRuns(): number {
   return [...runs.values()].filter((run) => run.live || run.state === 'running').length
 }
 
+/** Stamps BackgroundRun.finishedAt; a counter rather than a clock so two runs
+ * completing in the same millisecond still evict in their true finish order. */
+let finishSequence = 0
+
 function evictFinishedRuns(): void {
   const finished = [...runs.values()].filter((run) => !run.live && run.state !== 'running')
+  finished.sort((a, b) => (a.finishedAt ?? 0) - (b.finishedAt ?? 0))
   for (const stale of finished.slice(0, Math.max(0, finished.length - MAX_FINISHED_RUNS))) runs.delete(stale.id)
 }
 
@@ -160,6 +169,7 @@ export function resumeBackgroundRun(id: string, task: string, onComplete: (run:
   run.output = undefined
   run.exitCode = undefined
   run.stderr = undefined
+  run.finishedAt = undefined
   driveRun(run, { ...run.spawn, args }, onComplete)
   return 'resumed'
 }
@@ -256,6 +266,7 @@ function driveRun(run: BackgroundRun, invocation: BackgroundSpawn, onComplete: (
   const complete = (): void => {
     if (completed) return
     completed = true
+    run.finishedAt = ++finishSequence
     evictFinishedRuns()
     // A run outlives the session that started it, and pi's loader wires assertActive()
     // into every runtime call, so notifying a disposed session throws. This fires from

package/extensions/subagent/index.ts

@@ -30,8 +30,8 @@ import { repoRoot } from '../internal/project-root.js'
 import { SUBAGENT_CHANNEL } from '../internal/subagent-events.js'
 import { autoMemoryEnabled, capIndexForPrompt, INDEX_MAX_BYTES, INDEX_MAX_LINES, memorySettingsFiles, readMemorySettings } from '../memory.js'
 import { skillDirs } from '../skills.js'
-import { type AgentConfig, type AgentMemoryScope, type AgentScope, discoverAgents, resolveModelAlias, withPreloadedSkills } from './agents.js'
-import { activeBackgroundRuns, backgroundRun, backgroundStatusText, cancelBackgroundRun, MAX_BACKGROUND_RUNS, resumeBackgroundRun, startBackgroundRun } from './background.js'
+import { type AgentConfig, type AgentMemoryScope, type AgentScope, type AgentSource, discoverAgents, resolveModelAlias, withPreloadedSkills } from './agents.js'
+import { activeBackgroundRuns, type BackgroundRun, backgroundRun, backgroundStatusText, cancelBackgroundRun, MAX_BACKGROUND_RUNS, resumeBackgroundRun, startBackgroundRun } from './background.js'
 
 const MAX_PARALLEL_TASKS = 8
 const MAX_CONCURRENCY = 4
@@ -557,6 +557,67 @@ export function cancelResultText(id: string): string {
   return `Unknown background run: ${id}.\n\n${backgroundStatusText()}`
 }
 
+/** The registry fields the /tasks listing prints. */
+type BackgroundRunView = Pick<BackgroundRun, 'id' | 'agent' | 'task' | 'state' | 'turns' | 'output' | 'stderr'>
+
+const TASK_PREVIEW_CHARS = 60
+const TAIL_PREVIEW_CHARS = 200
+
+/** Truncate to at most `max` codepoints, iterating by codepoint so a multi-byte
+ * character on the boundary is never cut into a lone surrogate. Returns the whole
+ * string when it already fits, so a caller can tell it did not clip. */
+function clipCodepoints(text: string, max: number): string {
+  const points = Array.from(text)
+  return points.length > max ? points.slice(0, max).join('') : text
+}
+
+/** A one-line tail of what a run last said: the stderr tail for a failure (the only
+ * diagnostics a boot failure leaves), the latest assistant text otherwise. */
+function runOutputTail(run: BackgroundRunView): string | undefined {
+  const stderrTail = run.state === 'failed' ? run.stderr?.trim() : undefined
+  const raw = (stderrTail || run.output)?.trim()
+  if (!raw) return undefined
+  const last = raw.split('\n').at(-1)?.trim() ?? ''
+  const shortened = clipCodepoints(last, TAIL_PREVIEW_CHARS)
+  const clipped = shortened === last ? last : `${shortened}...`
+  return stderrTail ? `stderr: ${clipped}` : clipped
+}
+
+/** The /tasks listing: one line per background run, plus the short output tail the
+ * registry's own status lines omit. A pure formatter so it tests against a plain list. */
+export function tasksStatusText(runs: ReadonlyArray<BackgroundRunView>): string {
+  if (runs.length === 0) return 'No background subagent runs in this session.'
+  return runs
+    .map((run) => {
+      const plural = run.turns === 1 ? '' : 's'
+      const label = run.state === 'running' ? 'running' : `${run.state} (${run.turns} turn${plural})`
+      const head = `${run.id} ${run.agent}: ${label} - ${clipCodepoints(run.task, TASK_PREVIEW_CHARS)}`
+      const tail = runOutputTail(run)
+      return tail ? `${head}\n  ${tail}` : head
+    })
+    .join('\n')
+}
+
+/** Listing order for /agents: lowest to highest precedence, matching how discovery
+ * lets a later source win a name clash. */
+const AGENT_SOURCE_ORDER: ReadonlyArray<AgentSource> = ['builtin', 'plugin', 'user', 'project']
+
+const AGENTS_DIR_HINT = 'Add agents as markdown files under ~/.claude/agents (user) or .claude/agents (project).'
+
+/** The /agents listing: the discovered roster grouped by source, with file paths.
+ * A pure formatter so it tests against a sample roster. */
+export function agentsListText(agents: ReadonlyArray<Pick<AgentConfig, 'name' | 'source' | 'filePath'>>): string {
+  if (agents.length === 0) return `No agents discovered.\n${AGENTS_DIR_HINT}`
+  const sections: string[] = []
+  for (const source of AGENT_SOURCE_ORDER) {
+    const group = agents.filter((agent) => agent.source === source)
+    if (group.length === 0) continue
+    const lines = group.map((agent) => `  ${agent.name} - ${agent.filePath}`).join('\n')
+    sections.push(`${source}:\n${lines}`)
+  }
+  return `${sections.join('\n')}\n\n${AGENTS_DIR_HINT}`
+}
+
 /** Everything a mode handler needs from the surrounding execute() call. */
 interface ModeContext {
   agents: AgentConfig[]
@@ -729,7 +790,20 @@ function removeTmpPrompt(tmpPrompt: { dir: string; filePath: string } | undefine
   }
 }
 
-async function runBackgroundMode(params: SubagentParamsStatic, agents: AgentConfig[], defaultCwd: string, pi: ExtensionAPI, makeDetails: MakeDetails, skillRoots: string[], availableModels: ReadonlyArray<{ id: string }>, projectApproved: boolean): Promise<ToolResult> {
+/** Everything runBackgroundMode needs from the surrounding execute() call, grouped so
+ * the parameter list stays in bounds. */
+interface BackgroundContext {
+  agents: AgentConfig[]
+  defaultCwd: string
+  pi: ExtensionAPI
+  makeDetails: MakeDetails
+  skillRoots: string[]
+  availableModels: ReadonlyArray<{ id: string }>
+  projectApproved: boolean
+}
+
+async function runBackgroundMode(params: SubagentParamsStatic, context: BackgroundContext, onStarted?: (id: string) => void): Promise<ToolResult> {
+  const { agents, defaultCwd, pi, makeDetails, skillRoots, availableModels, projectApproved } = context
   const task = params.task
   const agentName = params.agent
   if (!task || !agentName) {
@@ -775,6 +849,7 @@ async function runBackgroundMode(params: SubagentParamsStatic, agents: AgentConf
     removeTmpPrompt(tmpPrompt)
     return backgroundCapResult(makeDetails)
   }
+  onStarted?.(id)
   pi.events.emit(SUBAGENT_CHANNEL, { phase: 'start', agentType: agent.name, agentId: id })
   return {
     content: [{ type: 'text', text: `Started background run ${id} (${agent.name}). A notification will arrive on completion; check progress with {status: true}.` }],
@@ -1249,6 +1324,21 @@ function renderParallelResult(results: SingleResult[], expanded: boolean, theme:
 }
 
 export default function subagentExtension(pi: ExtensionAPI) {
+  // /tasks resolves these against the registry at print time. background.ts owns the
+  // run records but does not enumerate them, so the ids started here are remembered;
+  // a run the registry has since evicted simply drops out of the listing.
+  const startedBackgroundRuns = new Set<string>()
+
+  // The registry self-caps and evicts old runs, so an id kept here after its record is
+  // gone is dead weight. Drop those on every add, bounding the set to the registry's
+  // live capacity rather than letting it grow for the whole session.
+  const rememberBackgroundRun = (id: string): void => {
+    for (const known of startedBackgroundRuns) {
+      if (!backgroundRun(known)) startedBackgroundRuns.delete(known)
+    }
+    startedBackgroundRuns.add(id)
+  }
+
   const notifyBackgroundCompletion = (run: { id: string; agent: string; state: string; turns: number; output?: string; stderr?: string }): void => {
     // Runs through driveRun's guard, same as the background-mode callback above.
     // The stop event fires here too, so SubagentStop hooks see resumed runs end.
@@ -1344,7 +1434,11 @@ export default function subagentExtension(pi: ExtensionAPI) {
         })
 
       if (params.resume) {
-        return { content: [{ type: 'text', text: resumeResultText(params.resume, params.task, notifyBackgroundCompletion, (run) => pi.events.emit(SUBAGENT_CHANNEL, { phase: 'start', agentType: run.agent, agentId: run.id })) }], details: makeDetails('single')([]) }
+        const onResumed = (run: { id: string; agent: string }): void => {
+          rememberBackgroundRun(run.id)
+          pi.events.emit(SUBAGENT_CHANNEL, { phase: 'start', agentType: run.agent, agentId: run.id })
+        }
+        return { content: [{ type: 'text', text: resumeResultText(params.resume, params.task, notifyBackgroundCompletion, onResumed) }], details: makeDetails('single')([]) }
       }
 
       if (params.cancel) {
@@ -1385,7 +1479,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
       // unavailable tier still falls back to the session model.
       const availableModels = ctx.modelRegistry?.getAvailable?.() ?? []
 
-      if (params.background) return runBackgroundMode(params, agents, ctx.cwd, pi, makeDetails, skillRoots, availableModels, projectApproved)
+      if (params.background) return runBackgroundMode(params, { agents, defaultCwd: ctx.cwd, pi, makeDetails, skillRoots, availableModels, projectApproved }, (id) => rememberBackgroundRun(id))
 
       const mode: ModeContext = { agents, defaultCwd: ctx.cwd, signal, onUpdate, makeDetails, skillRoots, availableModels, projectApproved, onPhase: (phase, agentType, agentId) => pi.events.emit(SUBAGENT_CHANNEL, { phase, agentType, agentId }) }
 
@@ -1426,4 +1520,24 @@ export default function subagentExtension(pi: ExtensionAPI) {
       return new Text(text?.type === 'text' ? text.text : '(no output)', 0, 0)
     },
   })
+
+  // Claude's /tasks: background-run status at a glance, returning immediately without
+  // interrupting the agent; the only other way to see these is to ask the model.
+  pi.registerCommand('tasks', {
+    description: 'Show background subagent runs',
+    handler: async (_args, ctx) => {
+      const runs = [...startedBackgroundRuns].map((id) => backgroundRun(id)).filter((run): run is BackgroundRun => run !== undefined)
+      ctx.ui.notify(tasksStatusText(runs), 'info')
+    },
+  })
+
+  // Claude's /agents: the discovered roster with sources and paths. Approval is read
+  // silently, like the roster above: project agents list only once the project is trusted.
+  pi.registerCommand('agents', {
+    description: 'List discovered subagents and where they come from',
+    handler: async (_args, ctx) => {
+      const { agents } = discoverAgents(ctx.cwd, isProjectApprovedSilently(ctx) ? 'both' : 'user')
+      ctx.ui.notify(agentsListText(agents), 'info')
+    },
+  })
 }

package/extensions/web.ts

@@ -233,6 +233,40 @@ async function fetchText(rawUrl: string, transport = httpFetch): Promise<{ text:
 const FETCH_CACHE_TTL_MS = 15 * 60 * 1000
 const FETCH_CACHE_MAX_ENTRIES = 50
 
+type FetchCache = Map<string, { expires: number; body: string }>
+
+/** Store a freshly fetched body. Drop expired entries first, then evict the oldest
+ * live one if still full; deleting before set keeps Map insertion order a true
+ * recency order, so a refreshed URL moves to the newest slot instead of keeping its
+ * stale one. Only a delivered body reaches here, so a thrown fetch retries next call. */
+function rememberFetch(cache: FetchCache, url: string, body: string, now: number): void {
+  cache.delete(url)
+  for (const [key, entry] of cache) {
+    if (entry.expires <= now) cache.delete(key)
+  }
+  if (cache.size >= FETCH_CACHE_MAX_ENTRIES) {
+    const oldest = cache.keys().next().value
+    if (oldest !== undefined) cache.delete(oldest)
+  }
+  cache.set(url, { expires: now + FETCH_CACHE_TTL_MS, body })
+}
+
+/** Claude's WebFetch runs the prompt over the page with a fast model and returns
+ * that answer, not the raw page. Best-effort: any failure (no model, provider error)
+ * yields null so the caller falls back to the markdown. */
+async function answerFromPage(model: Parameters<typeof completeText>[0], prompt: string, url: string, body: string, signal?: AbortSignal): Promise<string | null> {
+  try {
+    const answer = await completeText(model, `${prompt}\n\nAnswer using only the page content below, fetched from ${url}:\n\n${body}`, {
+      system: 'You extract and answer questions from a web page. Answer only from the provided content, concisely. If the content does not contain the answer, say so.',
+      maxTokens: 1024,
+      signal,
+    })
+    return answer || null
+  } catch {
+    return null
+  }
+}
+
 export default function webExtension(pi: ExtensionAPI) {
   const fetchCache = new Map<string, { expires: number; body: string }>()
   pi.registerTool({
@@ -280,35 +314,14 @@ export default function webExtension(pi: ExtensionAPI) {
       } else {
         const { text, contentType } = await fetchText(params.url)
         body = capFetchChars(contentType.includes('html') ? htmlToMarkdown(text) : text)
-        // Only a delivered body is cached; a thrown fetch must retry next call.
-        // Drop expired entries first, then evict the oldest live one if still full;
-        // deleting before set keeps Map insertion order a true recency order, so a
-        // refreshed URL moves to the newest slot instead of keeping its stale one.
-        fetchCache.delete(params.url)
-        for (const [url, entry] of fetchCache) {
-          if (entry.expires <= now) fetchCache.delete(url)
-        }
-        if (fetchCache.size >= FETCH_CACHE_MAX_ENTRIES) {
-          const oldest = fetchCache.keys().next().value
-          if (oldest !== undefined) fetchCache.delete(oldest)
-        }
-        fetchCache.set(params.url, { expires: now + FETCH_CACHE_TTL_MS, body })
+        rememberFetch(fetchCache, params.url, body, now)
       }
 
-      // Claude's WebFetch runs the prompt over the page with a fast model and returns
-      // that answer, not the raw page. Best-effort: any failure (no model, provider
-      // error) falls back to the markdown, so web_fetch always returns something.
+      // Best-effort prompt-over-page: a failure returns null, so web_fetch always
+      // falls back to the raw markdown and returns something.
       if (params.prompt && ctx?.model) {
-        try {
-          const answer = await completeText(ctx.model, `${params.prompt}\n\nAnswer using only the page content below, fetched from ${params.url}:\n\n${body}`, {
-            system: 'You extract and answer questions from a web page. Answer only from the provided content, concisely. If the content does not contain the answer, say so.',
-            maxTokens: 1024,
-            signal,
-          })
-          if (answer) return { content: [{ type: 'text' as const, text: answer }], details: {} }
-        } catch {
-          // fall through to the raw markdown
-        }
+        const answer = await answerFromPage(ctx.model, params.prompt, params.url, body, signal)
+        if (answer) return { content: [{ type: 'text' as const, text: answer }], details: {} }
       }
       // The char cap alone admits thousands of short lines; pi's tool-output budget
       // bounds lines too, which the shared guard enforces.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, and subagents",
   "keywords": [
     "pi",