pi-code 1.0.28 → 1.0.29

package/extensions/hooks/config.ts

@@ -41,6 +41,9 @@ export interface HookCommand {
   /** prompt/agent entries: an optional model override; agent adds a system prompt. */
   model?: string
   systemPrompt?: string
+  /** Dedup scope: unset for settings files (identical handlers collapse across
+   * them); a plugin's or skill's copy carries its origin and stays separate. */
+  origin?: string
 }
 export interface HookMatcher {
   matcher?: string
@@ -135,7 +138,15 @@ export function loadHooks(files: string[], sources?: Map<HookMatcher, string>):
   return config
 }
 
-function mergeHooksJson(config: HooksConfig, raw: string, source: string, sources?: Map<HookMatcher, string>): void {
+/** Claude dedups identical handlers across settings files only; a plugin's copy
+ * stays separate, so plugin entries carry their origin into the dedup key. */
+function stampOrigin(entries: HookMatcher[], origin: string): void {
+  for (const entry of entries) {
+    for (const hook of entry.hooks ?? []) hook.origin = origin
+  }
+}
+
+function mergeHooksJson(config: HooksConfig, raw: string, source: string, sources?: Map<HookMatcher, string>, origin?: string): void {
   let parsed: { hooks?: HooksConfig }
   try {
     parsed = JSON.parse(raw)
@@ -150,6 +161,7 @@ function mergeHooksJson(config: HooksConfig, raw: string, source: string, source
     // call for the rest of the session failed with an opaque type error.
     const usable = matchers.filter((entry) => isUsableMatcher(entry, source, event))
     if (usable.length === 0) continue
+    if (origin !== undefined) stampOrigin(usable, origin)
     config[event] = [...(config[event] ?? []), ...usable]
     // Each parse produces fresh entry objects, so object identity keys the /hooks
     // viewer's source attribution without touching the entries themselves.
@@ -167,12 +179,12 @@ export function loadPluginHooks(config: HooksConfig, plugins: InstalledPlugin[],
     // numeric event keys), so it falls through to the default path rather than
     // silently registering nothing.
     if (declared !== null && typeof declared === 'object' && !Array.isArray(declared)) {
-      mergeHooksJson(config, substitutePluginVars(JSON.stringify({ hooks: declared }), plugin), `${plugin.name} (plugin.json)`, sources)
+      mergeHooksJson(config, substitutePluginVars(JSON.stringify({ hooks: declared }), plugin), `${plugin.name} (plugin.json)`, sources, `plugin:${plugin.name}`)
       continue
     }
     const file = path.resolve(plugin.root, typeof declared === 'string' ? declared : path.join('hooks', 'hooks.json'))
     try {
-      mergeHooksJson(config, substitutePluginVars(fs.readFileSync(file, 'utf-8'), plugin), file, sources)
+      mergeHooksJson(config, substitutePluginVars(fs.readFileSync(file, 'utf-8'), plugin), file, sources, `plugin:${plugin.name}`)
     } catch {
       // a plugin without hooks contributes nothing
     }

package/extensions/hooks/index.ts

@@ -20,7 +20,12 @@
  * - Stop            -> pi `agent_end` (a block feeds its reason back as a new turn,
  *                      with stop_hook_active as the loop guard)
  * - PreCompact      -> pi `session_before_compact` (fire-and-forget)
- * - PostCompact     -> pi `session_compact` (fire-and-forget)
+ * - PostCompact     -> pi `session_compact` (fire-and-forget); the same event also
+ *                      fires SessionStart with source "compact", as Claude does
+ *                      when a session continues after compaction
+ * - PostModelSwitch -> pi `model_select` (after the change, matched against the new
+ *                      model id; stdout context rides the next agent start;
+ *                      PreModelSwitch stays unbridged, pi has no veto seam)
  * - PostToolUseFailure -> pi `tool_result` error branch (stderr/additionalContext
  *                      appended to the failed result; it cannot block, the tool failed)
  * - SessionEnd      -> pi `session_shutdown` (fire-and-forget)
@@ -160,6 +165,15 @@ function claudeSpelling(map: Record<string, string>, raw: string): { names: stri
   return { names: value === raw ? [raw] : [raw, value], value }
 }
 
+/** Claude: idle_prompt fires when "Claude finished responding about 60 seconds ago
+ * and you haven't typed since". */
+const IDLE_PROMPT_DELAY_MS = 60_000
+
+/** pi's model_select sources in Claude's PostModelSwitch vocabulary: an explicit
+ * set is a command-style request, cycling is the picker, and restore is the model
+ * Claude Code restores on resume. */
+const MODEL_SELECT_SOURCE: Record<string, string> = { set: 'command', cycle: 'picker', restore: 'resume' }
+
 export default function hooksExtension(pi: ExtensionAPI) {
   let config: HooksConfig = {}
   let projectDir = ''
@@ -170,6 +184,14 @@ export default function hooksExtension(pi: ExtensionAPI) {
   /** Consecutive Stop-hook blocks with no user progress between them. Reset on user input
    * and on a non-blocking Stop; at the cap the continuation is suppressed and the turn ends. */
   let stopHookBlockCount = 0
+  /** The pending idle_prompt notification: Claude fires it when the turn ended about
+   * 60 seconds ago and the user hasn't typed since, so it arms on agent_end and is
+   * canceled by input or the next turn. */
+  let idlePromptTimer: ReturnType<typeof setTimeout> | undefined
+  const cancelIdlePrompt = (): void => {
+    clearTimeout(idlePromptTimer)
+    idlePromptTimer = undefined
+  }
   let sessionCtx: ExtensionContext | undefined
   /** Claude's disableAllHooks escape hatch was set somewhere in the honored chain. */
   let hooksDisabled = false
@@ -353,6 +375,8 @@ export default function hooksExtension(pi: ExtensionAPI) {
   // over the bus from context-imports, which owns claudeMdExcludes; announcing
   // the raw contextFiles here would fire for a file the exclusion removed.
   pi.on('before_agent_start', async () => {
+    // A new turn is beginning, so the session is no longer idle.
+    cancelIdlePrompt()
     if (pendingSessionContext.length === 0) return
     const content = pendingSessionContext.join('\n')
     pendingSessionContext = []
@@ -452,6 +476,8 @@ export default function hooksExtension(pi: ExtensionAPI) {
     // Only genuine user input; extension-injected messages (plan-mode, subagent) are not
     // prompts the user submitted.
     if (event.source === 'extension') return { action: 'continue' }
+    // The user typed, so the pending idle_prompt no longer applies.
+    cancelIdlePrompt()
     // Genuine user input is progress, so it breaks a Stop-hook continuation streak: the
     // block cap counts only consecutive blocks with nothing from the user in between.
     stopHookBlockCount = 0
@@ -479,11 +505,18 @@ export default function hooksExtension(pi: ExtensionAPI) {
   // automatic retry or compaction; that is the better tradeoff.
   pi.on('agent_end', async (event, ctx) => {
     // Claude's Notification event, for the one type pi can honestly source: the
-    // agent finished and is waiting for input (idle_prompt). Observational only;
-    // exit codes and JSON output are ignored, as Claude documents for this event.
+    // agent finished and is waiting for input. Per Claude, idle_prompt fires when
+    // the turn ended about 60 seconds ago and the user hasn't typed since, so it
+    // arms here and input or the next turn cancels it. Observational only; exit
+    // codes and JSON output are ignored, as Claude documents for this event.
+    cancelIdlePrompt()
     const notifyCommands = matchingCommands(config.Notification, ['idle_prompt'])
     if (notifyCommands.length > 0) {
-      void runNotifyHooks(notifyCommands, { hook_event_name: 'Notification', notification_type: 'idle_prompt', message: 'pi is waiting for your input' }, boundRunner(ctx)).catch(() => {})
+      const runner = boundRunner(ctx)
+      idlePromptTimer = setTimeout(() => {
+        void runNotifyHooks(notifyCommands, { hook_event_name: 'Notification', notification_type: 'idle_prompt', message: 'pi is waiting for your input' }, runner).catch(() => {})
+      }, IDLE_PROMPT_DELAY_MS)
+      idlePromptTimer.unref?.()
     }
 
     // Stop has no matcher support (a stray matcher is ignored, as Claude documents)
@@ -557,6 +590,33 @@ export default function hooksExtension(pi: ExtensionAPI) {
     const trigger = claudeSpelling(PRECOMPACT_TRIGGER, event.reason)
     const results = await runNotifyHooks(matchingCommands(config.PostCompact, trigger.names), { hook_event_name: 'PostCompact', trigger: trigger.value }, boundRunner(ctx))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
+    // Claude also fires SessionStart with source "compact" when the session
+    // continues after compaction; its stdout context rides the next agent start,
+    // the same as any other SessionStart context.
+    const sessionStart = matchingCommands(config.SessionStart, 'compact')
+    if (sessionStart.length > 0) {
+      const startResults = await runNotifyHooks(sessionStart, { hook_event_name: 'SessionStart', source: 'compact' }, boundRunner(ctx))
+      surfaceSystemMessages(startResults, (message) => ctx.ui.notify(message, 'warning'))
+      pendingSessionContext.push(...startResults.map((result) => promptContext(result.stdout)).filter(Boolean))
+    }
+  })
+
+  pi.on('model_select', async (event, ctx) => {
+    // Claude's PostModelSwitch: runs after the session's model changes, matched
+    // against the model switched to; it can't block. PreModelSwitch stays
+    // unbridged: pi's model_select has no veto seam, and a "Pre" hook whose block
+    // decision is silently ignored would be worse than an absent event.
+    const { model, previousModel, source } = event as { model: { id: string }; previousModel?: { id: string }; source: string }
+    if (!previousModel || previousModel.id === model.id) return
+    const commands = matchingCommands(config.PostModelSwitch, model.id)
+    if (commands.length === 0) return
+    // requested_model is null: pi does not carry the alias the request named.
+    const payload = { hook_event_name: 'PostModelSwitch', from_model: previousModel.id, to_model: model.id, requested_model: null, source: MODEL_SELECT_SOURCE[source] ?? 'command' }
+    const results = await runNotifyHooks(commands, payload, boundRunner(ctx))
+    surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
+    // Claude delivers the hook's stdout (or additionalContext) to Claude with the
+    // next request after the switch; pi's seam for that is the next agent start.
+    pendingSessionContext.push(...results.map((result) => promptContext(result.stdout)).filter(Boolean))
   })
 
   pi.on('session_shutdown', async (event, ctx) => {

package/extensions/hooks/matcher.ts

@@ -115,9 +115,12 @@ function collectCommands(matchers: HookMatcher[] | undefined, applies: (entry: H
     if (!applies(entry)) continue
     for (const raw of (entry.hooks ?? []).filter(isRunnableHook)) {
       const hook = withCommand(raw)
-      // Claude runs a handler defined in more than one settings file once.
-      if (seen.has(hook.command)) continue
-      seen.add(hook.command)
+      // Claude runs a handler defined in more than one settings file once; a
+      // plugin's or skill's copy of the same handler stays separate, and http
+      // handlers with the same URL but different headers are distinct.
+      const key = `${hook.origin ?? 'settings'}\n${hook.command}\n${hook.headers ? JSON.stringify(hook.headers) : ''}`
+      if (seen.has(key)) continue
+      seen.add(key)
       result.push(hook)
     }
   }

package/extensions/hooks/runners.ts

@@ -247,6 +247,33 @@ export async function runPromptHook(hook: HookCommand, payload: unknown, model:
   }
 }
 
+/** A dotted path into the hook's JSON input, or undefined when any step is missing. */
+function lookupPath(payload: unknown, dotted: string): unknown {
+  let current: unknown = payload
+  for (const key of dotted.split('.')) {
+    if (current === null || typeof current !== 'object') return undefined
+    current = (current as Record<string, unknown>)[key]
+  }
+  return current
+}
+
+/** Claude's ${path} substitution for mcp_tool input: string values may reference the
+ * hook's JSON input, such as ${tool_input.file_path}. Arrays and nested objects are
+ * walked; an unresolvable path stays literal; non-string looked-up values are
+ * JSON-encoded into the string. */
+function substituteInputPaths(value: unknown, payload: unknown): unknown {
+  if (typeof value === 'string') {
+    return value.replace(/\$\{([\w.]+)\}/g, (matchText, dotted: string) => {
+      const found = lookupPath(payload, dotted)
+      if (found === undefined) return matchText
+      return typeof found === 'string' ? found : JSON.stringify(found)
+    })
+  }
+  if (Array.isArray(value)) return value.map((entry) => substituteInputPaths(entry, payload))
+  if (value !== null && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, substituteInputPaths(entry, payload)]))
+  return value
+}
+
 /**
  * Claude's `type: "mcp_tool"` hook: call a tool on an already-connected MCP server
  * and treat its text output like command stdout. pi reaches the server through the
@@ -255,7 +282,9 @@ export async function runPromptHook(hook: HookCommand, payload: unknown, model:
  */
 export async function runMcpToolHook(hook: HookCommand, payload: unknown, timeoutMs: number): Promise<HookRunResult> {
   if (!hook.server || !hook.tool) return { code: 1, stdout: '', stderr: 'mcp_tool hook needs server and tool', timedOut: false }
-  const input = hook.input && typeof hook.input === 'object' ? hook.input : (payload as Record<string, unknown>)
+  // Claude: `input` is the arguments passed to the tool; without it the tool is
+  // called with no arguments, never handed the whole event payload.
+  const input = hook.input && typeof hook.input === 'object' ? (substituteInputPaths(hook.input, payload) as Record<string, unknown>) : {}
   let timer: ReturnType<typeof setTimeout> | undefined
   const deadline = new Promise<HookRunResult>((resolve) => {
     timer = setTimeout(() => resolve({ code: 1, stdout: '', stderr: `mcp_tool hook timed out after ${timeoutMs}ms`, timedOut: false }), timeoutMs)

package/package.json

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