pi-code 1.0.9 → 1.0.11

package/extensions/memory.ts

@@ -14,11 +14,12 @@ import * as path from 'node:path'
 import { StringEnum } from '@earendil-works/pi-ai'
 import { type ExtensionAPI, withFileMutationQueue } from '@earendil-works/pi-coding-agent'
 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'
 
-const INDEX_FILE = 'MEMORY.md'
+export 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
@@ -282,7 +283,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(home, '.claude', 'settings.json')]
+  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))
@@ -306,6 +307,40 @@ export function readMemorySettings(files: string[]): { autoMemoryEnabled?: unkno
   return merged
 }
 
+/** Write `autoMemoryEnabled` into the user settings file, preserving every other key
+ * and creating the file and its config directory when absent. Claude's /memory toggle
+ * writes to the user scope (relocated by CLAUDE_CONFIG_DIR); the value takes effect from
+ * the next session start, which is where autoMemoryEnabled is read.
+ *
+ * An absent file starts from an empty object so the toggle still lands. A file that is
+ * PRESENT but unparseable is refused, not overwritten: clobbering it would destroy the
+ * user's hooks, env and permissions config. The caller surfaces the returned failure. */
+export function setAutoMemoryEnabledSetting(home: string, value: boolean): { ok: true } | { ok: false; error: string } {
+  const dir = claudeConfigDir(home)
+  const file = path.join(dir, 'settings.json')
+  let current: Record<string, unknown> = {}
+  let raw: string | undefined
+  try {
+    raw = fs.readFileSync(file, 'utf-8')
+  } catch (error) {
+    // Only a missing file means start fresh; any other read failure propagates.
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
+  }
+  if (raw !== undefined) {
+    try {
+      const parsed = JSON.parse(raw)
+      if (parsed !== null && typeof parsed === 'object') current = parsed as Record<string, unknown>
+    } catch {
+      // Present but unparseable: refuse rather than overwrite the user's config.
+      return { ok: false, error: 'settings.json is not valid JSON; not modified' }
+    }
+  }
+  current.autoMemoryEnabled = value
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(file, `${JSON.stringify(current, null, 2)}\n`)
+  return { ok: true }
+}
+
 export default function memoryExtension(pi: ExtensionAPI) {
   let dir = memoryDir(process.cwd())
   let enabled = true
@@ -409,4 +444,53 @@ export default function memoryExtension(pi: ExtensionAPI) {
       return { content: [{ type: 'text' as const, text: index.trim() || 'No memories saved for this project yet.' }], details: {} }
     },
   })
+
+  // Claude's /memory lists the memory locations and toggles auto memory. pi has no
+  // editor seam, so the paths are printed rather than opened. The listing reads the
+  // settings chain live so it reflects a toggle written in the same session.
+  pi.registerCommand('memory', {
+    description: 'Show memory file locations and toggle auto memory (/memory [on|off])',
+    handler: async (args, ctx) => {
+      const home = os.homedir()
+      const arg = args.trim().toLowerCase()
+
+      if (arg === 'on' || arg === 'off') {
+        const next = arg === 'on'
+        let result: { ok: true } | { ok: false; error: string }
+        try {
+          result = setAutoMemoryEnabledSetting(home, next)
+        } catch (error) {
+          ctx.ui.notify(`Could not update auto memory: ${error instanceof Error ? error.message : String(error)}`, 'error')
+          return
+        }
+        if (!result.ok) {
+          ctx.ui.notify(result.error, 'error')
+          return
+        }
+        ctx.ui.notify(`Auto memory ${next ? 'enabled' : 'disabled'} in ${path.join(claudeConfigDir(home), 'settings.json')} (applies next session).`, 'info')
+        return
+      }
+
+      if (arg.length > 0) {
+        ctx.ui.notify('Usage: /memory [on|off]', 'error')
+        return
+      }
+
+      const approved = isProjectApprovedSilently(ctx)
+      const settings = readMemorySettings(memorySettingsFiles(ctx.cwd, home, approved))
+      const isEnabled = autoMemoryEnabled(settings.autoMemoryEnabled, process.env)
+      const override = typeof settings.autoMemoryDirectory === 'string' ? settings.autoMemoryDirectory : undefined
+      const store = resolveMemoryDir(ctx.cwd, override)
+      const lines = [
+        'Memory',
+        `  Auto memory: ${isEnabled ? 'on' : 'off'}`,
+        `  Store:       ${store}`,
+        `  Index:       ${path.join(store, INDEX_FILE)}`,
+        `  User memory (CLAUDE.md):    ${path.join(home, '.claude', 'CLAUDE.md')}`,
+        `  Project memory (CLAUDE.md): ${path.join(ctx.cwd, 'CLAUDE.md')}`,
+        'Toggle with /memory on or /memory off.',
+      ]
+      ctx.ui.notify(lines.join('\n'), 'info')
+    },
+  })
 }

