pi-code 0.1.0 → 0.2.1

package/extensions/plan-mode/index.ts

@@ -14,7 +14,7 @@
 
 import type { AgentMessage } from '@earendil-works/pi-agent-core'
 import type { AssistantMessage, TextContent } from '@earendil-works/pi-ai'
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import type { ExtensionAPI, ExtensionContext, SessionEntry } from '@earendil-works/pi-coding-agent'
 import { Key } from '@earendil-works/pi-tui'
 import { Type } from 'typebox'
 import { extractTodoItems, isSafeCommand, markCompletedSteps, planToTodos, type TodoItem } from './utils.js'
@@ -35,6 +35,23 @@ function getTextContent(message: AssistantMessage): string {
     .join('\n')
 }
 
+// Last element matching the predicate (the lib target predates Array.prototype.findLast)
+function findLast<T>(items: T[], match: (item: T) => boolean): T | undefined {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (match(items[i])) return items[i]
+  }
+  return undefined
+}
+
+// Index of the last plan-mode-execute entry, or -1 when the current run never started one
+function findLastExecuteIndex(entries: SessionEntry[]): number {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i] as { customType?: string }
+    if (entry.customType === 'plan-mode-execute') return i
+  }
+  return -1
+}
+
 export default function planModeExtension(pi: ExtensionAPI): void {
   let planModeEnabled = false
   let executionMode = false
@@ -108,6 +125,62 @@ export default function planModeExtension(pi: ExtensionAPI): void {
     })
   }
 
