pi-code 1.0.46 → 1.0.48

package/README.md

@@ -11,7 +11,7 @@
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_pi-code&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_pi-code)
 [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_pi-code&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_pi-code)
 
-Claude Code experience for the [pi](https://pi.dev) coding agent, in one package. Point pi at a project that already has a `.claude/` directory and it reads your existing config: rules, commands, skills, hooks, output styles, MCP servers, and agents. It also adds the Claude Code features pi lacks: a todo overlay, checkpoints, memory, web search, and subagents.
+Claude Code experience for the [pi](https://pi.dev) coding agent, in one package. Point pi at a project that already has a `.claude/` directory and it reads your existing config: rules, commands, skills, hooks, output styles, MCP servers, and agents. It also adds the Claude Code features pi lacks: a todo overlay, checkpoints, memory, web search, subagents, and goals.
 
 What a repository ships is treated as untrusted until you approve it: project MCP servers, hooks, agents, rules, output styles, commands and skills load only once you say yes.
 
@@ -53,9 +53,10 @@ Each topic links to its own doc with the full contract and any divergences from
 - **[Statusline](docs/statusline.md)** — your Claude `statusLine` command with the documented stdin JSON.
 - **[WebSearch / WebFetch](docs/web.md)** — key-free search and SSRF-guarded fetch.
 - **[Claude plugins](docs/plugins.md)** — installed marketplace plugins: commands, agents, hooks, MCP servers, styles, skills.
+- **[Goal](docs/goal.md)**: `/goal <condition>` keeps the session working until a separate model check confirms the condition holds, with status, clear, block cap, background-work deferral, and resume.
 - **[Session extras](docs/session-extras.md)** — project trust, plan mode, todos, checkpoints/rewind, AskUserQuestion, notifications, think keywords, session titles, `/context`, `/init`.
 
-Slash commands: `/init`, `/context`, `/memory`, `/todos`, `/rewind`, `/tasks`, `/agents`, `/plan`, `/mcp`, `/hooks`, and `/output-style`, alongside your own `/dir:name` commands, `/skill:name` skills, `/plugin:name` plugin commands, and each connected server's `/mcp__server__prompt` prompts.
+Slash commands: `/init`, `/context`, `/goal`, `/memory`, `/todos`, `/rewind`, `/tasks`, `/agents`, `/plan`, `/mcp`, `/hooks`, and `/output-style`, alongside your own `/dir:name` commands, `/skill:name` skills, `/plugin:name` plugin commands, and each connected server's `/mcp__server__prompt` prompts.
 
 pi has no general permission system, so most of what Claude routes through a permission prompt maps to hard behavior here: `allowed-tools` restricts the turn's tool set instead of pre-approving calls, and a hook that times out on PreToolUse or UserPromptSubmit fails closed. A hook's `permissionDecision: "ask"` is the exception: it shows a confirm dialog and lets the call through when you approve (a headless run has no dialog, so it blocks). Where a Claude restriction cannot be expressed at all (an argument-scoped grant in an agent's `tools:`), the definition is rejected rather than widened.
 
@@ -69,7 +70,8 @@ Vendored bases (`question`, `notify`, `status-line`) come from pi's MIT example
 
 ```bash
 npm install
-npm run check           # biome + strict tsc + vitest, the whole gate
+npm run check           # biome + strict tsc + knip + vitest with coverage floors, the whole gate
+scripts/e2e-smoke.sh    # headless deterministic smoke: wire payload against a dead-port model, no real model (also runs in CI)
 scripts/e2e.sh          # quick smoke of the real pi TUI via tmux (needs a working model)
 scripts/e2e-full.sh     # every README feature end to end, model turns included (5-15 min)
 scripts/record-demos.sh # re-records demos/*.tape with vhs at low thinking

package/extensions/commands.ts

@@ -45,7 +45,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-c
 import { Type } from 'typebox'
 
 import { matchesBashRules } from './internal/bash-rules.js'
-import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
+import { type CommandExec, type DiscoveredCommand, discoverCommandFiles, expandDynamicContent, type ParsedCommand, type PathRuleTool, parseCommandFile, resolvePowershellBinary, spanExec, substituteArgsDetailed, substituteVars } from './internal/command-file.js'
 import { claudeConfigDir } from './internal/config-dir.js'
 import { managedSettingsFile, readManagedSettings } from './internal/managed-settings.js'
 import { capForContext } from './internal/output-guard.js'
@@ -56,8 +56,6 @@ import { ancestorDirs, repoRoot } from './internal/project-root.js'
 import { claudeSettingsChain } from './internal/settings-chain.js'
 import { createTurnOverride } from './internal/turn-override.js'
 
-type PathRuleTool = 'read' | 'edit' | 'write'
-
 /** Just enough of pi's Model to match and restore; getAvailable returns these. */
 interface ModelLike {
   id: string

package/extensions/goal.ts

@@ -0,0 +1,522 @@
+/**
+ * Goal Extension
+ *
+ * Claude Code's /goal: a completion condition the session keeps working toward. After
+ * each turn a separate model judges the condition against the conversation and returns
+ * met, not yet met (its reason becomes the next turn's guidance), or impossible. Claude
+ * implements it as a session-scoped prompt-based Stop hook; pi-code runs the same loop
+ * on agent_end next to the hooks extension's Stop path:
+ * - `/goal <condition>` sets (or replaces) the goal and starts a turn with Claude's
+ *   kickoff directive; `/goal` shows status; `/goal clear` (stop/off/reset/none/cancel)
+ *   removes it. The condition is capped at 4,000 characters.
+ * - The evaluator is the session model, or ANTHROPIC_DEFAULT_HAIKU_MODEL resolved against
+ *   the models this user can run. It reads the branch transcript trimmed to half its
+ *   context window and cannot run tools, so the condition must be provable from output.
+ * - The Stop hooks' consecutive-block cap (CLAUDE_CODE_STOP_HOOK_BLOCK_CAP, default 8)
+ *   bounds a stalled loop: that many not-met verdicts in a row on turns that used no tool
+ *   pause the loop with a warning, goal still set, until the next user prompt.
+ * - Evaluation is skipped while a subagent is still running (tracked from the subagent
+ *   extension's bus events; pi has no other background work). A check-in turn is
+ *   injected once the wait reaches CLAUDE_CODE_GOAL_CHECKIN_MINUTES (30, doubling up to
+ *   four times the first interval, at most three idle check-ins between user prompts;
+ *   0 turns check-ins off).
+ * - A turn ended by the user (Esc) or by an error is not evaluated, and an Esc during
+ *   the evaluation cancels it with the goal left set. An unrecoverable
+ *   error (authentication, credits, context overflow, model unavailable) clears the goal
+ *   with a warning once the run settles; a transient one leaves it set.
+ * - The active goal persists as a session entry and is restored on resume or reload with
+ *   the turn count, timer, and token baseline reset; an achieved, failed, or cleared goal
+ *   is not restored.
+ * - Gated as Claude documents: unavailable when hooks are restricted (disableAllHooks or
+ *   allowManagedHooksOnly) or the project is not trusted, with the reason shown.
+ * - Headless (`pi -p "/goal ..."`), the command holds the process open until the goal
+ *   resolves or pauses, and warnings also go to stderr since there is no notify surface.
+ *
+ * Docs: https://code.claude.com/docs/en/goal.md
+ */
+
+import * as os from 'node:os'
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+
+import { hookFiles, readSettingsDisableAllHooks, stopHookBlockCap } from './hooks/index.js'
+import {
+  checkinIntervalMs,
+  checkinText,
+  classifyUnrecoverable,
+  EVALUATOR_SYSTEM,
+  evaluatorPrompt,
+  formatAchievedGoal,
+  formatActiveGoal,
+  formatDuration,
+  formatTokens,
+  GOAL_CONDITION_MAX_CHARS,
+  type GoalSummary,
+  type GoalVerdict,
+  isClearAlias,
+  kickoffPrompt,
+  MAX_IDLE_CHECKINS,
+  NO_GOAL_TEXT,
+  parseVerdict,
+  type RunningWork,
+  renderTranscript,
+  summaryText,
+} from './internal/goal-evaluator.js'
+import { readManagedSettings } from './internal/managed-settings.js'
+import { completeText } from './internal/model-complete.js'
+import { resolveModelOverride } from './internal/model-lookup.js'
+import { isProjectApprovedSilently } from './internal/project-approval.js'
+import { isSubagentPhaseEvent, SUBAGENT_CHANNEL } from './internal/subagent-events.js'
+
+/** Session entry type the goal state persists under, and the custom message type its
+ * transcript lines (kickoff, verdicts, check-ins) carry. */
+const GOAL_ENTRY = 'goal'
+const GOAL_MESSAGE = 'goal'
+/** Claude's prompt-hook default; a slow evaluator is an error, not a stall. */
+const EVALUATOR_TIMEOUT_MS = 30_000
+/** A verdict is one JSON object; the cap stops a runaway reply. */
+const EVALUATOR_MAX_TOKENS = 512
+/** Claude trims the transcript to half the evaluator's context window. */
+const TRANSCRIPT_WINDOW_SHARE = 0.5
+const CHARS_PER_TOKEN = 4
+const DEFAULT_CONTEXT_WINDOW = 200_000
+/** The `◎ goal <elapsed>` indicator re-renders on this cadence while a goal is active. */
+const INDICATOR_REFRESH_MS = 60_000
+
+const HOOKS_GATE = "/goal can't run while hooks are restricted (disableAllHooks or allowManagedHooksOnly is set in settings or by policy)."
+const TRUST_GATE = '/goal is only available in trusted workspaces. Restart, accept the trust dialog, and try again.'
+
+type GoalState = 'active' | 'cleared' | 'achieved' | 'failed'
+
+interface GoalEntry {
+  state: GoalState
+  condition: string
+}
+
+interface ActiveGoal {
+  condition: string
+  setAt: number
+  iterations: number
+  lastReason?: string
+  /** Session token total when the goal was set; spend is measured from here. */
+  tokensAtStart: number
+  /** Evaluator calls are not on the session total; they count toward the goal's spend. */
+  evaluatorTokens: number
+}
+
+interface TurnMessage {
+  role?: string
+  stopReason?: string
+  errorMessage?: string
+}
+
+interface TokenUsage {
+  totalTokens?: number
+  input?: number
+  output?: number
+  cacheRead?: number
+  cacheWrite?: number
+}
+
+function usageTokens(usage: TokenUsage | undefined): number {
+  if (!usage) return 0
+  return usage.totalTokens ?? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0)
+}
+
+function lastAssistant(messages: readonly unknown[]): TurnMessage | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i] as TurnMessage
+    if (message?.role === 'assistant') return message
+  }
+  return undefined
+}
+
+type SessionReader = Pick<ExtensionContext, 'sessionManager'>
+
+/** The branch as the evaluator reads it: messages plus the goal's own transcript lines,
+ * which live in custom_message entries. */
+function branchMessages(ctx: SessionReader): unknown[] {
+  const messages: unknown[] = []
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type === 'message') messages.push(entry.message)
+    else if (entry.type === 'custom_message') messages.push({ role: 'custom', customType: entry.customType, content: entry.content })
+  }
+  return messages
+}
+
+/** Cumulative assistant usage on the branch: the session's token spend so far. */
+function sessionTokens(ctx: SessionReader): number {
+  let total = 0
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type === 'message' && entry.message.role === 'assistant') total += usageTokens(entry.message.usage as TokenUsage | undefined)
+  }
+  return total
+}
+
+/** The newest goal entry on the branch, which is the goal's persisted state. */
+function lastGoalEntry(ctx: SessionReader): GoalEntry | undefined {
+  const branch = ctx.sessionManager.getBranch()
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i]
+    if (entry.type !== 'custom' || entry.customType !== GOAL_ENTRY) continue
+    const data = entry.data as Partial<GoalEntry> | undefined
+    return typeof data?.condition === 'string' && typeof data.state === 'string' ? { state: data.state, condition: data.condition } : undefined
+  }
+  return undefined
+}
+
+/** Claude's availability rule: /goal rides the hooks system, so a hooks restriction or an
+ * untrusted workspace refuses it with the reason. Checked in Claude's order. */
+function goalUnavailable(ctx: Pick<ExtensionContext, 'cwd' | 'isProjectTrusted' | 'ui'>): string | undefined {
+  const managed = readManagedSettings()
+  const trusted = isProjectApprovedSilently(ctx)
+  const restricted = managed.disableAllHooks === true || managed.allowManagedHooksOnly === true || readSettingsDisableAllHooks(hookFiles(ctx.cwd, os.homedir(), trusted))
+  if (restricted) return HOOKS_GATE
+  if (!trusted) return TRUST_GATE
+  return undefined
+}
+
+/** Claude evaluates on its small fast model, ANTHROPIC_DEFAULT_HAIKU_MODEL overriding it;
+ * pi has no such tier, so the session model stands in unless the override names one of
+ * the models this user can run. */
+function evaluatorModel(ctx: ExtensionContext): ExtensionContext['model'] {
+  return resolveModelOverride(ctx, process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL?.trim() || undefined)
+}
+
+function transcriptBudget(model: { contextWindow?: number }): number {
+  return Math.floor((model.contextWindow || DEFAULT_CONTEXT_WINDOW) * TRANSCRIPT_WINDOW_SHARE * CHARS_PER_TOKEN)
+}
+
+export default function goalExtension(pi: ExtensionAPI) {
+  let goal: ActiveGoal | undefined
+  /** The last goal achieved this session, for the status view after it clears. */
+  let achieved: GoalSummary | undefined
+  /** The live context, for timer callbacks that fire outside any pi event. */
+  let sessionCtx: ExtensionContext | undefined
+  /** Bumped whenever the goal is set, cleared, or the session changes, so an evaluation
+   * that resolves after any of those is dropped instead of steering the wrong goal. */
+  let generation = 0
+  /** Whether the run now ending executed a tool: Claude's "progress" for the block cap. */
+  let turnUsedTools = false
+  /** Not-met verdicts in a row on turns that used no tool. */
+  let noProgressStreak = 0
+  /** The error the last run ended on, judged once the run settles (past pi's retries). */
+  let lastTurnError: string | undefined
+  /** Subagents still running, by id, from the subagent extension's bus events. */
+  const running = new Map<string, string>()
+  let deferredSince: number | undefined
+  let checkinsDelivered = 0
+  let idleCheckins = 0
+  /** A check-in came due while a turn was running: deliver it at the next turn end. */
+  let checkinDue = false
+  let checkinTimer: ReturnType<typeof setTimeout> | undefined
+  let indicatorTimer: ReturnType<typeof setInterval> | undefined
+
+  /** A goal line in the transcript, which the model also reads. A timer can outlive the
+   * session that armed it, and sendMessage throws on a disposed one. */
+  function send(content: string, options: { triggerTurn: boolean; deliverAs?: 'followUp' }): void {
+    try {
+      pi.sendMessage({ customType: GOAL_MESSAGE, content, display: true }, options)
+    } catch {
+      // Disposed session: nothing left to tell.
+    }
+  }
+
+  /** A line for the user. Headless runs have no notify surface, and a refusal or a
+   * loop that stops there without a word would look like a hang, so it also goes to
+   * stderr (where Claude's -p mode prints its goal messages). */
+  function tell(ctx: ExtensionContext, text: string, level: 'info' | 'warning' | 'error'): void {
+    ctx.ui.notify(text, level)
+    if (!ctx.hasUI) process.stderr.write(`${text}\n`)
+  }
+
+  function currentSummary(ctx: SessionReader): GoalSummary | undefined {
+    if (!goal) return undefined
+    return { condition: goal.condition, durationMs: Date.now() - goal.setAt, iterations: goal.iterations, tokens: sessionTokens(ctx) - goal.tokensAtStart + goal.evaluatorTokens, lastReason: goal.lastReason }
+  }
+
+  function showIndicator(ctx: ExtensionContext): void {
+    if (!goal) return
+    ctx.ui.setStatus('goal', ctx.ui.theme.fg('accent', `◎ goal ${formatDuration(Date.now() - goal.setAt)}`))
+    if (!indicatorTimer) {
+      indicatorTimer = setInterval(() => {
+        if (sessionCtx) showIndicator(sessionCtx)
+      }, INDICATOR_REFRESH_MS)
+      indicatorTimer.unref?.()
+    }
+  }
+
+  function stopIndicator(ctx: ExtensionContext): void {
+    clearInterval(indicatorTimer)
+    indicatorTimer = undefined
+    ctx.ui.setStatus('goal', undefined)
+  }
+
+  function stopCheckin(): void {
+    clearTimeout(checkinTimer)
+    checkinTimer = undefined
+  }
+
+  function endDeferral(): void {
+    deferredSince = undefined
+    checkinDue = false
+    stopCheckin()
+  }
+
+  /** Make `condition` the active goal with fresh counters; the entry is the caller's. */
+  function activate(ctx: ExtensionContext, condition: string): void {
+    goal = { condition, setAt: Date.now(), iterations: 0, tokensAtStart: sessionTokens(ctx), evaluatorTokens: 0 }
+    generation += 1
+    noProgressStreak = 0
+    checkinsDelivered = 0
+    idleCheckins = 0
+    endDeferral()
+    showIndicator(ctx)
+  }
+
+  /** Drop the active goal, recording how it ended; returns its condition. */
+  function endGoal(ctx: ExtensionContext, state: Exclude<GoalState, 'active'>): string | undefined {
+    const ended = goal
+    if (!ended) return undefined
+    goal = undefined
+    generation += 1
+    endDeferral()
+    stopIndicator(ctx)
+    pi.appendEntry(GOAL_ENTRY, { state, condition: ended.condition } satisfies GoalEntry)
+    return ended.condition
+  }
+
+  function finish(ctx: ExtensionContext, state: 'achieved' | 'failed', reason: string): void {
+    const summary = currentSummary(ctx)
+    if (!summary) return
+    if (state === 'achieved') achieved = summary
+    endGoal(ctx, state)
+    const head = state === 'achieved' ? `Goal achieved (${summaryText(summary)}): ${summary.condition}` : `Goal could not be achieved (${summaryText(summary)}): ${summary.condition}`
+    send(reason ? `${head}\nEvaluator: ${reason}` : head, { triggerTurn: false })
+  }
+
+  /** Claude feeds a not-met reason back as the next turn, under the Stop hooks' cap. */
+  function continueGoal(ctx: ExtensionContext, active: ActiveGoal, reason: string): void {
+    noProgressStreak = turnUsedTools ? 0 : noProgressStreak + 1
+    const cap = stopHookBlockCap()
+    showIndicator(ctx)
+    if (noProgressStreak >= cap) {
+      noProgressStreak = 0
+      tell(ctx, `Goal paused after ${cap} turns in a row without tool use; it stays set and evaluation resumes after your next prompt.`, 'warning')
+      return
+    }
+    const summary = currentSummary(ctx)
+    const spent = summary ? ` · ${formatDuration(summary.durationMs)} · ${formatTokens(summary.tokens)} tokens` : ''
+    send(`Goal not yet met (turn ${active.iterations}${spent}): ${reason}\nGoal: ${active.condition}`, { triggerTurn: true })
+  }
+
+  async function askEvaluator(ctx: ExtensionContext, active: ActiveGoal, model: NonNullable<ExtensionContext['model']>): Promise<GoalVerdict> {
+    const transcript = renderTranscript(branchMessages(ctx), transcriptBudget(model))
+    // Esc during the evaluation aborts the run's signal; the call must die with it, or
+    // a late verdict would queue the next goal turn into a run the user just stopped.
+    const deadline = AbortSignal.timeout(EVALUATOR_TIMEOUT_MS)
+    const signal = ctx.signal ? AbortSignal.any([ctx.signal, deadline]) : deadline
+    // Claude runs its evaluator with thinking disabled: the verdict is mechanical.
+    // completeText requests no thinking level, which is the same for pi.
+    const { text, usage } = await completeText(model, evaluatorPrompt(transcript, active.condition), { system: EVALUATOR_SYSTEM, maxTokens: EVALUATOR_MAX_TOKENS, signal })
+    active.evaluatorTokens += usageTokens(usage as TokenUsage | undefined)
+    const verdict = parseVerdict(text)
+    if (!verdict) throw new Error(`unreadable verdict: ${text.slice(0, 200)}`)
+    return verdict
+  }
+
+  async function evaluate(ctx: ExtensionContext): Promise<void> {
+    const active = goal
+    if (!active) return
+    const startedGeneration = generation
+    const model = evaluatorModel(ctx)
+    if (!model) {
+      tell(ctx, 'Goal evaluator has no model to run on; the goal stays set.', 'warning')
+      return
+    }
+    let verdict: GoalVerdict
+    try {
+      verdict = await askEvaluator(ctx, active, model)
+    } catch (error) {
+      // A user interrupt is not an evaluator failure: the goal stays, nothing to say.
+      if (ctx.signal?.aborted) return
+      // No verdict is a hook error in Claude's terms: the turn ends and the goal stays.
+      if (generation === startedGeneration) tell(ctx, `Goal evaluator error: ${error instanceof Error ? error.message : String(error)}. The goal stays set; the next turn is evaluated again.`, 'warning')
+      return
+    }
+    // Interrupted, cleared, or replaced during the await: this verdict must not act.
+    if (ctx.signal?.aborted || generation !== startedGeneration) return
+    active.iterations += 1
+    active.lastReason = verdict.reason
+    if (verdict.ok) finish(ctx, 'achieved', verdict.reason)
+    else if (verdict.impossible) finish(ctx, 'failed', verdict.reason)
+    else continueGoal(ctx, active, verdict.reason)
+  }
+
+  function deliverCheckin(paused: boolean): void {
+    if (!goal) return
+    checkinDue = false
+    checkinsDelivered += 1
+    const work: RunningWork[] = [...running].map(([id, agentType]) => ({ id, agentType }))
+    send(checkinText(goal.condition, Date.now() - (deferredSince ?? Date.now()), work, paused), { triggerTurn: true })
+  }
+
+  function onCheckinDue(): void {
+    checkinTimer = undefined
+    if (!goal || !sessionCtx) return
+    // Claude delivers a due check-in at the next turn end when a turn is running, and
+    // only starts idle turns for it up to the per-prompt cap.
+    if (!sessionCtx.isIdle() || idleCheckins >= MAX_IDLE_CHECKINS) {
+      checkinDue = true
+      return
+    }
+    idleCheckins += 1
+    deliverCheckin(idleCheckins >= MAX_IDLE_CHECKINS)
+  }
+
+  function armCheckin(): void {
+    if (checkinTimer) return
+    const ms = checkinIntervalMs(process.env, checkinsDelivered)
+    if (ms <= 0) return
+    checkinTimer = setTimeout(onCheckinDue, ms)
+    checkinTimer.unref?.()
+  }
+
+  /** Background work keeps the goal waiting: no verdict this turn, a check-in later. */
+  function deferEvaluation(): void {
+    deferredSince ??= Date.now()
+    if (checkinDue) {
+      deliverCheckin(false)
+      return
+    }
+    armCheckin()
+  }
+
+  function statusText(ctx: SessionReader): string {
+    const summary = currentSummary(ctx)
+    if (summary) return formatActiveGoal(summary)
+    if (achieved) return formatAchievedGoal(achieved)
+    return NO_GOAL_TEXT
+  }
+
+  pi.registerCommand('goal', {
+    description: 'Set a goal the session keeps working toward until a separate check confirms it is met; /goal shows status, /goal clear stops',
+    handler: async (args, ctx) => {
+      sessionCtx = ctx
+      const condition = args.trim()
+      if (condition === '') {
+        tell(ctx, statusText(ctx), 'info')
+        return
+      }
+      if (isClearAlias(condition)) {
+        const cleared = endGoal(ctx, 'cleared')
+        if (cleared === undefined) tell(ctx, 'No goal set', 'info')
+        else send(`Goal cleared: ${cleared}`, { triggerTurn: false })
+        return
+      }
+      if (condition.length > GOAL_CONDITION_MAX_CHARS) {
+        tell(ctx, `Goal condition is limited to ${GOAL_CONDITION_MAX_CHARS} characters (got ${condition.length})`, 'error')
+        return
+      }
+      const blocked = goalUnavailable(ctx)
+      if (blocked) {
+        tell(ctx, blocked, 'error')
+        return
+      }
+      // A new goal replaces the current one, as Claude documents; the entry written here
+      // is the state a resume restores.
+      activate(ctx, condition)
+      pi.appendEntry(GOAL_ENTRY, { state: 'active', condition } satisfies GoalEntry)
+      tell(ctx, `Goal set: ${condition}`, 'info')
+      // Setting a goal starts a turn immediately with the condition as the directive; a
+      // send during streaming queues it as a follow-up turn.
+      send(kickoffPrompt(condition), ctx.isIdle() ? { triggerTurn: true } : { triggerTurn: true, deliverAs: 'followUp' })
+      // A headless run (`pi -p "/goal ..."`) exits as soon as the command returns, before
+      // the kickoff turn runs. pi marks the run active synchronously on the send, and the
+      // continuations queued at agent_end extend that run, so waiting here holds the
+      // process open until the goal resolves, as Claude's -p mode does. The TUI's main
+      // loop returns to the editor on its own, so it must not block on the loop.
+      if (!ctx.hasUI) await ctx.waitForIdle()
+    },
+  })
+
+  pi.events.on(SUBAGENT_CHANNEL, (data) => {
+    if (!isSubagentPhaseEvent(data)) return
+    if (data.phase === 'start') running.set(data.agentId, data.agentType)
+    else running.delete(data.agentId)
+  })
+
+  pi.on('session_start', (_event, ctx) => {
+    // One extension instance serves every session: drop the previous session's goal and
+    // timers before reading this session's persisted state.
+    sessionCtx = ctx
+    goal = undefined
+    achieved = undefined
+    generation += 1
+    turnUsedTools = false
+    noProgressStreak = 0
+    lastTurnError = undefined
+    checkinsDelivered = 0
+    idleCheckins = 0
+    endDeferral()
+    stopIndicator(ctx)
+    const entry = lastGoalEntry(ctx)
+    if (entry?.state !== 'active') return
+    // Claude restores a still-active goal on resume with its counters reset.
+    activate(ctx, entry.condition)
+    tell(ctx, `Goal restored: ${entry.condition}`, 'info')
+  })
+
+  pi.on('session_shutdown', () => {
+    stopCheckin()
+    clearInterval(indicatorTimer)
+    indicatorTimer = undefined
+  })
+
+  pi.on('agent_start', () => {
+    turnUsedTools = false
+  })
+
+  pi.on('tool_execution_start', () => {
+    turnUsedTools = true
+  })
+
+  pi.on('input', (event) => {
+    // Only genuine user input is progress: a goal continuation or a subagent prompt
+    // arrives with source 'extension'. Claude resets the block cap and the idle
+    // check-in allowance on the user's next prompt.
+    if (event.source === 'extension') return
+    noProgressStreak = 0
+    idleCheckins = 0
+  })
+
+  // On agent_end rather than agent_settled, for the reason hooks.ts gives: a peer
+  // extension can hold its agent_end handler on a dialog, which would starve a settle-
+  // based evaluation; and a continuation sent here is picked up as the run's own
+  // continuation rather than a fresh prompt.
+  pi.on('agent_end', async (event, ctx) => {
+    sessionCtx = ctx
+    const last = lastAssistant(event.messages)
+    lastTurnError = last?.stopReason === 'error' ? (last.errorMessage ?? 'unknown error') : undefined
+    // Claude runs no Stop evaluation after a user interrupt; a failed turn is judged once
+    // the run settles, so neither is evaluated here and the goal stays set.
+    if (!goal || last?.stopReason === 'aborted' || lastTurnError !== undefined) return
+    if (running.size > 0) {
+      deferEvaluation()
+      return
+    }
+    endDeferral()
+    await evaluate(ctx)
+  })
+
+  pi.on('agent_settled', (_event, ctx) => {
+    const message = lastTurnError
+    lastTurnError = undefined
+    if (!goal || message === undefined) return
+    const kind = classifyUnrecoverable(message)
+    if (!kind) return
+    endGoal(ctx, 'cleared')
+    const text = `Goal cleared after an unrecoverable error (${kind}): "${message}". Run /goal again to continue.`
+    send(text, { triggerTurn: false })
+    tell(ctx, text, 'warning')
+  })
+}

package/extensions/hooks/index.ts

@@ -97,6 +97,7 @@ import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-a
 import { INSTRUCTIONS_CHANNEL, isInstructionLoadEvent } from '../internal/instruction-events.js'
 import { readManagedSettings } from '../internal/managed-settings.js'
 import { isMcpToolAliases, MCP_TOOLS_CHANNEL } from '../internal/mcp-alias.js'
+import { resolveModelOverride } from '../internal/model-lookup.js'
 import { isPlanModeState, PLAN_MODE_CHANNEL } from '../internal/plan-mode-state.js'
 import { installedPlugins } from '../internal/plugins.js'
 import { isProjectApproved } from '../internal/project-approval.js'
@@ -230,13 +231,7 @@ export default function hooksExtension(pi: ExtensionAPI) {
   }
   /** Claude's prompt-hook `model` override, resolved against the models this user
    * can run (exact id first, then a substring match); the session model otherwise. */
-  const resolveHookModel = (ctx: ExtensionContext, override: string | undefined): ExtensionContext['model'] => {
-    if (!override) return ctx.model
-    const available = (ctx as { modelRegistry?: { getAvailable?: () => ReadonlyArray<{ id: string; name?: string }> } }).modelRegistry?.getAvailable?.() ?? []
-    const needle = override.toLowerCase()
-    const match = available.find((model) => model.id.toLowerCase() === needle) ?? available.find((model) => model.id.toLowerCase().includes(needle) || model.name?.toLowerCase().includes(needle))
-    return (match as ExtensionContext['model']) ?? ctx.model
-  }
+  const resolveHookModel = (ctx: ExtensionContext, override: string | undefined): ExtensionContext['model'] => resolveModelOverride(ctx, override)
 
   /** Kills for background hooks still running; Claude kills async hooks at teardown,
    * so session_shutdown reaps anything left rather than let a hung hook pin the

package/extensions/internal/command-file.ts

@@ -307,7 +307,7 @@ export function parseCommandFile(content: string): ParsedCommand {
 }
 
 /** Split a raw argument string, keeping quoted runs together. */
-export function splitArgs(args: string): string[] {
+function splitArgs(args: string): string[] {
   const out: string[] = []
   const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g
   let match = pattern.exec(args)

package/extensions/internal/goal-evaluator.ts

@@ -0,0 +1,262 @@
+/**
+ * The pure half of /goal: the directive Claude Code sends when a goal is set, the
+ * evaluator prompt its small fast model judges the condition with, the transcript
+ * rendering that prompt sees, verdict parsing, the classifier for the errors that
+ * clear a goal, the check-in schedule, and the status text. No pi state lives here,
+ * so goal.ts stays the lifecycle wiring and each contract is pinned on its own.
+ */
+
+/** Claude caps a goal condition at 4,000 characters. */
+export const GOAL_CONDITION_MAX_CHARS = 4000
+
+/** `/goal clear` and its documented aliases, matched case-insensitively. */
+const CLEAR_ALIASES = new Set(['clear', 'stop', 'off', 'reset', 'none', 'cancel'])
+
+export function isClearAlias(text: string): boolean {
+  return CLEAR_ALIASES.has(text.toLowerCase())
+}
+
+/** The directive a set goal starts its first turn with: the condition itself is the task. */
+export function kickoffPrompt(condition: string): string {
+  return `A session-scoped Stop hook is now active with condition: "${condition}". Briefly acknowledge the goal, then immediately start (or continue) working toward it: treat the condition itself as your directive and do not pause to ask the user what to do. The hook will block stopping until the condition holds. It auto-clears once the condition is met, so do not tell the user to run \`/goal clear\` after success; that is only for clearing a goal early.`
+}
+
+/** Claude's stop-condition evaluator instructions: transcript evidence only, three
+ * verdict shapes, and impossible reserved for a condition that can never hold. */
+export const EVALUATOR_SYSTEM = [
+  'You are evaluating a stop-condition hook for a coding agent session. Read the conversation transcript carefully, then judge whether the user-provided condition is satisfied.',
+  'Your response must be a JSON object with one of these shapes:',
+  '- {"ok": true, "reason": "<quote evidence from the transcript that satisfies the condition>"}',
+  '- {"ok": false, "reason": "<quote what is missing or what blocks the condition>"}',
+  '- {"ok": false, "impossible": true, "reason": "<explain why the condition can never be satisfied>"}',
+  'Always include a "reason" field, quoting specific text from the transcript whenever possible. If the transcript does not contain clear evidence that the condition is satisfied, return {"ok": false, "reason": "insufficient evidence in transcript"}.',
+  'Only use {"ok": false, "impossible": true} when the condition is genuinely unachievable in this session, for example: the condition is self-contradictory, it depends on a resource or capability that is unavailable, or the assistant has explicitly tried, exhausted reasonable approaches, and stated it cannot be done. Apply your own judgment when deciding this: the assistant claiming the goal is impossible is evidence, not proof; independently confirm the condition is genuinely unachievable rather than deferring to the assistant\'s self-assessment. Do not use it just because the goal has not been reached yet or because progress is slow. When in doubt, return {"ok": false} without "impossible".',
+  // Claude pins the reply with a JSON schema; pi's one-off completion cannot, so the
+  // instruction has to carry that weight.
+  'Output the JSON object only, with no text before or after it and no code fence.',
+].join('\n')
+
+/** The user turn of the evaluation: the rendered transcript, then Claude's question. */
+export function evaluatorPrompt(transcript: string, condition: string): string {
+  return `<transcript>\n${transcript}\n</transcript>\n\nBased on the conversation transcript above, has the following stopping condition been satisfied? Answer based on transcript evidence only.\nCondition: ${condition}`
+}
+
+export interface GoalVerdict {
+  ok: boolean
+  reason: string
+  /** Only meaningful when ok is false: the condition can never be satisfied. */
+  impossible: boolean
+}
+
+/** A reply with no JSON at all but an opening yes/no: a small model answering the
+ * question in prose. The whole reply becomes the reason. Anything less clear-cut is
+ * not a verdict. */
+function proseVerdict(text: string): GoalVerdict | undefined {
+  const lead = /^\s*(yes|no)\b/i.exec(text)?.[1]?.toLowerCase()
+  if (lead === undefined) return undefined
+  return { ok: lead === 'yes', reason: text.trim(), impossible: false }
+}
+
+/** The evaluator's JSON verdict, tolerating prose or a code fence around the object; a
+ * reply with no object at all falls back to its yes/no lead. Undefined when the object
+ * does not parse, `ok` is not a boolean, or no lead is there, which the caller treats
+ * as an evaluator error rather than a verdict. */
+export function parseVerdict(text: string): GoalVerdict | undefined {
+  const start = text.indexOf('{')
+  const end = text.lastIndexOf('}')
+  if (start === -1) return proseVerdict(text)
+  if (end <= start) return undefined
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(text.slice(start, end + 1))
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const { ok, reason, impossible } = parsed as Record<string, unknown>
+  if (typeof ok !== 'boolean') return undefined
+  return { ok, reason: typeof reason === 'string' ? reason.trim() : '', impossible: !ok && impossible === true }
+}
+
+/** One message's rendering is capped so a single tool dump cannot consume the budget. */
+const BLOCK_MAX_CHARS = 6000
+/** Tool arguments are context, not evidence; a short prefix identifies the call. */
+const TOOL_ARGS_MAX_CHARS = 400
+const OMITTED_MARKER = '[earlier transcript omitted]'
+
+interface ContentPart {
+  type?: string
+  text?: string
+  name?: string
+  arguments?: unknown
+}
+
+interface TranscriptMessage {
+  role?: string
+  content?: unknown
+  toolName?: string
+  customType?: string
+  stopReason?: string
+  errorMessage?: string
+}
+
+function truncate(text: string, max: number): string {
+  if (text.length <= max) return text
+  return `${text.slice(0, max)}... [truncated ${text.length - max} chars]`
+}
+
+/** Text and tool-call parts of a content value; thinking is dropped, images noted. */
+function partsText(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  const rendered: string[] = []
+  for (const part of content as ContentPart[]) {
+    if (part?.type === 'text' && typeof part.text === 'string') rendered.push(part.text)
+    else if (part?.type === 'image') rendered.push('[image]')
+    else if (part?.type === 'toolCall') rendered.push(`[tool call ${part.name}(${truncate(JSON.stringify(part.arguments ?? {}), TOOL_ARGS_MAX_CHARS)})]`)
+  }
+  return rendered.join('\n')
+}
+
+function renderMessage(message: TranscriptMessage): string | undefined {
+  switch (message.role) {
+    case 'user':
+      return `User: ${partsText(message.content)}`
+    case 'assistant': {
+      const body = message.stopReason === 'error' ? `[error: ${message.errorMessage ?? 'unknown error'}]` : partsText(message.content)
+      return `Assistant: ${body}`
+    }
+    case 'toolResult':
+      return `Tool result (${message.toolName ?? 'tool'}): ${partsText(message.content)}`
+    case 'custom':
+      return `Note (${message.customType ?? 'note'}): ${partsText(message.content)}`
+    default:
+      return undefined
+  }
+}
+
+/**
+ * The conversation as the evaluator reads it: one block per message, newest last,
+ * trimmed from the head to `budgetChars` (Claude trims to half the evaluator's
+ * context window). A cut is marked so the model knows evidence may predate it; the
+ * newest message always survives, cut to the budget when it alone exceeds it.
+ */
+export function renderTranscript(messages: readonly unknown[], budgetChars: number): string {
+  const blocks: string[] = []
+  for (const message of messages as TranscriptMessage[]) {
+    const rendered = renderMessage(message)
+    if (rendered !== undefined) blocks.push(truncate(rendered, BLOCK_MAX_CHARS))
+  }
+  const newest = blocks.at(-1)
+  if (newest === undefined) return ''
+  const separator = '\n\n'
+  const kept: string[] = []
+  let used = 0
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const cost = blocks[i].length + (kept.length > 0 ? separator.length : 0)
+    if (used + cost > budgetChars) {
+      if (kept.length > 0) kept.unshift(OMITTED_MARKER)
+      break
+    }
+    kept.unshift(blocks[i])
+    used += cost
+  }
+  if (kept.length === 0) return newest.slice(0, budgetChars)
+  return kept.join(separator)
+}
+
+export type UnrecoverableKind = 'authentication' | 'credits' | 'context overflow' | 'model unavailable'
+
+/** Claude clears a goal after an error the user has to fix. Transient failures (rate
+ * limits, overloads, network) deliberately match nothing so the goal stays set. */
+const UNRECOVERABLE: ReadonlyArray<[UnrecoverableKind, RegExp]> = [
+  ['authentication', /\b40[13]\b|unauthori[sz]ed|authentication|invalid (?:api[ -])?key|x-api-key/i],
+  ['credits', /\bcredit|billing|insufficient[ _](?:funds|balance|quota)|payment required|\b402\b/i],
+  ['context overflow', /context (?:window|length)|too (?:long|many tokens)|maximum (?:context|input) (?:length|tokens)/i],
+  ['model unavailable', /model.*(?:not found|unavailable|does not exist|not available|unsupported)|no such model|not_found_error|\b404\b/i],
+]
+
+export function classifyUnrecoverable(errorMessage: string): UnrecoverableKind | undefined {
+  return UNRECOVERABLE.find(([, pattern]) => pattern.test(errorMessage))?.[0]
+}
+
+export function formatDuration(ms: number): string {
+  const seconds = Math.max(0, Math.round(ms / 1000))
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`
+}
+
+export function formatTokens(tokens: number): string {
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}k`
+  return String(tokens)
+}
+
+function plural(count: number, noun: string): string {
+  return `${count} ${noun}${count === 1 ? '' : 's'}`
+}
+
+export interface GoalSummary {
+  condition: string
+  durationMs: number
+  /** Turns the evaluator has judged. */
+  iterations: number
+  /** Tokens spent since the goal was set, evaluator calls included. */
+  tokens: number
+  lastReason?: string
+}
+
+/** Claude's status view fields: duration, turn count, and token spend. */
+export function summaryText(summary: GoalSummary): string {
+  return `${formatDuration(summary.durationMs)} · ${plural(summary.iterations, 'turn')} · ${formatTokens(summary.tokens)} tokens`
+}
+
+export const NO_GOAL_TEXT = 'No goal set. Usage: /goal <condition>'
+
+export function formatActiveGoal(summary: GoalSummary): string {
+  const turns = summary.iterations === 0 ? 'not yet evaluated' : plural(summary.iterations, 'turn')
+  const lines = [`Goal active: ${summary.condition} (${turns})`, `Running for ${formatDuration(summary.durationMs)} · ${formatTokens(summary.tokens)} tokens`]
+  if (summary.lastReason) lines.push(`Last check: ${summary.lastReason}`)
+  lines.push('/goal clear to stop early')
+  return lines.join('\n')
+}
+
+export function formatAchievedGoal(summary: GoalSummary): string {
+  return `Goal achieved: ${summary.condition} (${summaryText(summary)})\n/goal <condition> to set another`
+}
+
+/** Claude's first check-in interval while background work keeps a goal waiting. */
+export const DEFAULT_CHECKIN_MINUTES = 30
+/** Later check-ins wait twice as long each, up to four times the first interval. */
+const MAX_CHECKIN_DOUBLINGS = 2
+/** Idle check-ins per goal between user prompts; the third says they are paused. */
+export const MAX_IDLE_CHECKINS = 3
+
+/** Milliseconds until the next check-in given how many have been delivered for this
+ * goal: CLAUDE_CODE_GOAL_CHECKIN_MINUTES (0 turns check-ins off, junk falls back to
+ * the default) scaled by Claude's doubling. */
+export function checkinIntervalMs(env: Record<string, string | undefined>, delivered: number): number {
+  const raw = env.CLAUDE_CODE_GOAL_CHECKIN_MINUTES
+  const parsed = raw === undefined || raw.trim() === '' ? Number.NaN : Number(raw)
+  const minutes = Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_CHECKIN_MINUTES
+  return minutes * 60_000 * 2 ** Math.min(delivered, MAX_CHECKIN_DOUBLINGS)
+}
+
+export interface RunningWork {
+  id: string
+  agentType: string
+}
+
+/** Claude's check-in turn: the running work to look at, or a nudge to continue when
+ * the work stopped without reporting. `paused` marks the capped idle check-in. */
+export function checkinText(condition: string, deferredMs: number, running: readonly RunningWork[], paused: boolean): string {
+  const minutes = Math.max(1, Math.round(deferredMs / 60_000))
+  const pausedNote = paused ? ' Idle check-ins are paused until your next message, so say clearly where things stand.' : ''
+  if (running.length === 0) {
+    return `Goal check-in: «${condition}» is still active. Its evaluation was deferred for ${minutes} min while background work ran, and that work is no longer running (it finished or was stopped without reporting back). Continue toward the goal.${pausedNote}`
+  }
+  const list = running.map((work) => `- ${work.id} · subagent ${work.agentType}`).join('\n')
+  return `Goal check-in: «${condition}» is still active, and evaluation has been deferred for ${minutes} min because background work is still running:\n${list}\nCheck on their progress (e.g. read their output). If they are progressing, say so briefly and keep waiting; if they are stuck or no longer needed, fix or stop them and continue toward the goal.${pausedNote}`
+}

package/extensions/internal/html-markdown.ts

@@ -5,7 +5,8 @@
  * A regex pipeline, not a DOM: pi ships no HTML parser and the output is prose
  * for a model, not a rendering. Every pattern bounds its tag matches with
  * [^<>]* so a failed match stops at the next tag instead of rescanning to the
- * end of input, keeping the pass linear on hostile pages.
+ * end of input, keeping the pass linear on hostile pages. Bare tag removal is a
+ * scanner rather than a regex: see removeTags.
  */
 
 const NAMED_ENTITIES: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' }
@@ -18,7 +19,34 @@ function decodeAllEntities(text: string): string {
   })
 }
 
