pi-code 1.0.12 → 1.0.13

package/README.md

@@ -17,6 +17,10 @@ What a repository ships is treated as untrusted until you approve it: project MC
 
 ![pi-code demo](demos/hero.gif)
 
+## Requirements
+
+pi `>=0.79.1` (0.84.x recommended) and Node `>=22.19` for current pi.
+
 ## Install
 
 ```bash

package/extensions/commands.ts

@@ -466,6 +466,16 @@ export default function commandsExtension(pi: ExtensionAPI) {
   }
 
   pi.on('session_start', async (_event, ctx) => {
+    // One extension instance serves every session. A mid-turn /new fires session_start on
+    // the same instance while a command's per-run scoping is still pending (its agent_settled
+    // never came). Carrying that into the next session would restore an unrelated tool set,
+    // bash/path scope, model, or effort onto it, so drop the pending state here. Drop only:
+    // no setActiveTools/setModel/setThinkingLevel, since the new session owns its own state.
+    pendingRestore = undefined
+    pendingBashRules = undefined
+    pendingPathRules = undefined
+    pendingModelRestore = undefined
+    pendingEffortRestore = undefined
     const trusted = await isProjectApproved(ctx)
     projectApproved = trusted
     // A resume/fork/new session can switch projects in-process. pi cannot unregister a

package/extensions/git-checkpoint.ts

@@ -253,6 +253,13 @@ export default function gitCheckpointExtension(pi: ExtensionAPI) {
   }
 
   pi.on('session_start', async (_event, ctx) => {
+    // One extension instance serves every session. A mid-turn /new fires session_start on
+    // the same instance after turn_start took the pre-run snapshot but before turn_end saved
+    // it; that pending ref belongs to the previous session and must not attach to the next
+    // session's first turn_end. Re-arm runNeedsSnapshot too, so the next run snapshots its
+    // own tree even though the prior run left it false.
+    pending = undefined
+    runNeedsSnapshot = true
     await ensureShadow(ctx)
     checkpoints.clear()
     for (const entry of ctx.sessionManager.getEntries()) {

package/extensions/hooks.ts

@@ -67,7 +67,7 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import type { Api, Model } from '@earendil-works/pi-ai'
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import type { ExtensionAPI, ExtensionContext, ToolCallEventResult } from '@earendil-works/pi-coding-agent'
 import { runAgent } from './internal/agent-run.js'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { INSTRUCTIONS_CHANNEL, isInstructionLoadEvent } from './internal/instruction-events.js'
@@ -859,6 +859,13 @@ function postToolFeedback(result: HookRunResult, eventName: string, isError: boo
   return lines
 }
 
+/** A blocked tool_call verdict carrying pi's `terminate` flag (#7715): with it set on
+ * an all-terminating tool batch, pi skips the automatic follow-up model call that a plain
+ * block would otherwise pay for. */
+function blockedToolCall(reason: string | undefined): ToolCallEventResult {
+  return { block: true, reason, terminate: true }
+}
+
 export default function hooksExtension(pi: ExtensionAPI) {
   let config: HooksConfig = {}
   let projectDir = ''
@@ -951,6 +958,11 @@ export default function hooksExtension(pi: ExtensionAPI) {
 
   pi.on('session_start', async (event, ctx) => {
     sessionCtx = ctx
+    // One extension instance serves every session. A mid-turn /new fires session_start on
+    // the same instance while a Stop-hook continuation streak is in flight; it must not
+    // carry into the next session, so reset before any early return (disableAllHooks below).
+    stopHookActive = false
+    stopHookBlockCount = 0
     const trusted = await isProjectApproved(ctx)
     // Claude's CLAUDE_PROJECT_DIR is the project root, not the session cwd; a hook
     // referencing $CLAUDE_PROJECT_DIR/.claude/hooks/helper.sh must resolve from a
@@ -1002,9 +1014,9 @@ export default function hooksExtension(pi: ExtensionAPI) {
     // With no UI (headless) the block stands, which is the safe default.
     if (decision.ask && ctx.hasUI) {
       const approved = await ctx.ui.confirm(`Allow ${event.toolName}?`, decision.reason ?? 'A hook asks you to confirm this tool call.')
-      return approved ? undefined : { block: true, reason: decision.reason }
+      return approved ? undefined : blockedToolCall(decision.reason)
     }
-    return { block: true, reason: decision.reason }
+    return blockedToolCall(decision.reason)
   })
 
   // Claude's PostToolUse (success) and PostToolUseFailure (error) both feed their

package/extensions/mcp.ts

@@ -943,6 +943,12 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   // Original server/tool names per registered pi name, for Claude-style hook matchers.
   const aliases: McpToolAlias[] = []
 
+  /** How many tools a server actually has registered. Counted from `registered` (the
+   * durable owner map) rather than registerTools' return, so a reconnect on a second
+   * session, where every tool is already registered and registerTools adds 0, still
+   * reports the true count in /mcp and the startup banner instead of zero. */
+  const serverToolCount = (name: string): number => [...registered.values()].filter((owner) => owner === name).length
+
   /** Register every not-yet-registered tool of a server; returns how many were added. */
   function registerTools(name: string, config: ServerConfig, tools: McpToolInfo[]): number {
     let count = 0
@@ -1154,7 +1160,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
           const added = registerTools(name, config, refreshed)
           if (added === 0) return
           const current = status.get(name)
-          status.set(name, { state: current?.state ?? 'connected', tools: (current?.tools ?? 0) + added })
+          status.set(name, { state: current?.state ?? 'connected', tools: serverToolCount(name) })
           pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
         } catch (error) {
           console.warn(`pi-code-mcp: tool refresh failed for ${name}: ${error instanceof Error ? error.message : String(error)}`)
@@ -1187,7 +1193,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
           const client = await connect(name, config, authUi)
           clients.set(name, client)
           const tools = await withTimeout(listAllTools(client), connectTimeoutMs(), `list tools ${name}`)
-          const count = registerTools(name, config, tools)
+          registerTools(name, config, tools)
           subscribeToToolChanges(name, config, client)
           // Prompts and resources are additive surfaces: their failures warn (inside
           // connectPrompts) rather than flipping a tool-serving server to failed.
@@ -1195,7 +1201,10 @@ export default async function mcpExtension(pi: ExtensionAPI) {
           subscribeToPromptChanges(name, client)
           ensureResourceTools()
           subscribeToResourceChanges(client)
-          status.set(name, { state: 'connected', tools: count })
+          // Count from `registered`, not registerTools' return: a reconnect re-lists tools
+          // that are already registered (return 0) but still serves them, so the banner
+          // must reflect the true count.
+          status.set(name, { state: 'connected', tools: serverToolCount(name) })
           // A server that dies mid-session would otherwise stay "connected" in /mcp
           // while every call fails with the SDK's bare "Not connected"; flip the
           // status and free the name so a later session start can reconnect it.
@@ -1291,6 +1300,12 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   }
 
   pi.on('session_start', async (_event, ctx) => {
+    // Reset the status map so /mcp and the banner reflect only this session's config: a
+    // server present last session but not this one must not linger as "connected". The
+    // registered tools, aliases, and prompt commands stay: pi has no unregister (a
+    // withdrawn tool keeps its registration and surfaces the server's own error), which
+    // is why serverToolCount reads from `registered` to recover the true count here.
+    status.clear()
     const authUi = authUiFor(ctx)
     // The managed allow/deny lists filter every scope, including a managed-mcp.json set.
     const { allowed, denied } = mcpAllowDeny()
@@ -1320,6 +1335,13 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   pi.on('session_shutdown', async () => {
     // Close in parallel with a per-client timeout so one hung server can't stall pi's exit.
     await Promise.all([...clients.values()].map((client) => withTimeout(client.close(), 3000, 'close').catch(() => {})))
+    // Drop the closed clients and their status now rather than waiting on each client's
+    // onclose, which the SDK fires late: a same-process session switch (/new, /resume,
+    // /fork) runs the next session_start right after this, and a lingering dead client
+    // there would make connectServers skip reconnecting the name, stranding every tool
+    // closure on a closed client. session_start resets status too, so a switch rebuilds it.
+    clients.clear()
+    status.clear()
   })
 
   pi.registerCommand('mcp', {

package/extensions/session-title.ts

@@ -3,15 +3,15 @@
  *
  * Claude auto-names a new conversation from its first message; this does the same for
  * pi. After the first run of an unnamed session settles, it asks the current model for
- * a short title based on the first user message and applies it two ways: setSessionName
- * (the name shown in the session selector) and the terminal window/tab title.
+ * a short title based on the first user message and applies it with setSessionName, which
+ * names the session in the selector and refreshes the terminal window/tab title natively
+ * (pi changelog); a separate ctx.ui.setTitle call would only duplicate that, so there is none.
  *
  * It runs in every mode, not just the TUI: naming a session is cheap and harmless, and a
- * headless run that persists its session still benefits from a readable name later. The
- * window-title update is the only terminal-specific part, so it is optional-called rather
- * than gated on hasUI. Titling is best-effort throughout: a session that already has a
- * name, a run with no user text (a slash-command-only turn), a headless run with no model,
- * or any provider error leaves the session untitled and never throws.
+ * headless run that persists its session still benefits from a readable name later. Titling
+ * is best-effort throughout: a session that already has a name, a run with no user text (a
+ * slash-command-only turn), a headless run with no model, or any provider error leaves the
+ * session untitled and never throws.
  *
  * Cost: one model call per session at most. The guard is claimed before the completion so
  * repeated settles cannot each fire a call, and a failed attempt is not retried until a
@@ -132,8 +132,11 @@ export default function sessionTitleExtension(pi: ExtensionAPI) {
     // Post-await ctx getters throw once the session is disposed, and an escaping rejection
     // from this un-awaited settle can exit pi; apply the title best-effort.
     try {
+      // pi.setSessionName refreshes the terminal/tab title natively (pi changelog), so a
+      // separate ctx.ui.setTitle call would only duplicate that. The guard stays: a
+      // disposed session throws from setSessionName post-await, and an escaping rejection
+      // from this un-awaited settle can exit pi.
       pi.setSessionName(title)
-      ctx.ui.setTitle?.(title)
     } catch {
       // disposed session or a setter failure: leave the session untitled.
     }

package/extensions/subagent/background.ts

@@ -1,8 +1,9 @@
 /**
  * Background subagent runs: fire-and-forget children whose completion wakes
  * the parent agent via a notification message. State lives in an in-memory
- * registry queried via {status: true}; it is lost on restart, and a child
- * still running when pi exits finishes on its own rather than being killed.
+ * registry queried via {status: true}; it is lost on restart. A child still
+ * running when pi quits is SIGTERMed (cancelAllBackgroundRuns); one still running
+ * across a same-process session switch keeps going under the new session.
  */
 
 import { spawn } from 'node:child_process'
@@ -141,6 +142,18 @@ export function cancelBackgroundRun(id: string): 'cancelled' | 'not-running' | '
   return 'cancelled'
 }
 
+/** SIGTERM every live background child, killing each process group the way a single
+ * cancel does. Called on quit: a detached child would otherwise keep running (and
+ * spending tokens) after pi exits, its completion swallowed. Returns how many were
+ * signalled; each cancelled child still holds its slot until it actually dies. */
+export function cancelAllBackgroundRuns(): number {
+  let count = 0
+  for (const id of Array.from(runs.keys())) {
+    if (cancelBackgroundRun(id) === 'cancelled') count++
+  }
+  return count
+}
+
 export function backgroundStatusText(): string {
   return formatStatus(runs.values())
 }

package/extensions/subagent/index.ts

@@ -32,7 +32,7 @@ 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, type AgentSource, discoverAgents, resolveModelAlias, withPreloadedSkills } from './agents.js'
-import { activeBackgroundRuns, type BackgroundRun, backgroundRun, backgroundStatusText, cancelBackgroundRun, MAX_BACKGROUND_RUNS, resumeBackgroundRun, startBackgroundRun } from './background.js'
+import { activeBackgroundRuns, type BackgroundRun, backgroundRun, backgroundStatusText, cancelAllBackgroundRuns, cancelBackgroundRun, MAX_BACKGROUND_RUNS, resumeBackgroundRun, startBackgroundRun } from './background.js'
 
 const MAX_PARALLEL_TASKS = 8
 const MAX_CONCURRENCY = 4
@@ -1387,6 +1387,23 @@ export default function subagentExtension(pi: ExtensionAPI) {
     })
   })
 
+  pi.on('session_shutdown', (event, ctx) => {
+    // On quit pi is exiting, so a detached background child would keep running (and
+    // spending tokens) with its completion swallowed: SIGTERM every live run, killing the
+    // process group the way a cancel does. On a same-process session switch
+    // (new/resume/fork) the children keep running under the new session, so leave them be
+    // and warn once that they are still spending; /tasks inspects them. reload re-imports
+    // this module (losing the registry), so it neither kills nor warns.
+    if (event.reason === 'quit') {
+      cancelAllBackgroundRuns()
+      return
+    }
+    if (event.reason === 'new' || event.reason === 'resume' || event.reason === 'fork') {
+      const active = activeBackgroundRuns()
+      if (active > 0) ctx.ui?.notify(`${active} background run${active === 1 ? '' : 's'} still active; /tasks to inspect`, 'warning')
+    }
+  })
+
   // Claude surfaces each agent's description so the model can pick one autonomously.
   // Served from the session-level cache above (keyed on cwd and scope, so an approval
   // granted mid-session still widens it); project agents are included only when the

package/extensions/thinking.ts

@@ -46,6 +46,15 @@ export default function thinkingExtension(pi: ExtensionAPI) {
   // already moved the level, thinking stands down instead of clobbering it.
   let pendingTarget: ThinkingLevel | undefined
 
+  pi.on('session_start', () => {
+    // One extension instance serves every session. A mid-turn /new fires session_start on
+    // the same instance while an escalation is still pending (its agent_settled never came),
+    // and that stale restore must be dropped rather than fired into the next session, whose
+    // level the new session owns. Drop only: do NOT setThinkingLevel here.
+    pendingRestore = undefined
+    pendingTarget = undefined
+  })
+
   pi.on('input', (event, ctx) => {
     // Only genuine user input escalates. sendUserMessage emits an input event with
     // source 'extension' (a subagent prompt, a command body replayed through it); a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "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",
@@ -20,6 +20,7 @@
     "todo"
   ],
   "license": "MIT",
+  "author": "ilovepixelart",
   "type": "module",
   "files": [
     "extensions"
@@ -51,20 +52,20 @@
     "provenance": true
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "typebox": "^1.3.6"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-ai": ">=0.79.1",
+    "@earendil-works/pi-coding-agent": ">=0.79.1",
+    "@earendil-works/pi-tui": ">=0.79.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.4",
-    "@earendil-works/pi-agent-core": "^0.84.0",
-    "@earendil-works/pi-ai": "^0.84.0",
-    "@earendil-works/pi-coding-agent": "^0.84.0",
-    "@earendil-works/pi-tui": "^0.84.0",
+    "@earendil-works/pi-agent-core": "^0.84.2",
+    "@earendil-works/pi-ai": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
     "@types/node": "^26.1.1",
     "@vitest/coverage-v8": "^4.1.10",
     "typescript": "^7.0.2",