+  // Announce completion and reset once every step is done
+  function finalizeCompletedExecution(ctx: ExtensionContext): void {
+    if (!todoItems.every((t) => t.completed)) return
+    const completedList = todoItems.map((t) => `~~${t.text}~~`).join('\n')
+    pi.sendMessage({ customType: 'plan-complete', content: `**Plan Complete!** ✓\n\n${completedList}`, display: true }, { triggerTurn: false })
+    executionMode = false
+    todoItems = []
+    restoreTools()
+    updateStatus(ctx)
+    persistState() // Save cleared state so resume doesn't restore old execution mode
+  }
+
+  // Fall back to extracting a plan from the last assistant message's prose
+  function deriveTodosFromProse(messages: AgentMessage[]): void {
+    const lastAssistant = [...messages].reverse().find(isAssistantMessage)
+    if (!lastAssistant) return
+    const extracted = extractTodoItems(getTextContent(lastAssistant))
+    if (extracted.length > 0) {
+      todoItems = extracted
+    }
+  }
+
+  // Ask the user how to proceed after a plan is ready
+  async function promptPlanNextAction(ctx: ExtensionContext): Promise<void> {
+    const choice = await ctx.ui.select('Plan mode - what next?', [todoItems.length > 0 ? 'Execute the plan (track progress)' : 'Execute the plan', 'Stay in plan mode', 'Refine the plan'])
+
+    if (choice?.startsWith('Execute')) {
+      planModeEnabled = false
+      executionMode = todoItems.length > 0
+      planFromTool = false
+      restoreTools()
+      updateStatus(ctx)
+
+      const execMessage = todoItems.length > 0 ? `Execute the plan. Start with: ${todoItems[0].text}` : 'Execute the plan you just created.'
+      pi.sendMessage({ customType: 'plan-mode-execute', content: execMessage, display: true }, { triggerTurn: true })
+    } else if (choice === 'Refine the plan') {
+      const refinement = await ctx.ui.editor('Refine the plan:', '')
+      if (refinement?.trim()) {
+        pi.sendUserMessage(refinement.trim())
+      }
+    }
+  }
+
+  // Rebuild completion state from assistant messages after the last execute marker
+  function rescanCompletion(entries: SessionEntry[]): void {
+    const executeIndex = findLastExecuteIndex(entries)
+    const messages: AssistantMessage[] = []
+    for (let i = executeIndex + 1; i < entries.length; i++) {
+      const entry = entries[i]
+      if (entry.type === 'message' && 'message' in entry && isAssistantMessage(entry.message as AgentMessage)) {
+        messages.push(entry.message as AssistantMessage)
+      }
+    }
+    markCompletedSteps(messages.map(getTextContent).join('\n'), todoItems)
+  }
+
   pi.registerCommand('plan', {
     description: 'Toggle plan mode (read-only exploration)',
     handler: async (_args, ctx) => togglePlanMode(ctx),
@@ -193,7 +266,8 @@ You are in plan mode - a read-only exploration mode for safe code analysis.
 Restrictions:
 - You can only use: read, bash, grep, find, ls, question
 - You CANNOT use: edit, write (file modifications are disabled)
-- Bash is restricted to an allowlist of read-only commands
+- Bash is limited to an allowlist of read-only commands, checked per subcommand. Treat it
+  as a reminder of intent, not a sandbox: do not look for ways around it
 
 Ask clarifying questions using the question tool.
 
@@ -244,15 +318,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
   pi.on('agent_end', async (event, ctx) => {
     // Check if execution is complete
     if (executionMode && todoItems.length > 0) {
-      if (todoItems.every((t) => t.completed)) {
-        const completedList = todoItems.map((t) => `~~${t.text}~~`).join('\n')
-        pi.sendMessage({ customType: 'plan-complete', content: `**Plan Complete!** ✓\n\n${completedList}`, display: true }, { triggerTurn: false })
-        executionMode = false
-        todoItems = []
-        restoreTools()
-        updateStatus(ctx)
-        persistState() // Save cleared state so resume doesn't restore old execution mode
-      }
+      finalizeCompletedExecution(ctx)
       return
     }
 
@@ -260,13 +326,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
 
     // Prefer an explicitly submitted plan; fall back to extracting from prose
     if (!planFromTool) {
-      const lastAssistant = [...event.messages].reverse().find(isAssistantMessage)
-      if (lastAssistant) {
-        const extracted = extractTodoItems(getTextContent(lastAssistant))
-        if (extracted.length > 0) {
-          todoItems = extracted
-        }
-      }
+      deriveTodosFromProse(event.messages)
     }
 
     // Show plan steps and prompt for next action
@@ -282,23 +342,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
       )
     }
 
-    const choice = await ctx.ui.select('Plan mode - what next?', [todoItems.length > 0 ? 'Execute the plan (track progress)' : 'Execute the plan', 'Stay in plan mode', 'Refine the plan'])
-
-    if (choice?.startsWith('Execute')) {
-      planModeEnabled = false
-      executionMode = todoItems.length > 0
-      planFromTool = false
-      restoreTools()
-      updateStatus(ctx)
-
-      const execMessage = todoItems.length > 0 ? `Execute the plan. Start with: ${todoItems[0].text}` : 'Execute the plan you just created.'
-      pi.sendMessage({ customType: 'plan-mode-execute', content: execMessage, display: true }, { triggerTurn: true })
-    } else if (choice === 'Refine the plan') {
-      const refinement = await ctx.ui.editor('Refine the plan:', '')
-      if (refinement?.trim()) {
-        pi.sendUserMessage(refinement.trim())
-      }
-    }
+    await promptPlanNextAction(ctx)
   })
 
   // Restore state on session start/resume
@@ -310,7 +354,7 @@ After completing a step, include a [DONE:n] tag in your response.`,
     const entries = ctx.sessionManager.getEntries()
 
     // Restore persisted state
-    const planModeEntry = entries.filter((e: { type: string; customType?: string }) => e.type === 'custom' && e.customType === 'plan-mode').pop() as { data?: { enabled: boolean; todos?: TodoItem[]; executing?: boolean } } | undefined
+    const planModeEntry = findLast(entries, (e: { type: string; customType?: string }) => e.type === 'custom' && e.customType === 'plan-mode') as { data?: { enabled: boolean; todos?: TodoItem[]; executing?: boolean } } | undefined
 
     if (planModeEntry?.data) {
       planModeEnabled = planModeEntry.data.enabled ?? planModeEnabled
@@ -318,30 +362,11 @@ After completing a step, include a [DONE:n] tag in your response.`,
       executionMode = planModeEntry.data.executing ?? executionMode
     }
 