-const stripInnerTags = (html: string): string => html.replace(/<[^<>]*>/g, '')
+/** The HTML tokenizer's tag-open rule: `<` starts a tag only before a letter, `/`,
+ * `!`, or `?`; any other `<` (as in `1 < 2`) is text. */
+const TAG_OPEN = /^<[A-Za-z/!?]/
+
+/**
+ * Drop every tag in one linear pass. A regex strip can rebuild a tag out of nested
+ * brackets: `<scr<b>ipt>` loses `<b>` and becomes `<script>` (CodeQL's incomplete
+ * multi-character sanitization). Skipping from a tag's `<` to the next `>` removes the
+ * whole span, so nothing removed can reassemble; a tag that never closes stays as text.
+ */
+export function removeTags(html: string): string {
+  let out = ''
+  let cursor = 0
+  while (cursor < html.length) {
+    const open = html.indexOf('<', cursor)
+    if (open === -1) return out + html.slice(cursor)
+    if (!TAG_OPEN.test(html.slice(open, open + 2))) {
+      out += html.slice(cursor, open + 1)
+      cursor = open + 1
+      continue
+    }
+    const close = html.indexOf('>', open + 1)
+    if (close === -1) return out + html.slice(cursor)
+    out += html.slice(cursor, open)
+    cursor = close + 1
+  }
+  return out
+}
 
 // Strip leading and trailing newline runs in linear time. The equivalent
 // /^\n+|\n+$/g backtracks super-linearly on a long run of newlines (S8786).
