pi-code 1.0.12 → 1.0.14

package/extensions/memory.ts

@@ -17,7 +17,9 @@ import { Type } from 'typebox'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { capForContext } from './internal/output-guard.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
-import { findNearestFile, repoRoot } from './internal/project-root.js'
+import { repoRoot } from './internal/project-root.js'
+import { claudeSettingsChain } from './internal/settings-chain.js'
+import { statToken } from './internal/stat-token.js'
 
 export const INDEX_FILE = 'MEMORY.md'
 
@@ -148,7 +150,7 @@ type MemoryToolResult = { content: Array<{ type: 'text'; text: string }>; detail
  * also on the memory file: a second nested queue self-deadlocks when a memory name
  * canonicalizes to the same key as the index (e.g. `memory.md` and `MEMORY.md` under a
  * case-insensitive filesystem, since the queue keys on realpath). */
-export async function saveMemory(dir: string, indexPath: string, name: string | undefined, description: string | undefined, content: string | undefined, now: string = new Date().toISOString()): Promise<MemoryToolResult> {
+async function saveMemory(dir: string, indexPath: string, name: string | undefined, description: string | undefined, content: string | undefined, now: string = new Date().toISOString()): Promise<MemoryToolResult> {
   if (!name || !description || !content) {
     return { content: [{ type: 'text', text: 'save requires name, description, and content.' }], details: {} }
   }
@@ -289,12 +291,7 @@ function writeIndex(indexPath: string, content: string): void {
  * approved, since a project's `autoMemoryDirectory` is honored under the same trust
  * rule as hooks in settings files. Later files win. */
 export function memorySettingsFiles(cwd: string, home: string, approved: boolean): string[] {
-  const files = [path.join(claudeConfigDir(home), 'settings.json')]
-  if (!approved) return files
-  for (const name of ['settings.json', 'settings.local.json']) {
-    files.push(findNearestFile(cwd, path.join('.claude', name)) ?? path.join(cwd, '.claude', name))
-  }
-  return files
+  return claudeSettingsChain(cwd, home, approved)
 }
 
 /** Merge the two memory settings across the chain, later files winning per key. */
@@ -361,8 +358,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
   const indexStatToken = (): string => {
     try {
-      const stat = fs.statSync(path.join(dir, INDEX_FILE))
-      return `${stat.mtimeMs}:${stat.size}`
+      return statToken(path.join(dir, INDEX_FILE))
     } catch {
       return 'missing'
     }

package/extensions/output-styles.ts

@@ -28,6 +28,7 @@ import { claudeConfigDir } from './internal/config-dir.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApproved } from './internal/project-approval.js'
 import { findNearestDir, findNearestFile } from './internal/project-root.js'
+import { claudeSettingsChain } from './internal/settings-chain.js'
 
 export interface OutputStyle {
   name: string
@@ -130,12 +131,7 @@ export function loadStyles(dirs: string[]): OutputStyle[] {
 /** Settings files that carry `outputStyle`. Project settings apply only when trusted,
  * each the nearest of its name at or above cwd, as the hooks settings chain reads. */
 export function settingsFiles(cwd: string, home: string, trusted: boolean): string[] {
-  const files = [path.join(claudeConfigDir(home), 'settings.json')]
-  if (!trusted) return files
-  for (const name of ['settings.json', 'settings.local.json']) {
-    files.push(findNearestFile(cwd, path.join('.claude', name)) ?? path.join(cwd, '.claude', name))
-  }
-  return files
+  return claudeSettingsChain(cwd, home, trusted)
 }
 
 /** The `outputStyle` recorded in settings, last file winning. */

package/extensions/plan-mode/utils.ts

@@ -201,7 +201,7 @@ export function extractTodoItems(message: string): TodoItem[] {
   return items
 }
 
-export function extractDoneSteps(message: string): number[] {
+function extractDoneSteps(message: string): number[] {
   const steps: number[] = []
   for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
     const step = Number(match[1])

package/extensions/question.ts

@@ -58,7 +58,7 @@ export interface QuestionSpec {
 }
 
 /** Normalize either accepted shape into the list of questions to ask. */
-export function questionList(params: Partial<QuestionSpec> & { questions?: QuestionSpec[] }): QuestionSpec[] {
+function questionList(params: Partial<QuestionSpec> & { questions?: QuestionSpec[] }): QuestionSpec[] {
   if (params.questions && params.questions.length > 0) return params.questions
   if (typeof params.question === 'string') return [{ question: params.question, header: shortHeader(params.header), options: params.options ?? [], multiSelect: params.multiSelect }]
   return []
@@ -67,7 +67,7 @@ export function questionList(params: Partial<QuestionSpec> & { questions?: Quest
 /** Claude keeps a header short for the label slot. Truncating is the forgiving read:
  * rejecting the call costs a turn while the model recovers from a validation error,
  * which is a poor trade for a display detail. */
-export const HEADER_MAX = 12
+const HEADER_MAX = 12
 export const shortHeader = (header: string | undefined): string | undefined => (header === undefined ? undefined : header.slice(0, HEADER_MAX))
 
 function checkbox(checked: boolean | undefined): string {

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/status-line.ts

@@ -28,7 +28,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, readDisableAllHooks, runHookCommand } from './hooks.js'
+import { hookFiles, readDisableAllHooks, runHookCommand } from './hooks/index.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'

package/extensions/subagent/agents.ts

@@ -278,7 +278,7 @@ function buildAgentMap(userAgents: AgentConfig[], projectAgents: AgentConfig[],
 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')
+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. */

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,106 +32,17 @@ 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'
+import { type DisplayItem, formatToolCall, formatUsageStats, getDisplayItems, getFinalOutput } from './render.js'
+
+// Re-exported so the render formatters stay importable from the subagent entry point,
+// where the tests and the tool itself have always reached for them.
+export { formatTokens, formatToolCall, formatUsageStats, getDisplayItems, getFinalOutput } from './render.js'
 
 const MAX_PARALLEL_TASKS = 8
 const MAX_CONCURRENCY = 4
 const COLLAPSED_ITEM_COUNT = 10
 
-export function formatTokens(count: number): string {
-  if (count < 1000) return count.toString()
-  if (count < 10000) return `${(count / 1000).toFixed(1)}k`
-  if (count < 1000000) return `${Math.round(count / 1000)}k`
-  return `${(count / 1000000).toFixed(1)}M`
-}
-
-export function formatUsageStats(
-  usage: {
-    input: number
-    output: number
-    cacheRead: number
-    cacheWrite: number
-    cost: number
-    contextTokens?: number
-    turns?: number
-  },
-  model?: string,
-): string {
-  const parts: string[] = []
-  if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? 's' : ''}`)
-  if (usage.input) parts.push(`↑${formatTokens(usage.input)}`)
-  if (usage.output) parts.push(`↓${formatTokens(usage.output)}`)
-  if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`)
-  if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`)
-  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`)
-  if (usage.contextTokens && usage.contextTokens > 0) {
-    parts.push(`ctx:${formatTokens(usage.contextTokens)}`)
-  }
-  if (model) parts.push(model)
-  return parts.join(' ')
-}
-
-export function formatToolCall(toolName: string, args: Record<string, unknown>, themeFg: Theme['fg']): string {
-  const shortenPath = (p: string) => {
-    const home = os.homedir()
-    return p.startsWith(home) ? `~${p.slice(home.length)}` : p
-  }
-
-  switch (toolName) {
-    case 'bash': {
-      const command = (args.command as string) || '...'
-      const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command
-      return themeFg('muted', '$ ') + themeFg('toolOutput', preview)
-    }
-    case 'read': {
-      const rawPath = (args.file_path || args.path || '...') as string
-      const filePath = shortenPath(rawPath)
-      const offset = args.offset as number | undefined
-      const limit = args.limit as number | undefined
-      let text = themeFg('accent', filePath)
-      if (offset !== undefined || limit !== undefined) {
-        const startLine = offset ?? 1
-        const endLine = limit !== undefined ? startLine + limit - 1 : ''
-        const rangeSuffix = endLine ? `-${endLine}` : ''
-        text += themeFg('warning', `:${startLine}${rangeSuffix}`)
-      }
-      return themeFg('muted', 'read ') + text
-    }
-    case 'write': {
-      const rawPath = (args.file_path || args.path || '...') as string
-      const filePath = shortenPath(rawPath)
-      const content = (args.content || '') as string
-      const lines = content.split('\n').length
-      let text = themeFg('muted', 'write ') + themeFg('accent', filePath)
-      if (lines > 1) text += themeFg('dim', ` (${lines} lines)`)
-      return text
-    }
-    case 'edit': {
-      const rawPath = (args.file_path || args.path || '...') as string
-      return themeFg('muted', 'edit ') + themeFg('accent', shortenPath(rawPath))
-    }
-    case 'ls': {
-      const rawPath = (args.path || '.') as string
-      return themeFg('muted', 'ls ') + themeFg('accent', shortenPath(rawPath))
-    }
-    case 'find': {
-      const pattern = (args.pattern || '*') as string
-      const rawPath = (args.path || '.') as string
-      return themeFg('muted', 'find ') + themeFg('accent', pattern) + themeFg('dim', ` in ${shortenPath(rawPath)}`)
-    }
-    case 'grep': {
-      const pattern = (args.pattern || '') as string
-      const rawPath = (args.path || '.') as string
-      return themeFg('muted', 'grep ') + themeFg('accent', `/${pattern}/`) + themeFg('dim', ` in ${shortenPath(rawPath)}`)
-    }
-    default: {
-      const argsStr = JSON.stringify(args)
-      const preview = argsStr.length > 50 ? `${argsStr.slice(0, 50)}...` : argsStr
-      return themeFg('accent', toolName) + themeFg('dim', ` ${preview}`)
-    }
-  }
-}
-
 interface UsageStats {
   input: number
   output: number
@@ -163,34 +74,6 @@ interface SubagentDetails {
   results: SingleResult[]
 }
 
-export function getFinalOutput(messages: Message[]): string {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i]
-    if (msg.role === 'assistant') {
-      // The complete text of the last assistant message: a message can carry more than one
-      // text part, and taking only the first diverged from the background parser.
-      const parts = msg.content.filter((part) => part.type === 'text').map((part) => part.text)
-      if (parts.length > 0) return parts.join('\n')
-    }
-  }
-  return ''
-}
-
-type DisplayItem = { type: 'text'; text: string } | { type: 'toolCall'; name: string; args: Record<string, unknown> }
-
-export function getDisplayItems(messages: Message[]): DisplayItem[] {
-  const items: DisplayItem[] = []
-  for (const msg of messages) {
-    if (msg.role === 'assistant') {
-      for (const part of msg.content) {
-        if (part.type === 'text') items.push({ type: 'text', text: part.text })
-        else if (part.type === 'toolCall') items.push({ type: 'toolCall', name: part.name, args: part.arguments })
-      }
-    }
-  }
-  return items
-}
-
 export async function mapWithConcurrencyLimit<TIn, TOut>(items: TIn[], concurrency: number, fn: (item: TIn, index: number) => Promise<TOut>): Promise<TOut[]> {
   if (items.length === 0) return []
   const limit = Math.max(1, Math.min(concurrency, items.length))
@@ -724,7 +607,7 @@ export function agentMemorySection(dir: string, memoryMd: string): string {
 /** The memory section for one run, or undefined when the agent declares no memory,
  * auto memory is off, or a repo-scoped store is not approved. Subagent memory is part
  * of auto memory, so the same settings chain and env kill switch gate it. */
-export function agentMemoryPromptSection(agent: Pick<AgentConfig, 'memory' | 'name'>, cwd: string, projectApproved: boolean): string | undefined {
+function agentMemoryPromptSection(agent: Pick<AgentConfig, 'memory' | 'name'>, cwd: string, projectApproved: boolean): string | undefined {
   if (!agent.memory) return undefined
   // project and local stores live under the repository's .claude, a repo-controlled
   // path; like rules, they are only read once the project is approved.
@@ -1387,6 +1270,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/subagent/render.ts

@@ -0,0 +1,131 @@
+/**
+ * Subagent display formatters: the pure helpers that turn a run's messages and usage
+ * into the strings the subagent tool renders. No process spawning, no pi API, no state,
+ * so they render the same way for the live tool and for tests.
+ */
+
+import * as os from 'node:os'
+import type { Message } from '@earendil-works/pi-ai'
+import type { Theme } from '@earendil-works/pi-coding-agent'
+
+export function formatTokens(count: number): string {
+  if (count < 1000) return count.toString()
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`
+  if (count < 1000000) return `${Math.round(count / 1000)}k`
+  return `${(count / 1000000).toFixed(1)}M`
+}
+
+export function formatUsageStats(
+  usage: {
+    input: number
+    output: number
+    cacheRead: number
+    cacheWrite: number
+    cost: number
+    contextTokens?: number
+    turns?: number
+  },
+  model?: string,
+): string {
+  const parts: string[] = []
+  if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? 's' : ''}`)
+  if (usage.input) parts.push(`↑${formatTokens(usage.input)}`)
+  if (usage.output) parts.push(`↓${formatTokens(usage.output)}`)
+  if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`)
+  if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`)
+  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`)
+  if (usage.contextTokens && usage.contextTokens > 0) {
+    parts.push(`ctx:${formatTokens(usage.contextTokens)}`)
+  }
+  if (model) parts.push(model)
+  return parts.join(' ')
+}
+
+export function formatToolCall(toolName: string, args: Record<string, unknown>, themeFg: Theme['fg']): string {
+  const shortenPath = (p: string) => {
+    const home = os.homedir()
+    return p.startsWith(home) ? `~${p.slice(home.length)}` : p
+  }
+
+  switch (toolName) {
+    case 'bash': {
+      const command = (args.command as string) || '...'
+      const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command
+      return themeFg('muted', '$ ') + themeFg('toolOutput', preview)
+    }
+    case 'read': {
+      const rawPath = (args.file_path || args.path || '...') as string
+      const filePath = shortenPath(rawPath)
+      const offset = args.offset as number | undefined
+      const limit = args.limit as number | undefined
+      let text = themeFg('accent', filePath)
+      if (offset !== undefined || limit !== undefined) {
+        const startLine = offset ?? 1
+        const endLine = limit !== undefined ? startLine + limit - 1 : ''
+        const rangeSuffix = endLine ? `-${endLine}` : ''
+        text += themeFg('warning', `:${startLine}${rangeSuffix}`)
+      }
+      return themeFg('muted', 'read ') + text
+    }
+    case 'write': {
+      const rawPath = (args.file_path || args.path || '...') as string
+      const filePath = shortenPath(rawPath)
+      const content = (args.content || '') as string
+      const lines = content.split('\n').length
+      let text = themeFg('muted', 'write ') + themeFg('accent', filePath)
+      if (lines > 1) text += themeFg('dim', ` (${lines} lines)`)
+      return text
+    }
+    case 'edit': {
+      const rawPath = (args.file_path || args.path || '...') as string
+      return themeFg('muted', 'edit ') + themeFg('accent', shortenPath(rawPath))
+    }
+    case 'ls': {
+      const rawPath = (args.path || '.') as string
+      return themeFg('muted', 'ls ') + themeFg('accent', shortenPath(rawPath))
+    }
+    case 'find': {
+      const pattern = (args.pattern || '*') as string
+      const rawPath = (args.path || '.') as string
+      return themeFg('muted', 'find ') + themeFg('accent', pattern) + themeFg('dim', ` in ${shortenPath(rawPath)}`)
+    }
+    case 'grep': {
+      const pattern = (args.pattern || '') as string
+      const rawPath = (args.path || '.') as string
+      return themeFg('muted', 'grep ') + themeFg('accent', `/${pattern}/`) + themeFg('dim', ` in ${shortenPath(rawPath)}`)
+    }
+    default: {
+      const argsStr = JSON.stringify(args)
+      const preview = argsStr.length > 50 ? `${argsStr.slice(0, 50)}...` : argsStr
+      return themeFg('accent', toolName) + themeFg('dim', ` ${preview}`)
+    }
+  }
+}
+
+export function getFinalOutput(messages: Message[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (msg.role === 'assistant') {
+      // The complete text of the last assistant message: a message can carry more than one
+      // text part, and taking only the first diverged from the background parser.
+      const parts = msg.content.filter((part) => part.type === 'text').map((part) => part.text)
+      if (parts.length > 0) return parts.join('\n')
+    }
+  }
+  return ''
+}
+
+export type DisplayItem = { type: 'text'; text: string } | { type: 'toolCall'; name: string; args: Record<string, unknown> }
+
+export function getDisplayItems(messages: Message[]): DisplayItem[] {
+  const items: DisplayItem[] = []
+  for (const msg of messages) {
+    if (msg.role === 'assistant') {
+      for (const part of msg.content) {
+        if (part.type === 'text') items.push({ type: 'text', text: part.text })
+        else if (part.type === 'toolCall') items.push({ type: 'toolCall', name: part.name, args: part.arguments })
+      }
+    }
+  }
+  return items
+}

package/extensions/thinking.ts

@@ -10,6 +10,7 @@
  */
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import { createTurnOverride } from './internal/turn-override.js'
 
 // The pi ThinkingLevel union, taken from the setter's parameter so it tracks the SDK.
 type ThinkingLevel = Parameters<ExtensionAPI['setThinkingLevel']>[0]
@@ -34,17 +35,27 @@ export function requestedThinkingLevel(text: string): ThinkingLevel | undefined
 }
 
 export default function thinkingExtension(pi: ExtensionAPI) {
-  // The level to restore once the escalated turn settles, captured the first time a
-  // turn escalates so back-to-back keywords in one turn still restore the original.
-  // Cleared on agent_settled, the run's true end past any retry/compaction/Stop
-  // continuation, the same clearing point commands.ts uses for its model override.
-  let pendingRestore: ThinkingLevel | undefined
-  // The level this extension last escalated to. The restore is conditional on the level
-  // still being this target at settle: commands.ts also restores an `effort:` override
-  // on agent_settled, so both fire on the same event. Keying the restore on the target
-  // makes the outcome order-independent: if a command's restore (or a manual change)
-  // already moved the level, thinking stands down instead of clobbering it.
-  let pendingTarget: ThinkingLevel | undefined
+  // A per-turn escalation: the level to restore, captured the first time a turn escalates
+  // so back-to-back keywords still restore the original, and the target this extension
+  // moved to. The restore is conditional on the level still being that target at settle:
+  // commands.ts also restores an `effort:` override on agent_settled, so both fire on the
+  // same event. Keying the restore on the target makes the outcome order-independent: if a
+  // command's restore (or a manual change) already moved the level, thinking stands down
+  // instead of clobbering it. The capture clears on agent_settled, the run's true end past
+  // any retry/compaction/Stop continuation, the same clearing point commands.ts uses.
+  const override = createTurnOverride<ThinkingLevel>({
+    set: (level) => pi.setThinkingLevel?.(level),
+    get: () => pi.getThinkingLevel?.(),
+    conditional: true,
+  })
+
+  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.
+    override.reset()
+  })
 
   pi.on('input', (event, ctx) => {
     // Only genuine user input escalates. sendUserMessage emits an input event with
@@ -56,35 +67,27 @@ export default function thinkingExtension(pi: ExtensionAPI) {
     // signal that the prior prompt is gone: if this extension still owns the level (it is
     // exactly our escalation target), restore before handling this input. In the normal
     // path a settle already cleared pending, so this fires only for the blocked case.
-    if (pendingRestore !== undefined && (pi.getThinkingLevel?.() ?? ctx.thinkingLevel) === pendingTarget) {
-      pi.setThinkingLevel?.(pendingRestore)
-      pendingRestore = undefined
-      pendingTarget = undefined
+    const armedPrior = override.prior
+    if (armedPrior !== undefined && (pi.getThinkingLevel?.() ?? ctx.thinkingLevel) === override.target) {
+      pi.setThinkingLevel?.(armedPrior)
+      override.reset()
     }
     const target = requestedThinkingLevel(event.text)
     if (!target) return
     const current = pi.getThinkingLevel?.() ?? ctx.thinkingLevel ?? 'off'
     // A keyword only raises reasoning: leave a level already at or above the target.
     if (thinkingRank(current) >= thinkingRank(target)) return
-    pendingRestore = pendingRestore ?? current
-    pendingTarget = target
+    override.arm(current, target)
     pi.setThinkingLevel?.(target)
     // Return nothing so the input is neither consumed nor transformed: Claude keeps
     // the keyword in the prompt.
   })
 
   pi.on('agent_settled', () => {
-    if (pendingRestore === undefined) return
-    const restore = pendingRestore
-    const target = pendingTarget
-    pendingRestore = undefined
-    pendingTarget = undefined
-    // Restore only if nothing else moved the level since this extension set it. If a
-    // command's effort restore or the user's manual change already took over (current
-    // no longer equals our target), leave that value in place and stand down. When the
-    // level cannot be read, restore unconditionally, the prior best-effort behavior.
-    const current = pi.getThinkingLevel?.()
-    if (current !== undefined && current !== target) return
-    pi.setThinkingLevel?.(restore)
+    // Restore the pre-escalation level, but only if nothing else moved it since (a
+    // command's effort restore, a manual change): the conditional override stands down in
+    // that case and restores unconditionally when the level cannot be read, the prior
+    // best-effort behavior.
+    override.settle()
   })
 }

package/package.json

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