pi-code 1.0.8 → 1.0.10

package/extensions/status-line.ts

@@ -13,8 +13,10 @@
  * the built-in segment stands in.
  *
  * Without a configured statusLine, the built-in segment shows turn state plus
- * running session cost, summed from per-message usage on the current branch so it
- * stays correct across /tree navigation and forks. The built-in segment is also
+ * running session cost: a total seeded from the branch's per-message usage at
+ * session start, accumulated per message_end, and reseeded when compaction or
+ * /tree navigation reshapes the branch, so it stays correct across navigation
+ * and forks without re-walking the branch on every render. The built-in segment is also
  * the fallback while a configured command produces no output. Multi-line output
  * is truncated to its first line: the segment is one footer row in pi.
  *
@@ -48,6 +50,8 @@ interface UsageEntry {
   message?: { usage?: { cost?: { total?: number } } }
 }
 
+/** Full branch walk: used only to (re)seed the running total, at session start
+ * and on the events that reshape the branch. Renders read the total instead. */
 function sessionCost(ctx: ExtensionContext): number {
   let total = 0
   for (const entry of ctx.sessionManager.getBranch() as UsageEntry[]) {
@@ -95,8 +99,17 @@ export default function statusLine(pi: ExtensionAPI) {
   let sessionCtx: ExtensionContext | undefined
   let commandLine: string | undefined
   let permissionMode = 'default'
-  let projectApproved = false
   let sessionStartMs = Date.now()
+  // Running session cost; seeded and reseeded by sessionCost(), see below.
+  let costTotal = 0
+  // The output-style settings chain and active style name, resolved once at
+  // session start: the chain's upward walk and per-file reads are too costly for
+  // every refresh tick. /output-style persists a choice straight to settings with
+  // no bus event, and the new style applies from the next turn anyway, so the
+  // cached name is re-read lazily at most once per turn (styleDirty, turn_start).
+  let styleFiles: string[] = []
+  let styleName: string | undefined
+  let styleDirty = false
   // Lines changed, counted from successful edit/write inputs: newText and content
   // lines add, oldText lines remove. An approximation of Claude's counters, which
   // is honest for the tools pi has; bash-side changes are invisible to both.
@@ -114,8 +127,7 @@ export default function statusLine(pi: ExtensionAPI) {
 
   function segmentText(ctx: ExtensionContext, symbol: string): string {
     const theme = ctx.ui.theme
-    const cost = sessionCost(ctx)
-    const costText = cost > 0 ? theme.fg('muted', ` ${formatCost(cost)}`) : ''
+    const costText = costTotal > 0 ? theme.fg('muted', ` ${formatCost(costTotal)}`) : ''
     const turnText = turnCount > 0 ? theme.fg('dim', ` turn ${turnCount}`) : theme.fg('dim', ' ready')
     return symbol + turnText + costText
   }
@@ -128,9 +140,11 @@ export default function statusLine(pi: ExtensionAPI) {
   function buildPayload(ctx: ExtensionContext): Record<string, unknown> {
     const usage = ctx.getContextUsage() ?? { tokens: null, contextWindow: 0, percent: null }
     const model = ctx.model as { id?: string; name?: string } | undefined
-    // Same gate as the config read above: an unapproved project's style is not applied,
-    // so reporting it here would describe a style the session is not using.
-    const styleName = readActiveStyleName(settingsFiles(ctx.cwd, os.homedir(), projectApproved))
+    // Refresh the cached style name only when a turn boundary may have changed it.
+    if (styleDirty) {
+      styleName = readActiveStyleName(styleFiles)
+      styleDirty = false
+    }
     const payload: Record<string, unknown> = {
       hook_event_name: 'Status',
       session_id: ctx.sessionManager.getSessionId(),
@@ -141,7 +155,7 @@ export default function statusLine(pi: ExtensionAPI) {
       // read .model.display_name and render the literal "null" when it is missing.
       model: { id: model?.id ?? '', display_name: model?.name ?? model?.id ?? '' },
       cost: {
-        total_cost_usd: sessionCost(ctx),
+        total_cost_usd: costTotal,
         total_duration_ms: Date.now() - sessionStartMs,
         total_api_duration_ms: apiDurationMs,
         total_lines_added: linesAdded,
@@ -250,10 +264,13 @@ export default function statusLine(pi: ExtensionAPI) {
     if (requestStartMs !== undefined) apiDurationMs += Date.now() - requestStartMs
     requestStartMs = undefined
   })
-  // The last message's token usage, for the breakdown getContextUsage() omits.
+  // The last message's token usage, for the breakdown getContextUsage() omits,
+  // and the running cost total, so renders never re-walk the branch.
   pi.on('message_end', async (event) => {
-    const usage = (event as { message?: { usage?: NonNullable<typeof lastUsage> } }).message?.usage
-    if (usage) lastUsage = usage
+    const usage = (event as { message?: { usage?: NonNullable<typeof lastUsage> & { cost?: { total?: number } } } }).message?.usage
+    if (!usage) return
+    lastUsage = usage
+    costTotal += usage.cost?.total ?? 0
   })
 
   pi.on('session_start', async (_event, ctx) => {
@@ -268,11 +285,18 @@ export default function statusLine(pi: ExtensionAPI) {
     requestStartMs = undefined
     lastUsage = undefined
     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.
+    costTotal = sessionCost(ctx)
     // Reading config must never open a trust dialog: several extensions resolve
     // approval at session start, and a second prompt stacks over the first and eats
     // the keys meant for it. An undecided project simply skips project settings.
     const trusted = isProjectApprovedSilently(ctx)
-    projectApproved = trusted
+    // Same gate for the style chain: an unapproved project's style is not applied,
+    // so reporting it in the payload would describe a style the session is not using.
+    styleFiles = settingsFiles(ctx.cwd, os.homedir(), trusted)
+    styleName = readActiveStyleName(styleFiles)
+    styleDirty = false
     const files = hookFiles(ctx.cwd, os.homedir(), trusted)
     // Claude's disableAllHooks also turns off the custom statusLine command; the
     // built-in segment still renders as the fallback.
@@ -286,6 +310,9 @@ export default function statusLine(pi: ExtensionAPI) {
 
   pi.on('turn_start', async (_event, ctx) => {
     turnCount++
+    // A /output-style between turns lands in settings silently; its style applies
+    // from this turn, so this is the moment the cached name can go stale.
+    styleDirty = true
     const theme = ctx.ui.theme
     show(ctx, theme.fg('accent', '●') + theme.fg('dim', ` turn ${turnCount}...`))
   })
@@ -300,10 +327,17 @@ export default function statusLine(pi: ExtensionAPI) {
     scheduleRefresh()
   })
 
-  pi.on('session_compact', async (_event, _ctx) => {
+  pi.on('session_compact', async (_event, ctx) => {
+    // Compaction replaces the branch entries; reseed the total from what remains.
+    costTotal = sessionCost(ctx)
     scheduleRefresh()
   })
 
+  pi.on('session_tree', async (_event, ctx) => {
+    // Tree navigation swaps the branch wholesale with no message_end events.
+    costTotal = sessionCost(ctx)
+  })
+
   pi.on('session_shutdown', async () => {
     clearInterval(refreshTimer)
     clearTimeout(debounceTimer)

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)
 }
@@ -1352,7 +1353,16 @@ export default function subagentExtension(pi: ExtensionAPI) {
   // available model list are captured per session so a hook run lands in the right repo.
   let hookCwd = process.cwd()
   let hookModels: ReadonlyArray<{ id: string }> = []
+
+  // Discovery walks the plugin cache, the builtin dir, and every agent dir, parsing
+  // each file: dozens of fs ops per call. The roster injection below runs every turn
+  // for a list that almost never changes mid-session, so it reuses one discovery per
+  // (cwd, scope), dropped on session_start. The tool's execute() keeps rediscovering
+  // per invocation, so a just-added agent is still runnable without a restart.
+  let rosterCache: { key: string; agents: AgentConfig[] } | null = null
+
   pi.on('session_start', async (_event, ctx) => {
+    rosterCache = null
     hookCwd = ctx.cwd
     try {
       hookModels = ctx.modelRegistry?.getAvailable?.() ?? []
@@ -1378,12 +1388,15 @@ export default function subagentExtension(pi: ExtensionAPI) {
   })
 
   // Claude surfaces each agent's description so the model can pick one autonomously.
-  // Rebuilt per turn (agents are rediscovered per invocation too); project agents are
-  // included only when the project is already approved, read without prompting, since
-  // a trust dialog must not appear mid-turn and their descriptions are project text.
+  // 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
+  // project is already approved, read without prompting, since a trust dialog must
+  // not appear mid-turn and their descriptions are project text.
   pi.on('before_agent_start', async (event, ctx) => {
-    const scope = isProjectApprovedSilently(ctx) ? 'both' : 'user'
-    const { agents } = discoverAgents(ctx.cwd, scope)
+    const scope: AgentScope = isProjectApprovedSilently(ctx) ? 'both' : 'user'
+    const key = `${scope}\n${ctx.cwd}`
+    if (rosterCache?.key !== key) rosterCache = { key, agents: discoverAgents(ctx.cwd, scope).agents }
+    const { agents } = rosterCache
     if (agents.length === 0) return
     const line = (text: string): string => text.replace(/\s+/g, ' ').trim().slice(0, 200)
     const roster = agents.map((agent) => `- ${agent.name} (${agent.source}): ${line(agent.description)}`).join('\n')

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.8",
+  "version": "1.0.10",
   "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",