@@ -37,23 +65,23 @@ export function htmlToMarkdown(html: string): string {
     .replace(/<!--[\s\S]*?-->/g, ' ')
     .replace(/<(script|style|noscript|head|svg)\b[^<>]*>[\s\S]*?<\/\1[^<>]*>/gi, ' ')
     .replace(/<pre\b[^<>]*>([\s\S]*?)<\/pre>/gi, (_whole, inner: string) => {
-      preBodies.push(trimNewlines(decodeAllEntities(stripInnerTags(inner))))
+      preBodies.push(trimNewlines(decodeAllEntities(removeTags(inner))))
       return `\n\n\uE000PRE${preBodies.length - 1}\uE000\n\n`
     })
 
   work = work
-    .replace(/<code\b[^<>]*>([\s\S]*?)<\/code>/gi, (_whole, inner: string) => `\`${stripInnerTags(inner)}\``)
+    .replace(/<code\b[^<>]*>([\s\S]*?)<\/code>/gi, (_whole, inner: string) => `\`${removeTags(inner)}\``)
     // Only real web links become markdown links; fragment and javascript hrefs
     // keep their label and lose the target.
     .replace(/<a\b[^<>]*?href=(?:"([^"]*)"|'([^']*)')[^<>]*>([\s\S]*?)<\/a>/gi, (_whole, dq: string | undefined, sq: string | undefined, inner: string) => {
       const href = decodeAllEntities(dq ?? sq ?? '')
-      const label = stripInnerTags(inner).trim()
+      const label = removeTags(inner).trim()
       if (!label) return ' '
       return /^https?:\/\//i.test(href) ? `[${label}](${href})` : label
     })