-    // On resume: re-scan messages to rebuild completion state
-    // Only scan messages AFTER the last "plan-mode-execute" to avoid picking up [DONE:n] from previous plans
+    // On resume: re-scan messages after the last "plan-mode-execute" to rebuild
+    // completion state without picking up [DONE:n] from previous plans
     const isResume = planModeEntry !== undefined
     if (isResume && executionMode && todoItems.length > 0) {
-      // Find the index of the last plan-mode-execute entry (marks when current execution started)
-      let executeIndex = -1
-      for (let i = entries.length - 1; i >= 0; i--) {
-        const entry = entries[i] as { type: string; customType?: string }
-        if (entry.customType === 'plan-mode-execute') {
-          executeIndex = i
-          break
-        }
-      }
-
-      // Only scan messages after the execute marker
-      const messages: AssistantMessage[] = []
-      for (let i = executeIndex + 1; i < entries.length; i++) {
-        const entry = entries[i]
-        if (entry.type === 'message' && 'message' in entry && isAssistantMessage(entry.message as AgentMessage)) {
-          messages.push(entry.message as AssistantMessage)
-        }
-      }
-      const allText = messages.map(getTextContent).join('\n')
-      markCompletedSteps(allText, todoItems)
+      rescanCompletion(entries)
     }
 
     if (planModeEnabled) {

package/extensions/plan-mode/utils.ts

@@ -27,7 +27,7 @@ const DESTRUCTIVE_PATTERNS = [
   /\bpip\s+(install|uninstall)/i,
   /\bapt(-get)?\s+(install|remove|purge|update|upgrade)/i,
   /\bbrew\s+(install|uninstall|upgrade)/i,
-  /\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-[dD]|stash|cherry-pick|revert|tag|init|clone)/i,
+  /\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-d|stash|cherry-pick|revert|tag|init|clone)/i,
   /\bsudo\b/i,
   /\bsu\b/i,
   /\bkill\b/i,
@@ -40,7 +40,9 @@ const DESTRUCTIVE_PATTERNS = [
   /\b(vim?|nano|emacs|code|subl)\b/i,
 ]
 
