pi-code 0.7.0 → 0.8.0

package/extensions/git-checkpoint.ts

@@ -13,6 +13,7 @@
  * the checkpoint (files created after the checkpoint are left in place).
  */
 
+import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from '@earendil-works/pi-coding-agent'
@@ -28,6 +29,35 @@ interface Checkpoint {
   createdAt: string
 }
 
+/** Claude deletes checkpoints after 30 days (cleanupPeriodDays). Shadow repos hold
+ * full snapshots of every non-ignored file, so unbounded retention grows under $HOME
+ * for the life of the machine. */
+export const CHECKPOINT_RETENTION_DAYS = 30
+
+/** Remove shadow repos untouched for longer than the retention window. The live
+ * session's repo is always kept, whatever its age: a long session's directory mtime
+ * can predate the window. Failures are ignored; this is housekeeping, not a gate. */
+export function pruneCheckpointRepos(root: string, retentionDays: number, keepDir?: string): void {
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true })
+  } catch {
+    return
+  }
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const dir = path.join(root, entry.name)
+    if (keepDir && path.resolve(dir) === path.resolve(keepDir)) continue
+    try {
+      if (fs.statSync(dir).mtimeMs >= cutoff) continue
+      fs.rmSync(dir, { recursive: true, force: true })
+    } catch {
+      // a repo we cannot stat or remove stays; housekeeping must not break startup
+    }
+  }
+}
+
 export function sessionSlug(sessionFile: string | undefined): string {
   if (!sessionFile) return `ephemeral-${process.pid}`
   return path.basename(sessionFile).replace(/[^\w.-]+/g, '_')
@@ -93,7 +123,9 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
   async function ensureShadow(ctx: ExtensionContext): Promise<void> {
     workTree = ctx.cwd
     const sessionFile = (ctx.sessionManager as { getSessionFile?: () => string | undefined }).getSessionFile?.()
-    shadowDir = path.join(os.homedir(), '.pi', 'agent', 'checkpoints', sessionSlug(sessionFile))
+    const checkpointsRoot = path.join(os.homedir(), '.pi', 'agent', 'checkpoints')
+    shadowDir = path.join(checkpointsRoot, sessionSlug(sessionFile))
+    pruneCheckpointRepos(checkpointsRoot, CHECKPOINT_RETENTION_DAYS, shadowDir)
     const check = await pi.exec('git', ['--git-dir', shadowDir, 'rev-parse', '--git-dir'], { cwd: ctx.cwd })
     if (check.code !== 0) {
       await pi.exec('git', ['init', '--bare', '-b', 'main', shadowDir], { cwd: ctx.cwd })

package/extensions/mcp.ts

@@ -21,7 +21,7 @@
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 import { Client } from '@modelcontextprotocol/sdk/client/index.js'
 // SSE is deprecated in favour of Streamable HTTP, but the SDK notes servers still on
 // the old spec exist, so this stays as a fallback for the migration period.
@@ -60,6 +60,8 @@ export interface StdioServerConfig {
   args?: string[]
   env?: Record<string, string>
   cwd?: string
+  /** Per-call wall-clock budget in ms, overriding MCP_TOOL_TIMEOUT for this server. */
+  timeout?: number
 }
 
 export interface HttpServerConfig {
@@ -68,6 +70,8 @@ export interface HttpServerConfig {
   headers?: Record<string, string>
   bearerToken?: string
   bearerTokenEnv?: string
+  /** Per-call wall-clock budget in ms, overriding MCP_TOOL_TIMEOUT for this server. */
+  timeout?: number
 }
 
 export type ServerConfig = StdioServerConfig | HttpServerConfig
@@ -123,6 +127,19 @@ export function projectServerPolicy(cwd: string, home: string): ProjectServerPol
   return { disabled, consented, consentAll }
 }
 
+/** Split project servers by the per-server policy: never-connect, connect without the
+ * whole-project confirm, and still gated behind it. */
+export function splitByPolicy(candidates: Record<string, ServerConfig>, policy: ProjectServerPolicy): { consented: Record<string, ServerConfig>; gated: Record<string, ServerConfig> } {
+  const consented: Record<string, ServerConfig> = {}
+  const gated: Record<string, ServerConfig> = {}
+  for (const [name, config] of Object.entries(candidates)) {
+    if (policy.disabled.has(name)) continue
+    if (policy.consentAll || policy.consented.has(name)) consented[name] = config
+    else gated[name] = config
+  }
+  return { consented, gated }
+}
+
 export function loadConfigFrom(files: string[]): Record<string, ServerConfig> {
   const servers: Record<string, ServerConfig> = {}
   for (const file of files) {
@@ -153,6 +170,28 @@ export function loadUserScope(home: string, cwd: string): Record<string, ServerC
   return servers
 }
 
+/** Claude reports a config entry that has a url but no type as an error; pi-code
+ * still connects (streamable HTTP with SSE fallback) but says the entry is wrong. */
+/** An inline bearerToken (interpolated) wins over bearerTokenEnv, which names an
+ * environment variable read as-is. */
+export function resolveBearerToken(config: { bearerToken?: string; bearerTokenEnv?: string }): string | undefined {
+  if (config.bearerToken) return interpolateEnv(config.bearerToken)
+  if (config.bearerTokenEnv) return process.env[config.bearerTokenEnv]
+  return undefined
+}
+
+/** A server cwd expands ${VAR} then a leading ~, or stays unset. */
+export function expandCwd(cwd: string | undefined): string | undefined {
+  if (!cwd) return undefined
+  return interpolateEnv(cwd).replace(/^~(?=\/|$)/, os.homedir())
+}
+
+export function warnOnTypelessUrl(name: string, config: ServerConfig): void {
+  if ('url' in config && config.type === undefined) {
+    console.warn(`pi-code-mcp: server ${name} declares a url with no "type"; add "type": "http" or "sse"`)
+  }
+}
+
 export function formatToolName(server: string, tool: string): string {
   return `${server}_${tool}`.replaceAll('-', '_')
 }
@@ -228,7 +267,7 @@ async function connect(name: string, config: ServerConfig): Promise<Client> {
       command: interpolateEnv(config.command),
       args: (config.args ?? []).map((arg) => interpolateEnv(arg)),
       env,
-      cwd: config.cwd?.replace(/^~(?=\/|$)/, os.homedir()),
+      cwd: expandCwd(config.cwd),
       stderr: 'ignore',
     })
     await connectWithTimeout(client, transport, `connect ${name}`)
@@ -236,7 +275,7 @@ async function connect(name: string, config: ServerConfig): Promise<Client> {
   }
   const headers: Record<string, string> = {}
   for (const [key, value] of Object.entries(config.headers ?? {})) headers[key] = interpolateEnv(value)
-  const token = config.bearerToken ? interpolateEnv(config.bearerToken) : config.bearerTokenEnv ? process.env[config.bearerTokenEnv] : undefined
+  const token = resolveBearerToken(config)
   if (token) headers.Authorization = `Bearer ${token}`
   const url = new URL(interpolateEnv(config.url))
   if (config.type === 'sse') {
@@ -305,6 +344,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
         console.warn(`pi-code-mcp: skipping duplicate server name ${name}`)
         continue
       }
+      warnOnTypelessUrl(name, config)
       try {
         const client = await connect(name, config)
         clients.set(name, client)
@@ -327,7 +367,10 @@ export default async function mcpExtension(pi: ExtensionAPI) {
             async execute(_id, params) {
               // Pass the timeout to the SDK too: its own default request timeout is 60s and
               // would otherwise reject first, so the outer race at CALL_TIMEOUT_MS was dead.
-              const result = await withTimeout(client.callTool({ name: tool.name, arguments: params as Record<string, unknown> }, undefined, { timeout: callTimeoutMs() }), callTimeoutMs(), toolName)
+              // Claude's per-server timeout wins over MCP_TOOL_TIMEOUT, with a 1s floor.
+              const declared = typeof config.timeout === 'number' && config.timeout >= 1000 ? config.timeout : undefined
+              const budget = declared ?? callTimeoutMs()
+              const result = await withTimeout(client.callTool({ name: tool.name, arguments: params as Record<string, unknown> }, undefined, { timeout: budget }), budget, toolName)
               const content = mapContent(result.content as McpContentBlock[], result.structuredContent)
               const details: { error?: string } = {}
               if (result.isError) {
@@ -346,6 +389,18 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     }
   }
 
+  /** Connect the project scope under the per-server policy. Returns whether the scope
+   * is settled, so a refused confirm can be retried on a later session start. */
+  async function connectProjectScope(ctx: ExtensionContext): Promise<boolean> {
+    const policy = projectServerPolicy(ctx.cwd, os.homedir())
+    const { consented, gated } = splitByPolicy(loadConfigFrom(projectConfigPaths(ctx.cwd)), policy)
+    if (Object.keys(consented).length > 0) await connectServers(consented)
+    if (Object.keys(gated).length === 0) return true
+    if (!(await isProjectApproved(ctx))) return false
+    await connectServers(gated)
+    return true
+  }
+
   let userConnected = false
   let projectConnected = false
 
@@ -361,23 +416,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // connect, servers the user consented to individually connect without the
     // whole-project confirm, and the rest stay behind it. Reconnect attempts after a
     // refusal are safe: connectServers skips names that already connected.
-    if (!projectConnected) {
-      const policy = projectServerPolicy(ctx.cwd, os.homedir())
-      const candidates = loadConfigFrom(projectConfigPaths(ctx.cwd))
-      const consented: Record<string, ServerConfig> = {}
-      const gated: Record<string, ServerConfig> = {}
-      for (const [name, config] of Object.entries(candidates)) {
-        if (policy.disabled.has(name)) continue
-        if (policy.consentAll || policy.consented.has(name)) consented[name] = config
-        else gated[name] = config
-      }
-      if (Object.keys(consented).length > 0) await connectServers(consented)
-      if (Object.keys(gated).length === 0) projectConnected = true
-      else if (await isProjectApproved(ctx)) {
-        projectConnected = true
-        await connectServers(gated)
-      }
-    }
+    if (!projectConnected) projectConnected = await connectProjectScope(ctx)
 
     pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
 

package/extensions/memory.ts

@@ -7,6 +7,7 @@
  * memories through the memory tool (save / read / delete / list).
  */
 
+import { createHash } from 'node:crypto'
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
@@ -17,7 +18,27 @@ import { capForContext } from './internal/output-guard.js'
 
 const INDEX_FILE = 'MEMORY.md'
 
+/** Claude loads the first 200 lines or 25KB of the memory index at startup. */
+export const INDEX_MAX_LINES = 200
+export const INDEX_MAX_BYTES = 25_000
+
+/** Windows drive letters are case-insensitive, so C:\x and c:\x are one project. */
+function normalizeCwd(cwd: string): string {
+  return cwd.replace(/^([A-Za-z]):(?=[/\\])/, (_match, letter: string) => letter.toUpperCase())
+}
+
+/** Readable dashed path plus a short digest of the real path. The digest is what makes
+ * the slug injective: every separator becomes a dash, so /a/b, /a-b and \a\b share a
+ * dashed form and would otherwise share one store. */
 export function projectSlug(cwd: string): string {
+  const normalized = normalizeCwd(cwd)
+  const readable = normalized.replace(/[/\\]/g, '-').replace(/^-+/, '-')
+  const digest = createHash('sha256').update(normalized).digest('hex').slice(0, 8)
+  return `${readable}-${digest}`
+}
+
+/** The pre-digest slug, kept only to migrate an existing store to the new name. */
+function legacySlug(cwd: string): string {
   return cwd
     .replace(/^([A-Za-z]):(?=[/\\])/, '$1')
     .replace(/[/\\]/g, '-')
@@ -28,6 +49,34 @@ export function memoryDir(cwd: string): string {
   return path.join(os.homedir(), '.pi', 'agent', 'memory', projectSlug(cwd))
 }
 
+/** Move a store written under the pre-digest slug to the current one, once. Without
+ * this the slug change would silently orphan every memory a user already has. */
+export function migrateLegacyStore(cwd: string): void {
+  const current = memoryDir(cwd)
+  if (fs.existsSync(current)) return
+  const legacy = path.join(os.homedir(), '.pi', 'agent', 'memory', legacySlug(cwd))
+  if (!fs.existsSync(legacy)) return
+  try {
+    fs.renameSync(legacy, current)
+  } catch {
+    // A failed migration must not take down session start; the store stays legacy.
+  }
+}
+
+/** The index as injected into the prompt, bounded like Claude's startup load. */
+export function capIndexForPrompt(index: string): string {
+  const withinLines = index.split('\n').slice(0, INDEX_MAX_LINES)
+  let dropped = index.split('\n').length - withinLines.length
+  let text = withinLines.join('\n')
+  while (Buffer.byteLength(text, 'utf-8') > INDEX_MAX_BYTES && withinLines.length > 1) {
+    withinLines.pop()
+    dropped++
+    text = withinLines.join('\n')
+  }
+  if (dropped <= 0) return index
+  return `${text}\n(${dropped} more memories not shown; use the memory tool with action "list")`
+}
+
 export function slugifyName(name: string): string {
   return (
     name
@@ -76,6 +125,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
   let dir = memoryDir(process.cwd())
 
   pi.on('session_start', async (_event, ctx) => {
+    migrateLegacyStore(ctx.cwd)
     dir = memoryDir(ctx.cwd)
     const count = readIndex(dir)
       .split('\n')
@@ -87,7 +137,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
     const index = readIndex(dir)
     if (!index.trim()) return
     return {
-      systemPrompt: `${event.systemPrompt}\n\n## Memory\n\nPersistent memories from earlier sessions (index):\n\n${index}\nUse the memory tool with action "read" to load a memory's full content when relevant.`,
+      systemPrompt: `${event.systemPrompt}\n\n## Memory\n\nPersistent memories from earlier sessions (index):\n\n${capIndexForPrompt(index)}\nUse the memory tool with action "read" to load a memory's full content when relevant.`,
     }
   })
 

package/extensions/plan-mode/utils.ts

@@ -194,8 +194,10 @@ export function cleanStepText(text: string): string {
 // Anchored to line start (m flag) so a prose line merely ending in "plan:" is not taken
 // for the header, which would slice the plan section mid-list and drop earlier steps.
 // Horizontal whitespace only ([^\S\n]): \s would include \n itself and overlap the
-// following \n, which is what backtracks super-linearly.
-const PLAN_HEADER = /^[^\S\n]*\*{0,2}Plan:\*{0,2}[^\S\n]*\n/im
+// following \n. The runs are bounded rather than unbounded: an unbounded run retried
+// from every position on a long whitespace-only line is what backtracks super-linearly,
+// and a real header carries at most a few spaces of indentation.
+const PLAN_HEADER = /^[^\S\n]{0,8}\*{0,2}Plan:\*{0,2}[^\S\n]{0,8}\n/im
 
 const isBlank = (ch: string | undefined): boolean => ch !== undefined && ch !== '\n' && ch.trim() === ''
 

package/extensions/question.ts

@@ -32,10 +32,10 @@ const OptionSchema = Type.Object({
   description: Type.Optional(Type.String({ description: 'Optional description shown below label' })),
 })
 
-const QuestionParams = Type.Object({
+export const QuestionParams = Type.Object({
   question: Type.String({ description: 'The question to ask the user' }),
-  header: Type.Optional(Type.String({ description: 'Short label for the question, shown above it' })),
-  options: Type.Array(OptionSchema, { description: 'Options for the user to choose from' }),
+  header: Type.Optional(Type.String({ description: 'Short label for the question, shown above it (max 12 characters)', maxLength: 12 })),
+  options: Type.Array(OptionSchema, { description: 'Options for the user to choose from (1-4)', minItems: 1, maxItems: 4 }),
   multiSelect: Type.Optional(Type.Boolean({ description: 'Allow selecting several options (space toggles, enter confirms)' })),
 })
 

package/extensions/subagent/README.md

@@ -7,7 +7,7 @@ Delegate tasks to specialized subagents with isolated context windows.
 - **Isolated context**: Each subagent runs in a separate `pi` process
 - **Streaming output**: See tool calls and progress as they happen
 - **Parallel streaming**: All parallel tasks stream updates simultaneously
-- **Background runs**: Fire-and-forget with a completion notification; max 8 running at once
+- **Background runs**: `{background: true}` returns a run id and notifies on completion; `{status: true}` lists runs and `{cancel: "<id>"}` stops one (signalling its process group); max 8 running at once
 - **Bounded fan-out**: A subagent refuses to spawn subagents of its own (an env marker the tool honors: steering, not a sandbox)
 - **Markdown rendering**: Final output rendered with proper formatting (expanded view)
 - **Usage tracking**: Shows turns, tokens, cost, and context usage per agent

package/extensions/subagent/background.ts

@@ -12,10 +12,12 @@ export interface BackgroundRun {
   id: string
   agent: string
   task: string
-  state: 'running' | 'done' | 'failed'
+  state: 'running' | 'done' | 'failed' | 'cancelled'
   exitCode?: number
   output?: string
   turns: number
+  /** Set while running so the run can be cancelled; cleared on completion. */
+  kill?: () => void
 }
 
 export interface BackgroundSpawn {
@@ -63,6 +65,18 @@ export function formatStatus(all: Iterable<BackgroundRun>): string {
   return lines.length > 0 ? lines.join('\n') : 'No background runs in this session.'
 }
 
+/** Cancel a running background child. Returns what the caller should tell the model:
+ * unknown id, already finished, or cancelled. */
+export function cancelBackgroundRun(id: string): 'cancelled' | 'not-running' | 'unknown' {
+  const run = runs.get(id)
+  if (!run) return 'unknown'
+  if (run.state !== 'running' || !run.kill) return 'not-running'
+  run.state = 'cancelled'
+  run.kill()
+  run.kill = undefined
+  return 'cancelled'
+}
+
 export function backgroundStatusText(): string {
   return formatStatus(runs.values())
 }
@@ -80,9 +94,18 @@ export function startBackgroundRun(agent: string, task: string, invocation: Back
     cwd: invocation.cwd,
     shell: false,
     stdio: ['ignore', 'pipe', 'ignore'],
+    // Its own group, so cancelling reaches any grandchild the agent spawned.
+    detached: true,
     // The marker lets the child's subagent tool refuse to nest further.
     env: { ...process.env, PI_CODE_SUBAGENT: '1' },
   })
+  run.kill = () => {
+    try {
+      process.kill(-proc.pid!, 'SIGTERM')
+    } catch {
+      proc.kill('SIGTERM')
+    }
+  }
   let stdout = ''
   // Node fires both 'error' and 'close' on a spawn failure (ENOENT); complete once.
   let completed = false
@@ -96,13 +119,16 @@ export function startBackgroundRun(agent: string, task: string, invocation: Back
   })
   proc.on('close', (code) => {
     const { text, turns } = parseFinalOutputFromJsonl(stdout)
-    run.state = code === 0 ? 'done' : 'failed'
+    run.kill = undefined
+    // 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
     run.output = text
     run.turns = turns
     complete()
   })
   proc.on('error', () => {
+    run.kill = undefined
     run.state = 'failed'
     run.exitCode = 1
     complete()

package/extensions/subagent/index.ts

@@ -27,7 +27,7 @@ import { capForContext } from '../internal/output-guard.js'
 import { isProjectApproved, isProjectApprovedSilently } from '../internal/project-approval.js'
 import { SUBAGENT_CHANNEL } from '../internal/subagent-events.js'
 import { type AgentConfig, type AgentScope, discoverAgents } from './agents.js'
-import { activeBackgroundRuns, backgroundStatusText, MAX_BACKGROUND_RUNS, startBackgroundRun } from './background.js'
+import { activeBackgroundRuns, backgroundStatusText, cancelBackgroundRun, MAX_BACKGROUND_RUNS, startBackgroundRun } from './background.js'
 
 const MAX_PARALLEL_TASKS = 8
 const MAX_CONCURRENCY = 4
@@ -460,6 +460,7 @@ const SubagentParams = Type.Object({
   cwd: Type.Optional(Type.String({ description: 'Working directory for the agent process (single mode)' })),
   background: Type.Optional(Type.Boolean({ description: 'Run the single-mode task in the background: returns a run id immediately and a notification arrives when it completes.' })),
   status: Type.Optional(Type.Boolean({ description: 'Set true (alone, no other params) to list background runs instead of running anything.' })),
+  cancel: Type.Optional(Type.String({ description: 'Background run id to cancel (from the id returned when it started, or from status).' })),
 })
 
 /**
@@ -489,6 +490,14 @@ type SubagentParamsStatic = Static<typeof SubagentParams>
 type ChainStepParam = Static<typeof ChainItem>
 type TaskItemParam = Static<typeof TaskItem>
 
+/** What to tell the model about a cancel request. */
+export function cancelResultText(id: string): string {
+  const outcome = cancelBackgroundRun(id)
+  if (outcome === 'cancelled') return `Cancelled background run ${id}.`
+  if (outcome === 'not-running') return `Background run ${id} already finished; nothing to cancel.`
+  return `Unknown background run: ${id}.\n\n${backgroundStatusText()}`
+}
+
 /** Everything a mode handler needs from the surrounding execute() call. */
 interface ModeContext {
   agents: AgentConfig[]
@@ -1120,6 +1129,10 @@ export default function subagentExtension(pi: ExtensionAPI) {
           results,
         })
 
+      if (params.cancel) {
+        return { content: [{ type: 'text', text: cancelResultText(params.cancel) }], details: makeDetails('single')([]) }
+      }
+
       if (params.status) {
         return { content: [{ type: 'text', text: backgroundStatusText() }], details: makeDetails('single')([]) }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "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",