package/extensions/notify.ts

@@ -21,6 +21,8 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
+import { claudeConfigDir } from './internal/config-dir.js'
+
 /** How a finished turn is announced, from Claude's `preferredNotifChannel`. */
 export type NotifChannel = 'desktop' | 'bell' | 'both' | 'off'
 
@@ -55,7 +57,7 @@ export function isAway(lastInputAt: number | undefined, now: number, thresholdMs
  * or change your notifications. */
 function readPreferredNotifChannel(home: string): unknown {
   try {
-    const settings = JSON.parse(fs.readFileSync(path.join(home, '.claude', 'settings.json'), 'utf-8'))
+    const settings = JSON.parse(fs.readFileSync(path.join(claudeConfigDir(home), 'settings.json'), 'utf-8'))
     return settings?.preferredNotifChannel
   } catch {
     return undefined

package/extensions/output-styles.ts

@@ -24,6 +24,7 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
+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'
@@ -82,7 +83,7 @@ function isDirectory(target: string): boolean {
  * verbatim into the system prompt.
  */
 export function styleDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const dirs = [path.join(home, '.claude', 'output-styles')]
+  const dirs = [path.join(claudeConfigDir(home), 'output-styles')]
   if (trusted) dirs.push(findNearestDir(cwd, path.join('.claude', 'output-styles')) ?? path.join(cwd, '.claude', 'output-styles'))
   return dirs.filter((dir) => isDirectory(dir))
 }
@@ -129,7 +130,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(home, '.claude', 'settings.json')]
+  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))
@@ -199,6 +200,13 @@ export default function outputStylesExtension(pi: ExtensionAPI) {
 
   pi.registerCommand('output-style', {
     description: 'Choose the active Claude output style (or /output-style <name>)',
+    // /output-style <name> takes a style name, so complete the discovered names by the
+    // typed prefix (case-insensitive, like the handler's own name lookup). An empty
+    // prefix offers every style.
+    getArgumentCompletions: (argumentPrefix) => {
+      const prefix = argumentPrefix.trim().toLowerCase()
+      return styles.filter((style) => style.name.toLowerCase().startsWith(prefix)).map((style) => ({ value: style.name, label: style.name, ...(style.description ? { description: style.description } : {}) }))
+    },
     handler: async (args, ctx) => {
       const requested = args.trim()
       if (requested) {

package/extensions/session-title.ts

@@ -0,0 +1,126 @@
+/**
+ * Session Auto-Title Extension
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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
+ * new session resets the guard.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+
+import { completeText } from './internal/model-complete.js'
+
+const TITLE_SYSTEM = 'You name a coding session from its first user message. Reply with a terse 3 to 6 word title in Title Case that captures the task. No quotes, no surrounding punctuation, no trailing period. Output the title only, nothing else.'
+/** A title is a few words; a tight cap keeps the extra call cheap and stops a runaway reply. */
+const TITLE_MAX_TOKENS = 24
+/** The first message can be huge; only its opening is needed to name the session, and a
+ * bounded prompt keeps the input cost of the extra call small. */
+const MAX_PROMPT_CHARS = 1000
+
+/** Join the text of a message's content, mirroring git-checkpoint's extraction: content is
+ * either a plain string or an array of parts, of which only text parts carry a title's worth. */
+function extractText(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join(' ')
+}
+
+/** Text of the first user message in the branch, or empty when the run carried no user text
+ * (for example a slash-command-only turn), in which case there is nothing to title from. */
+export function firstUserText(ctx: ExtensionContext): string {
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry?.type === 'message' && entry.message.role === 'user') {
+      return extractText(entry.message.content).trim()
+    }
+  }
+  return ''
+}
+
+/** Wrapping quotes (straight, smart, and backtick) and trailing sentence punctuation that
+ * cleanTitle peels, held as plain strings so the trims below can test membership by index
+ * rather than with an anchored regex. */
+const WRAPPING_QUOTES = '"\'`“”‘’'
+const TRAILING_PUNCTUATION = '.,;:!?'
+
+/** Strip runs of `chars` from both ends of `value` in linear time. The equivalent
+ * /^[chars]+|[chars]+$/g backtracks super-linearly on a long run (S8786). */
+function trimBothEnds(value: string, chars: string): string {
+  let start = 0
+  let end = value.length
+  while (start < end && chars.includes(value[start])) start++
+  while (end > start && chars.includes(value[end - 1])) end--
+  return value.slice(start, end)
+}
+
+/** Strip a trailing run of `chars` from `value` in linear time. The equivalent
+ * /[chars]+$/g backtracks super-linearly on a long trailing run (S8786). */
+function trimTrailing(value: string, chars: string): string {
+  let end = value.length
+  while (end > 0 && chars.includes(value[end - 1])) end--
+  return value.slice(0, end)
+}
+
+/** Trim the model's reply to a bare title: collapse whitespace, then peel wrapping quotes
+ * and trailing punctuation until stable, so `"Fix The Parser."` and `Fix The Parser.` both
+ * land on the plain phrase. */
+export function cleanTitle(raw: string): string {
+  let title = raw.trim().replace(/\s+/g, ' ')
+  let prev: string
+  do {
+    prev = title
+    title = trimTrailing(trimBothEnds(title, WRAPPING_QUOTES), TRAILING_PUNCTUATION).trim()
+  } while (title !== prev)
+  return title
+}
+
+export default function sessionTitleExtension(pi: ExtensionAPI) {
+  // One title per session, reset when a new session takes over so a resumed or forked
+  // session can still earn its own name.
+  let titled = false
+
+  pi.on('session_start', () => {
+    titled = false
+  })
+
+  pi.on('agent_settled', async (_event, ctx) => {
+    if (titled) return
+    // Never clobber an existing name: a user-chosen or resumed name wins.
+    if (pi.getSessionName?.()) return
+    const model = ctx.model
+    if (!model) return // headless with no model: nothing to name with, and the guard is left unspent
+    const prompt = firstUserText(ctx)
+    if (!prompt) return // no user text this run: leave the guard unspent for a later real message
+
+    // Claim the single attempt before the await, so overlapping or repeated settles cannot
+    // each fire a model call; a failed attempt below is not retried within this session.
+    titled = true
+    let title: string
+    try {
+      const { text } = await completeText(model, `First user message of a new coding session:\n\n${prompt.slice(0, MAX_PROMPT_CHARS)}`, {
+        system: TITLE_SYSTEM,
+        maxTokens: TITLE_MAX_TOKENS,
+      })
+      title = cleanTitle(text)
+    } catch {
+      return // no model, provider error: leave the session untitled (best-effort)
+    }
+    if (!title) return
+    pi.setSessionName(title)
+    ctx.ui.setTitle?.(title)
+  })
+}

package/extensions/skills.ts

@@ -15,6 +15,7 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
+import { claudeConfigDir } from './internal/config-dir.js'
 import { installedPlugins } from './internal/plugins.js'
 import { isProjectApprovedSilently } from './internal/project-approval.js'
 import { findNearestDir } from './internal/project-root.js'
@@ -33,7 +34,7 @@ function isDirectory(target: string): boolean {
  * name and description to the model, so an untrusted repository would otherwise get
  * text into the prompt without the user ever agreeing to load its config. */
 export function skillDirs(cwd: string, home: string, trusted: boolean): string[] {
-  const candidates = [path.join(home, '.claude', 'skills')]
+  const candidates = [path.join(claudeConfigDir(home), 'skills')]
   // Enabled plugins contribute their skills directories. pi's loader names a
   // skill by its directory, so a plugin skill registers without Claude's
   // /plugin: prefix; a rename-free approximation, disclosed in the README.

package/extensions/status-line.ts

@@ -64,6 +64,66 @@ function formatCost(cost: number): string {
   return cost >= 0.01 ? `$${cost.toFixed(2)}` : `$${cost.toFixed(4)}`
 }
 
+interface RateLimitWindow {
+  used_percentage: number
+  resets_at?: string
+}
+interface RateLimitSnapshot {
+  five_hour?: RateLimitWindow
+  seven_day?: RateLimitWindow
+}
+
+/** Lowercase every header name (HTTP names are case-insensitive) and drop null
+ * values, so a single lookup shape works regardless of how the provider cased
+ * them. ProviderHeaders values are string | null. */
+function normalizeHeaders(raw: Record<string, string | null> | undefined): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const [key, value] of Object.entries(raw ?? {})) {
+    if (typeof value === 'string') out[key.toLowerCase()] = value
+  }
+  return out
+}
+
+function toNumber(value: string | undefined): number | undefined {
+  if (value === undefined || value.trim() === '') return undefined
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : undefined
+}
+
+/** One rate-limit window from the `anthropic-ratelimit-<prefix>-*` header family,
+ * taking a direct `-utilization` percentage when present, else computing it from
+ * `-limit` and `-remaining`. resets_at comes from `-reset` when the header is set.
+ * Header names vary, so only what is present is read and a bare number is enough. */
+function readRateLimitWindow(headers: Record<string, string>, prefix: string): RateLimitWindow | undefined {
+  const base = `anthropic-ratelimit-${prefix}`
+  let usedPercentage = toNumber(headers[`${base}-utilization`])
+  if (usedPercentage === undefined) {
+    const limit = toNumber(headers[`${base}-limit`])
+    const remaining = toNumber(headers[`${base}-remaining`])
+    if (limit !== undefined && limit > 0 && remaining !== undefined) {
+      usedPercentage = ((limit - remaining) / limit) * 100
+    }
+  }
+  if (usedPercentage === undefined) return undefined
+  const window: RateLimitWindow = { used_percentage: usedPercentage }
+  const resetsAt = headers[`${base}-reset`] ?? headers[`${base}-resets-at`]
+  if (resetsAt) window.resets_at = resetsAt
+  return window
+}
+
+/** The five-hour and seven-day utilization windows Claude's statusline reports,
+ * from the unified rate-limit response headers. Undefined when neither is present
+ * so a response without them never clobbers an earlier snapshot. */
+function parseRateLimits(headers: Record<string, string>): RateLimitSnapshot | undefined {
+  const fiveHour = readRateLimitWindow(headers, 'unified-5h')
+  const sevenDay = readRateLimitWindow(headers, 'unified-7d')
+  if (!fiveHour && !sevenDay) return undefined
+  const snapshot: RateLimitSnapshot = {}
+  if (fiveHour) snapshot.five_hour = fiveHour
+  if (sevenDay) snapshot.seven_day = sevenDay
+  return snapshot
+}
+
 export interface StatusLineConfig {
   command: string
   padding: number
@@ -120,6 +180,10 @@ export default function statusLine(pi: ExtensionAPI) {
   let apiDurationMs = 0
   let requestStartMs: number | undefined
   let lastUsage: { input: number; output: number; cacheRead: number; cacheWrite: number; totalTokens: number } | undefined
+  // The most recent rate-limit snapshot parsed from provider response headers, and
+  // a once-per-session guard so a 429 warns the user only the first time it lands.
+  let rateLimits: RateLimitSnapshot | undefined
+  let rateLimitWarned = false
   let refreshTimer: ReturnType<typeof setInterval> | undefined
   let debounceTimer: ReturnType<typeof setTimeout> | undefined
   let running = false
@@ -193,6 +257,9 @@ export default function statusLine(pi: ExtensionAPI) {
       payload.thinking = { enabled: ctx.thinkingLevel !== 'off' }
     }
     if (styleName) payload.output_style = { name: styleName }
+    // The current utilization of the account's rate-limit windows, when the
+    // provider reported them; omitted entirely until a response has carried them.
+    if (rateLimits) payload.rate_limits = rateLimits
     return payload
   }
 
@@ -260,9 +327,24 @@ export default function statusLine(pi: ExtensionAPI) {
   pi.on('before_provider_request', async () => {
     requestStartMs = Date.now()
   })
-  pi.on('after_provider_response', async () => {
+  pi.on('after_provider_response', async (event, ctx) => {
     if (requestStartMs !== undefined) apiDurationMs += Date.now() - requestStartMs
     requestStartMs = undefined
+    // Rate-limit windows and 429 handling ride on the same response event. Header
+    // names and presence vary, so parse only what is there and never throw.
+    const headers = normalizeHeaders(event.headers)
+    const snapshot = parseRateLimits(headers)
+    if (snapshot) rateLimits = snapshot
+    if (event.status === 429 && !rateLimitWarned) {
+      rateLimitWarned = true
+      const retryAfter = headers['retry-after']
+      const detail = retryAfter ? `; retry after ${retryAfter}s` : ''
+      try {
+        ctx.ui.notify(`Provider rate limit reached (429)${detail}`, 'warning')
+      } catch {
+        // The session may be gone by the time a late response lands; nothing to warn.
+      }
+    }
   })
   // The last message's token usage, for the breakdown getContextUsage() omits,
   // and the running cost total, so renders never re-walk the branch.
@@ -284,6 +366,8 @@ export default function statusLine(pi: ExtensionAPI) {
     apiDurationMs = 0
     requestStartMs = undefined
     lastUsage = undefined
+    rateLimits = undefined
+    rateLimitWarned = false
     clearInterval(refreshTimer)
     // Seed the running cost from the branch: a resumed or forked session starts
     // with history, and message_end only accumulates from here on.
@@ -327,6 +411,15 @@ export default function statusLine(pi: ExtensionAPI) {
     scheduleRefresh()
   })
 
+  // The model and effort segments of the payload go stale between turns; a switch
+  // fires these events, so refresh at once instead of waiting for the next tick.
+  pi.on('model_select', async () => {
+    scheduleRefresh()
+  })
+  pi.on('thinking_level_select', async () => {
+    scheduleRefresh()
+  })
+
   pi.on('session_compact', async (_event, ctx) => {
     // Compaction replaces the branch entries; reseed the total from what remains.
     costTotal = sessionCost(ctx)

package/extensions/subagent/agents.ts

@@ -11,6 +11,7 @@ import { getAgentDir, parseFrontmatter, stripFrontmatter } from '@earendil-works
 // Claude field, and `--tools` is an exact-name allowlist, so a name pi has no tool for
 // is not merely ignored, it narrows the child's registry.
 import { parseToolGrants } from '../internal/command-file.js'
+import { claudeConfigDir } from '../internal/config-dir.js'
 import { installedPlugins } from '../internal/plugins.js'
 import { findNearestDir } from '../internal/project-root.js'
 
@@ -291,7 +292,7 @@ function pluginAgentDirs(home: string): string[] {
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
   const userDir = path.join(getAgentDir(), 'agents')
-  const claudeUserDir = path.join(os.homedir(), '.claude', 'agents')
+  const claudeUserDir = path.join(claudeConfigDir(os.homedir()), 'agents')
   const projectPiDir = findNearestDir(cwd, path.join('.pi', 'agents'))
   const projectClaudeDir = findNearestDir(cwd, path.join('.claude', 'agents'))
 

package/extensions/subagent/index.ts

@@ -24,6 +24,7 @@ import { type ExtensionAPI, type ExtensionContext, getMarkdownTheme, type Theme,
 import { Container, Markdown, Spacer, Text } from '@earendil-works/pi-tui'
 import { type Static, Type } from 'typebox'
 import { type AgentRunRequest, setAgentRunner } from '../internal/agent-run.js'
+import { claudeConfigDir } from '../internal/config-dir.js'
 import { capForContext } from '../internal/output-guard.js'
 import { isProjectApproved, isProjectApprovedSilently } from '../internal/project-approval.js'
 import { repoRoot } from '../internal/project-root.js'
@@ -697,7 +698,7 @@ export function agentMemoryDir(scope: AgentMemoryScope, name: string, cwd: strin
   const sanitized = name.replace(/[^\w.-]+/g, '_')
   // A name of only dots ('.', '..') survives the character filter but still traverses.
   const segment = /^\.+$/.test(sanitized) ? '_' : sanitized
-  if (scope === 'user') return path.join(home, '.claude', 'agent-memory', segment)
+  if (scope === 'user') return path.join(claudeConfigDir(home), 'agent-memory', segment)
   const root = repoRoot(cwd) ?? cwd
   return path.join(root, '.claude', scope === 'project' ? 'agent-memory' : 'agent-memory-local', segment)
 }

package/extensions/thinking.ts

@@ -0,0 +1,80 @@
+/**
+ * Thinking Keyword Escalation
+ *
+ * Claude Code raises reasoning effort for a single turn when the prompt carries a
+ * think keyword: `ultrathink` asks for the maximum, `think hard`/`think harder` for
+ * a high level, and a bare `think` for a medium one. The word stays in the prompt
+ * (the input is observed, never consumed or transformed), the escalation only ever
+ * raises the level, and the prior level is restored once the turn settles, mirroring
+ * how commands.ts restores a per-command model override on agent_settled.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+// The pi ThinkingLevel union, taken from the setter's parameter so it tracks the SDK.
+type ThinkingLevel = Parameters<ExtensionAPI['setThinkingLevel']>[0]
+
+/** Lowest to highest, matching pi's ThinkingLevel union; rank is the index. */
+const THINKING_ORDER: readonly ThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+
+export function thinkingRank(level: ThinkingLevel): number {
+  const i = THINKING_ORDER.indexOf(level)
+  return Math.max(i, 0)
+}
+
+/** The reasoning level a prompt requests through Claude's think keywords, or undefined
+ * when it names none. Checked most-specific first so `think harder` does not fall
+ * through to the bare-`think` branch, and on word boundaries so `rethink`/`thinking`
+ * and the whole word `ultrathink` never trip the bare match. */
+export function requestedThinkingLevel(text: string): ThinkingLevel | undefined {
+  if (/\bultrathink\b/i.test(text)) return 'max'
+  if (/\bthink harder\b/i.test(text) || /\bthink hard\b/i.test(text)) return 'high'
+  if (/\bthink\b/i.test(text)) return 'medium'
+  return 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
+
+  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
+    // think keyword the user did not type must not escalate, mirroring hooks.ts's guard.
+    if (event.source === 'extension') return
+    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
+    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)
+  })
+}

package/package.json

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