-// Safe read-only commands allowed in plan mode
+// Safe read-only commands allowed in plan mode. Deliberately excludes env/printenv
+// (secret disclosure, and env is an exec wrapper), curl/wget (fetch plus -o writes),
+// awk (system()) and sed (w/W/e write even under -n).
 const SAFE_PATTERNS = [
   /^\s*cat\b/,
   /^\s*head\b/,
@@ -65,8 +67,6 @@ const SAFE_PATTERNS = [
   /^\s*which\b/,
   /^\s*whereis\b/,
   /^\s*type\b/,
-  /^\s*env\b/,
-  /^\s*printenv\b/,
   /^\s*uname\b/,
   /^\s*whoami\b/,
   /^\s*id\b/,
@@ -83,21 +83,86 @@ const SAFE_PATTERNS = [
   /^\s*yarn\s+(list|info|why|audit)/i,
   /^\s*node\s+--version/i,
   /^\s*python\s+--version/i,
-  /^\s*curl\s/i,
-  /^\s*wget\s+-O\s*-/i,
   /^\s*jq\b/,
-  /^\s*sed\s+-n/i,
-  /^\s*awk\b/,
   /^\s*rg\b/,
   /^\s*fd\b/,
   /^\s*bat\b/,
   /^\s*eza\b/,
 ]
 
+// The shell can hide an arbitrary command inside any of these, so they are refused
+// outright rather than parsed.
+const SUBSTITUTION = /\$\(|`|<\(|>\(/
+
+/**
+ * Split on the shell separators Claude Code documents (`&&`, `||`, `;`, `|`, `|&`, `&`,
+ * newline) so every subcommand is checked on its own, ignoring separators inside quotes:
+ * `grep 'a|b'` is one read, not a pipe. Returns nothing on an unbalanced quote, which
+ * fails the caller closed rather than guessing at the intended split.
+ *
+ * A shell AST would be exact; this is the honest approximation for a quoting-only concern.
+ */
+function splitSegments(command: string): string[] {
+  const segments: string[] = []
+  let current = ''
+  let quote: "'" | '"' | undefined
+
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i]
+    if (quote !== undefined) {
+      current += ch
+      if (ch === quote) quote = undefined
+      continue
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch
+      current += ch
+      continue
+    }
+    if (ch === '\\' && i + 1 < command.length) {
+      current += ch + command[++i]
+      continue
+    }
+    const pair = command.slice(i, i + 2)
+    if (pair === '&&' || pair === '||' || pair === '|&') {
+      segments.push(current)
+      current = ''
+      i++
+      continue
+    }
+    if (ch === ';' || ch === '|' || ch === '&' || ch === '\n') {
+      segments.push(current)
+      current = ''
+      continue
+    }
+    current += ch
+  }
+
+  if (quote !== undefined) return []
+  segments.push(current)
+  return segments.map((segment) => segment.trim()).filter(Boolean)
+}
+
+// find is allowlisted for traversal only; these actions run commands or delete.
+const FIND_ACTIONS = /\s-(exec|execdir|ok|okdir|delete|fls|fprint|fprintf)\b/
+
+function isSafeSegment(segment: string): boolean {
+  if (DESTRUCTIVE_PATTERNS.some((p) => p.test(segment))) return false
+  if (!SAFE_PATTERNS.some((p) => p.test(segment))) return false
+  return !(/^\s*find\b/.test(segment) && FIND_ACTIONS.test(segment))
+}
+
+/**
+ * Whether plan mode should let this bash command run.
+ *
+ * Model steering, not a sandbox: an allowlisted interpreter can still read and write
+ * whatever the user can, so this narrows the blast radius of a wrong turn rather than
+ * containing a determined one. Only OS-level isolation would be a boundary.
+ */
 export function isSafeCommand(command: string): boolean {
-  const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(command))
-  const isSafe = SAFE_PATTERNS.some((p) => p.test(command))
-  return !isDestructive && isSafe
+  if (SUBSTITUTION.test(command)) return false
+  const segments = splitSegments(command)
+  return segments.length > 0 && segments.every(isSafeSegment)
 }
 
 export interface TodoItem {
@@ -123,16 +188,53 @@ export function cleanStepText(text: string): string {
   return cleaned
 }
 
+// Horizontal whitespace before the newline: \s would include \n itself and overlap
+// the following \n, which is what backtracks super-linearly.
+const PLAN_HEADER = /\*{0,2}Plan:\*{0,2}[^\S\n]*\n/i
+
+const isBlank = (ch: string | undefined): boolean => ch !== undefined && ch !== '\n' && ch.trim() === ''
+
+/**
+ * Text of a `1. step` / `2) step` line, stopping at an inline `*`, or undefined when
+ * the line is not a numbered step. Scanned rather than matched: the equivalent
+ * pattern needs adjacent quantifiers over overlapping classes, which backtracks
+ * super-linearly on a long line that turns out not to be a step.
+ */
+function numberedStepText(line: string): string | undefined {
+  let i = 0
+  while (isBlank(line[i])) i++
+
+  const digitsStart = i
+  while (line[i] >= '0' && line[i] <= '9') i++
+  if (i === digitsStart) return undefined
+
+  if (line[i] !== '.' && line[i] !== ')') return undefined
+  i++
+
+  const spaceStart = i
+  while (isBlank(line[i])) i++
+  if (i === spaceStart) return undefined // the marker must be followed by whitespace
+
+  for (let stars = 0; stars < 2 && line[i] === '*'; stars++) i++
+  const first = line[i]
+  if (first === undefined || first === '*' || isBlank(first)) return undefined
+
+  const rest = line.slice(i)
+  const star = rest.indexOf('*')
+  return star === -1 ? rest : rest.slice(0, star)
+}
+
 export function extractTodoItems(message: string): TodoItem[] {
   const items: TodoItem[] = []
-  const headerMatch = message.match(/\*{0,2}Plan:\*{0,2}\s*\n/i)
+  const headerMatch = PLAN_HEADER.exec(message)
   if (!headerMatch) return items
 
   const planSection = message.slice(message.indexOf(headerMatch[0]) + headerMatch[0].length)
-  const numberedPattern = /^\s*(\d+)[.)]\s+\*{0,2}([^*\n]+)/gm
 
-  for (const match of planSection.matchAll(numberedPattern)) {
-    const text = match[2]
+  for (const line of planSection.split('\n')) {
+    const captured = numberedStepText(line)
+    if (captured === undefined) continue
+    const text = captured
       .trim()
       .replace(/\*{1,2}$/, '')
       .trim()
@@ -170,6 +272,6 @@ export function markCompletedSteps(text: string, items: TodoItem[]): number {
  * the tool input is already known to be the plan itself.
  */
 export function planToTodos(plan: string): TodoItem[] {
-  const withHeader = /\*{0,2}Plan:\*{0,2}\s*\n/i.test(plan) ? plan : `Plan:\n${plan}`
+  const withHeader = PLAN_HEADER.test(plan) ? plan : `Plan:\n${plan}`
   return extractTodoItems(withHeader)
 }

package/extensions/project-approval.ts

@@ -0,0 +1,73 @@
+/**
+ * Project Approval
+ *
+ * `ctx.isProjectTrusted()` is not sufficient on its own. pi decides whether to ask for
+ * trust in `hasTrustRequiringProjectResources`, which looks only under `cwd/.pi` and for
+ * `.agents/skills`. A repository shipping just `.claude/` and `.mcp.json` matches neither,
+ * so `resolveProjectTrusted` short-circuits to `true` before it ever emits `project_trust`:
+ *
+ *     if (!hasTrustRequiringProjectResources(cwd)) return true
+ *     if (extensionsResult) { ...emitProjectTrustEvent... }
+ *
+ * A `project_trust` handler therefore cannot cover this case; the event only fires for
+ * projects pi was already going to prompt about. The decision has to be made where the
+ * project config is consumed instead, which is what this module does.
+ *
+ * Answers are stored in pi's own trust store, so approving here also satisfies pi if the
+ * project later grows `.pi` resources, and a decision recorded on a parent directory applies.
+ */
+
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { getAgentDir, hasTrustRequiringProjectResources, ProjectTrustStore } from '@earendil-works/pi-coding-agent'
+
+/** Project files pi-code acts on that pi's own trust check does not look for. */
+const CLAUDE_SHAPED = [path.join('.claude', 'settings.json'), path.join('.claude', 'settings.local.json'), path.join('.claude', 'agents'), path.join('.claude', 'hooks'), path.join('.claude', 'output-styles'), '.mcp.json', path.join('.pi', 'mcp.json'), path.join('.pi', 'agents')]
+
+export function hasClaudeShapedConfig(cwd: string): boolean {
+  return CLAUDE_SHAPED.some((entry) => fs.existsSync(path.join(cwd, entry)))
+}
+
+export interface ApprovalContext {
+  cwd: string
+  hasUI: boolean
+  isProjectTrusted?: () => boolean
+  ui: { confirm: (title: string, body: string) => Promise<boolean> }
+}
+
+export interface ApprovalDeps {
+  hasClaudeShaped: (cwd: string) => boolean
+  piWouldAsk: (cwd: string) => boolean
+  savedDecision: (cwd: string) => boolean | null
+  remember: (cwd: string, trusted: boolean) => void
+}
+
+const defaultDeps: ApprovalDeps = {
+  hasClaudeShaped: hasClaudeShapedConfig,
+  piWouldAsk: hasTrustRequiringProjectResources,
+  savedDecision: (cwd) => new ProjectTrustStore(getAgentDir()).get(cwd),
+  remember: (cwd, trusted) => new ProjectTrustStore(getAgentDir()).set(cwd, trusted),
+}
+
+const APPROVAL_BODY = 'It ships Claude Code configuration that pi-code loads. MCP servers, hooks and agents can run commands from this repository.'
+
+/**
+ * Whether project-controlled config may be acted on.
+ *
+ * Refuses without a UI rather than deferring: pi reached this point without consulting
+ * `defaultProjectTrust` at all, so there is no user preference to fall back on. A run
+ * that cannot ask has not been approved.
+ */
+export async function isProjectApproved(ctx: ApprovalContext, deps: ApprovalDeps = defaultDeps): Promise<boolean> {
+  if (ctx.isProjectTrusted?.() !== true) return false // pi already declined, or never trusted
+  if (!deps.hasClaudeShaped(ctx.cwd)) return true // nothing here pi's own check would miss
+  if (deps.piWouldAsk(ctx.cwd)) return true // pi genuinely prompted for this project
+
+  const stored = deps.savedDecision(ctx.cwd)
+  if (stored !== null) return stored
+  if (!ctx.hasUI) return false
+
+  const approved = await ctx.ui.confirm('Trust this project?', `${ctx.cwd}\n\n${APPROVAL_BODY}`)
+  deps.remember(ctx.cwd, approved)
+  return approved
+}

package/extensions/question.ts

@@ -4,7 +4,7 @@
  * Escape in editor returns to options, Escape in options cancels
  */
 
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import type { ExtensionAPI, Theme } from '@earendil-works/pi-coding-agent'
 import { Editor, type EditorTheme, Key, matchesKey, Text, truncateToWidth } from '@earendil-works/pi-tui'
 import { Type } from 'typebox'
 
@@ -33,6 +33,60 @@ const QuestionParams = Type.Object({
   options: Type.Array(OptionSchema, { description: 'Options for the user to choose from' }),
 })
 
+function optionLine(opt: DisplayOption, index: number, selected: boolean, editMode: boolean, theme: Theme): string {
+  const label = `${index + 1}. ${opt.label}`
+  const prefix = selected ? theme.fg('accent', '> ') : '  '
+  if (opt.isOther === true && editMode) {
+    return prefix + theme.fg('accent', `${label} ✎`)
+  }
+  if (selected) {
+    return prefix + theme.fg('accent', label)
+  }
+  return `  ${theme.fg('text', label)}`
+}
+
+interface QuestionView {
+  width: number
+  question: string
+  options: DisplayOption[]
+  optionIndex: number
+  editMode: boolean
+  editor: Editor
+  theme: Theme
+}
+
+function buildQuestionLines(view: QuestionView): string[] {
+  const { width, question, options, optionIndex, editMode, editor, theme } = view
+  const lines: string[] = []
+  const add = (s: string) => lines.push(truncateToWidth(s, width))
+
+  add(theme.fg('accent', '─'.repeat(width)))
+  add(theme.fg('text', ` ${question}`))
+  lines.push('')
+
+  for (let i = 0; i < options.length; i++) {
+    const opt = options[i]
+    add(optionLine(opt, i, i === optionIndex, editMode, theme))
+    if (opt.description) {
+      add(`     ${theme.fg('muted', opt.description)}`)
+    }
+  }
+
+  if (editMode) {
+    lines.push('')
+    add(theme.fg('muted', ' Your answer:'))
+    for (const line of editor.render(width - 2)) {
+      add(` ${line}`)
+    }
+  }
+
+  lines.push('')
+  add(theme.fg('dim', editMode ? ' Enter to submit • Esc to go back' : ' ↑↓ navigate • Enter to select • Esc to cancel'))
+  add(theme.fg('accent', '─'.repeat(width)))
+
+  return lines
+}
+
 export default function question(pi: ExtensionAPI) {
   pi.registerTool({
     name: 'question',
@@ -65,6 +119,7 @@ export default function question(pi: ExtensionAPI) {
         let optionIndex = 0
         let editMode = false
         let cachedLines: string[] | undefined
+        let cachedWidth: number | undefined
 
         const editorTheme: EditorTheme = {
           borderColor: (s) => theme.fg('accent', s),
@@ -135,58 +190,16 @@ export default function question(pi: ExtensionAPI) {
         }
 
         function render(width: number): string[] {
-          if (cachedLines) return cachedLines
-
-          const lines: string[] = []
-          const add = (s: string) => lines.push(truncateToWidth(s, width))
-
-          add(theme.fg('accent', '─'.repeat(width)))
-          add(theme.fg('text', ` ${params.question}`))
-          lines.push('')
-
-          for (let i = 0; i < allOptions.length; i++) {
-            const opt = allOptions[i]
-            const selected = i === optionIndex
-            const isOther = opt.isOther === true
-            const prefix = selected ? theme.fg('accent', '> ') : '  '
-
-            if (isOther && editMode) {
-              add(prefix + theme.fg('accent', `${i + 1}. ${opt.label} ✎`))
-            } else if (selected) {
-              add(prefix + theme.fg('accent', `${i + 1}. ${opt.label}`))
-            } else {
-              add(`  ${theme.fg('text', `${i + 1}. ${opt.label}`)}`)
-            }
-
-            // Show description if present
-            if (opt.description) {
-              add(`     ${theme.fg('muted', opt.description)}`)
-            }
-          }
-
-          if (editMode) {
-            lines.push('')
-            add(theme.fg('muted', ' Your answer:'))
-            for (const line of editor.render(width - 2)) {
-              add(` ${line}`)
-            }
-          }
-
-          lines.push('')
-          if (editMode) {
-            add(theme.fg('dim', ' Enter to submit • Esc to go back'))
-          } else {
-            add(theme.fg('dim', ' ↑↓ navigate • Enter to select • Esc to cancel'))
-          }
-          add(theme.fg('accent', '─'.repeat(width)))
-
-          cachedLines = lines
-          return lines
+          if (cachedLines && cachedWidth === width) return cachedLines
+          cachedWidth = width
+          cachedLines = buildQuestionLines({ width, question: params.question, options: allOptions, optionIndex, editMode, editor, theme })
+          return cachedLines
         }
 
         return {
           render,
           invalidate: () => {
+            cachedWidth = undefined
             cachedLines = undefined
           },
           handleInput,
@@ -231,7 +244,8 @@ export default function question(pi: ExtensionAPI) {
       if (opts.length) {
         const labels = opts.map((o: OptionWithDesc) => o.label)
         const numbered = [...labels, 'Type something.'].map((o, i) => `${i + 1}. ${o}`)
-        text += `\n${theme.fg('dim', `  Options: ${numbered.join(', ')}`)}`
+        const optionsLine = `  Options: ${numbered.join(', ')}`
+        text += `\n${theme.fg('dim', optionsLine)}`
       }
       return new Text(text, 0, 0)
     },

package/extensions/subagent/agents.ts

@@ -111,6 +111,17 @@ function findNearestDir(cwd: string, relative: string): string | null {
   }
 }
 
+function buildAgentMap(userAgents: AgentConfig[], projectAgents: AgentConfig[], scope: AgentScope): Map<string, AgentConfig> {
+  const agentMap = new Map<string, AgentConfig>()
+  const register = (agents: AgentConfig[]): void => {
+    for (const agent of agents) agentMap.set(agent.name, agent)
+  }
+  // user agents first so project agents win on name conflicts
+  if (scope !== 'project') register(userAgents)
+  if (scope !== 'user') register(projectAgents)
+  return agentMap
+}
+
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
   const userDir = path.join(getAgentDir(), 'agents')
   const claudeUserDir = path.join(os.homedir(), '.claude', 'agents')
@@ -122,17 +133,7 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
   // project .claude/agents loads first so project .pi/agents wins on name conflicts
   const projectAgents = scope === 'user' ? [] : [...(projectClaudeDir ? loadAgentsFromDir(projectClaudeDir, 'project') : []), ...(projectPiDir ? loadAgentsFromDir(projectPiDir, 'project') : [])]
 
-  const agentMap = new Map<string, AgentConfig>()
-
-  if (scope === 'both') {
-    for (const agent of userAgents) agentMap.set(agent.name, agent)
-    for (const agent of projectAgents) agentMap.set(agent.name, agent)
-  } else if (scope === 'user') {
-    for (const agent of userAgents) agentMap.set(agent.name, agent)
-  } else {
-    for (const agent of projectAgents) agentMap.set(agent.name, agent)
-  }
-
+  const agentMap = buildAgentMap(userAgents, projectAgents, scope)
   return { agents: Array.from(agentMap.values()), projectAgentsDir: projectPiDir }
 }