-    .replace(/<(strong|b)\b[^<>]*>([\s\S]*?)<\/\1>/gi, (_whole, _tag, inner: string) => `**${stripInnerTags(inner).trim()}**`)
-    .replace(/<(em|i)\b[^<>]*>([\s\S]*?)<\/\1>/gi, (_whole, _tag, inner: string) => `*${stripInnerTags(inner).trim()}*`)
-    .replace(/<h([1-6])\b[^<>]*>([\s\S]*?)<\/h\1>/gi, (_whole, level: string, inner: string) => `\n\n${'#'.repeat(Number(level))} ${stripInnerTags(inner).trim()}\n\n`)
+    .replace(/<(strong|b)\b[^<>]*>([\s\S]*?)<\/\1>/gi, (_whole, _tag, inner: string) => `**${removeTags(inner).trim()}**`)
+    .replace(/<(em|i)\b[^<>]*>([\s\S]*?)<\/\1>/gi, (_whole, _tag, inner: string) => `*${removeTags(inner).trim()}*`)
+    .replace(/<h([1-6])\b[^<>]*>([\s\S]*?)<\/h\1>/gi, (_whole, level: string, inner: string) => `\n\n${'#'.repeat(Number(level))} ${removeTags(inner).trim()}\n\n`)
     .replace(/<img\b[^<>]*?alt=(?:"([^"]*)"|'([^']*)')[^<>]*>/gi, (_whole, dq?: string, sq?: string) => dq ?? sq ?? '')
     .replace(/<li\b[^<>]*>/gi, '\n- ')
     .replace(/<blockquote\b[^<>]*>/gi, '\n\n> ')
@@ -61,7 +89,7 @@ export function htmlToMarkdown(html: string): string {
     .replace(/<(?:br|hr)\b[^<>]*>/gi, '\n')
     .replace(/<\/(?:p|div|section|article|ul|ol|li|table|tr|blockquote|tbody|thead|header|footer|main|nav)[^<>]*>/gi, '\n\n')
 
-  const text = decodeAllEntities(work.replace(/<[^<>]*>/g, ''))
+  const text = decodeAllEntities(removeTags(work))
     .replace(/[ \t]+/g, ' ')
     .replace(/ ?\n ?/g, '\n')
     .replace(/\n{3,}/g, '\n\n')

package/extensions/internal/model-lookup.ts

@@ -0,0 +1,20 @@
+/**
+ * A model named by an override (a prompt hook's `model`, /goal's evaluator model),
+ * resolved against the models this user can run: exact id first, then a substring
+ * of the id or display name. The session model stands in when nothing matches or no
+ * override was given, so a misspelled override degrades to the default rather than
+ * silently disabling the feature.
+ */
+
+export interface ModelLookupContext<M> {
+  model: M | undefined
+  modelRegistry?: { getAvailable?: () => ReadonlyArray<{ id: string; name?: string }> }
+}
+
+export function resolveModelOverride<M>(ctx: ModelLookupContext<M>, override: string | undefined): M | undefined {
+  if (!override) return ctx.model
+  const available = ctx.modelRegistry?.getAvailable?.() ?? []
+  const needle = override.toLowerCase()
+  const match = available.find((model) => model.id.toLowerCase() === needle) ?? available.find((model) => model.id.toLowerCase().includes(needle) || model.name?.toLowerCase().includes(needle))
+  return (match as M | undefined) ?? ctx.model
+}

package/extensions/memory.ts

@@ -98,11 +98,36 @@ export function stampModified(content: string, iso: string): string {
   return `---\n${body}modified: ${iso}\n---${rest}`
 }
 
+/** Length of the line break `text` starts with: CRLF, LF, or none. */
+function leadingLineBreak(text: string): number {
+  if (text.startsWith('\r\n')) return 2
+  return text.startsWith('\n') ? 1 : 0
+}
+
+/** Drop every `<!-- ... -->` (and the line break after it) in one pass. A regex strip
+ * can rebuild a comment from one nested in another: `<!-<!-- x -->-- y -->` loses the
+ * inner comment and becomes `<!--- y -->`. After a removal the scan resumes three
+ * characters back, so a comment assembled across the cut is removed too; an opener
+ * that never closes stays as text. */
+function removeComments(text: string): string {
+  let out = text
+  let cursor = 0
+  while (cursor < out.length) {
+    const open = out.indexOf('<!--', cursor)
+    const close = open === -1 ? -1 : out.indexOf('-->', open + 4)
+    if (close === -1) return out
+    const tail = out.slice(close + 3)
+    out = out.slice(0, open) + tail.slice(leadingLineBreak(tail))
+    cursor = Math.max(0, open - 3)
+  }
+  return out
+}
+
 /** The index content that actually loads: YAML frontmatter and block-level HTML
  * comments are stripped, so they neither show in the prompt nor count toward the
  * 200-line / 25KB read limits, matching Claude Code. */
 export function stripNonLoaded(text: string): string {
-  return text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').replace(/<!--[\s\S]*?-->\r?\n?/g, '')
+  return removeComments(text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, ''))
 }
 
 /** Move a store written under an older slug to the current one, once. Two earlier

package/extensions/plan-mode/utils.ts

@@ -120,7 +120,7 @@ export interface TodoItem {
   completed: boolean
 }
 
-export function cleanStepText(text: string): string {
+function cleanStepText(text: string): string {
   let cleaned = text
     .replace(/\*{1,2}([^*]+)\*{1,2}/g, '$1') // Remove bold/italic
     .replace(/`([^`]+)`/g, '$1') // Remove code

package/extensions/web.ts

@@ -13,7 +13,7 @@ import type { Usage } from '@earendil-works/pi-ai'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 import { Type } from 'typebox'
 
-import { htmlToMarkdown } from './internal/html-markdown.js'
+import { htmlToMarkdown, removeTags } from './internal/html-markdown.js'
 import { completeText } from './internal/model-complete.js'
 import { capForContext } from './internal/output-guard.js'
 import { httpFetch } from './internal/web-transport.js'
@@ -40,11 +40,7 @@ export function decodeEntities(text: string): string {
 }
 
 export function stripTags(html: string): string {
-  // [^<>] rather than [^>]: excluding `<` bounds a failed match at the next tag start
-  // instead of rescanning to end of input, which is what makes the strip linear.
-  return decodeEntities(html.replace(/<[^<>]*>/g, ''))
-    .replace(/\s+/g, ' ')
-    .trim()
+  return decodeEntities(removeTags(html)).replace(/\s+/g, ' ').trim()
 }
 
 /** Resolve DuckDuckGo's redirect links (/l/?uddg=<encoded>) to the target URL. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-code",
-  "version": "1.0.46",
-  "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",
+  "version": "1.0.48",
+  "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, subagents, and goals",
   "keywords": [
     "pi",
     "pi-package",
@@ -41,8 +41,9 @@
     "biome:fix": "npx --no-install @biomejs/biome check --write .",
     "type:check": "tsc --noEmit",
     "test": "vitest run --coverage",
-    "check": "npm run biome && npm run type:check && npm run test",
-    "prepublishOnly": "npm run check"
+    "check": "npm run biome && npm run type:check && npm run knip && npm run test",
+    "prepublishOnly": "npm run check",
+    "knip": "npx --no-install knip"
   },
   "engines": {
     "node": ">=22.19"
@@ -68,6 +69,8 @@
     "@earendil-works/pi-tui": "^0.84.2",
     "@types/node": "^26.1.1",
     "@vitest/coverage-v8": "^4.1.10",
+    "fast-check": "^4.9.0",
+    "knip": "^6.34.0",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   }