pi-code 1.0.30 → 1.0.31

package/extensions/hooks/decisions.ts

@@ -19,9 +19,14 @@ export interface HookDecision {
   ask?: boolean
 }
 
+/** Claude's stdout shape rule: only output that starts with `{` and ends with `}`
+ * (ignoring surrounding whitespace) is read as JSON output; a JSON array, a quoted
+ * string, or a bare number is plain text. Multi-line output whose lines each parse
+ * as JSON on their own with no output field set is plain text too (that case
+ * arrives here as a parse failure and hookJsonError sorts it from a real error). */
 export function tryParseJson(text: string):
   | {
-      hookSpecificOutput?: { permissionDecision?: string; permissionDecisionReason?: string; additionalContext?: string; updatedInput?: unknown }
+      hookSpecificOutput?: { permissionDecision?: string; permissionDecisionReason?: string; additionalContext?: string; updatedInput?: unknown; suppressOriginalPrompt?: boolean }
       decision?: string
       reason?: string
       continue?: boolean
@@ -32,13 +37,58 @@ export function tryParseJson(text: string):
       ok?: boolean
     }
   | undefined {
+  const trimmed = text.trim()
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) return undefined
   try {
-    return JSON.parse(text)
+    const parsed: unknown = JSON.parse(trimmed)
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? (parsed as ReturnType<typeof tryParseJson>) : undefined
   } catch {
     return undefined
   }
 }
 
+/** Top-level JSON output fields; a multi-line output where a line sets one of
+ * these is a parse failure rather than plain text, as Claude documents. */
+const OUTPUT_FIELDS = new Set(['decision', 'reason', 'continue', 'stopReason', 'systemMessage', 'suppressOutput', 'hookSpecificOutput', 'updatedToolOutput', 'updatedMCPToolOutput', 'ok'])
+
+/** Claude reports a `<hook> hook error` notice when {..}-shaped stdout cannot be
+ * read as JSON output, and does not treat that stdout as plain text. Returns the
+ * error message for that case; undefined for valid JSON output and for output the
+ * shape rule already reads as plain text (including the multi-line case). */
+export function hookJsonError(text: string): string | undefined {
+  const trimmed = text.trim()
+  if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) return undefined
+  let parseError: string
+  try {
+    JSON.parse(trimmed)
+    return undefined
+  } catch (error) {
+    parseError = error instanceof Error ? error.message : String(error)
+  }
+  const lines = trimmed
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line !== '')
+  if (lines.length >= 2 && !multiLineSetsOutputField(lines)) return undefined
+  return `invalid JSON output: ${parseError}`
+}
+
+/** Whether every line parses as JSON and at least one sets an output field; a
+ * non-JSON line means the multi-line rule does not apply (still a parse error). */
+function multiLineSetsOutputField(lines: string[]): boolean {
+  let setsField = false
+  for (const line of lines) {
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(line)
+    } catch {
+      return true // not all-JSON: the whole output is a parse failure
+    }
+    if (parsed !== null && typeof parsed === 'object' && Object.keys(parsed).some((key) => OUTPUT_FIELDS.has(key))) setsField = true
+  }
+  return setsField
+}
+
 /** The reason a JSON body's blocking decision carries, whichever spelling made it. */
 function jsonBlockingReason(parsed: ReturnType<typeof tryParseJson>): string | undefined {
   if (parsed?.hookSpecificOutput?.permissionDecision === 'deny') return parsed.hookSpecificOutput.permissionDecisionReason
@@ -94,6 +144,10 @@ function surfaceHookFailures(commands: HookCommand[], results: HookRunResult[],
   if (!notify) return
   for (const [i, result] of results.entries()) {
     if (result.spawnFailed) notify(`Hook failed to run: ${commands[i].command}: ${result.stderr.trim() || 'unknown error'}`)
+    // Claude shows a `<hook> hook error` notice when {..}-shaped stdout cannot be
+    // read as JSON output (exit 2 still blocks and reads its own channels).
+    const jsonError = result.code === 2 ? undefined : hookJsonError(result.stdout)
+    if (jsonError !== undefined) notify(`${commands[i].command} hook error: ${jsonError}`)
   }
 }
 
@@ -196,6 +250,8 @@ export interface PromptDecision {
   block: boolean
   reason?: string
   context: string
+  /** Claude's suppressOriginalPrompt: the hook's context replaces the prompt. */
+  suppress?: boolean
 }
 
 /** Additional context a UserPromptSubmit hook contributes: an explicit
@@ -203,6 +259,8 @@ export interface PromptDecision {
 export function promptContext(stdout: string): string {
   const parsed = tryParseJson(stdout)
   if (parsed) return parsed.hookSpecificOutput?.additionalContext ?? ''
+  // Malformed JSON output is an error, not plain text: no context is added.
+  if (hookJsonError(stdout) !== undefined) return ''
   return stdout.trim()
 }
 
@@ -221,13 +279,17 @@ export async function runUserPromptSubmit(config: HooksConfig, prompt: string, r
   }
   if (onSystemMessage) surfaceSystemMessages(results, onSystemMessage)
   const contexts: string[] = []
+  let suppress = false
   for (const result of results) {
     const decision = interpretHookResult(result.code, result.stdout, result.stderr)
     if (decision.block) return { block: true, reason: decision.reason, context: '' }
+    // Claude's suppressOriginalPrompt: any hook setting it hides the original
+    // prompt, and the collected context is what reaches the model.
+    if (tryParseJson(result.stdout)?.hookSpecificOutput?.suppressOriginalPrompt === true) suppress = true
     const context = promptContext(result.stdout)
     if (context) contexts.push(context)
   }
-  return { block: false, context: contexts.join('\n') }
+  return { block: false, context: contexts.join('\n'), suppress }
 }
 
 /** The feedback lines one PostToolUse/PostToolUseFailure result appends next to the

package/extensions/hooks/index.ts

@@ -187,6 +187,9 @@ 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
+  /** Tool start times per call id, for Claude's duration_ms on PostToolUse: the
+   * clock starts after PreToolUse hooks and any confirm dialog resolve. */
+  const toolStartTimes = new Map<string, number>()
   /** 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. */
@@ -417,13 +420,18 @@ export default function hooksExtension(pi: ExtensionAPI) {
       // additionalContext is delivered alongside the tool result, so stash it for
       // this call's tool_result to append.
       if (decision.context && decision.context.length > 0) pendingToolContext.set(event.toolCallId, decision.context)
+      // Claude's duration_ms excludes PreToolUse hook time, so the clock starts here.
+      toolStartTimes.set(event.toolCallId, Date.now())
       return undefined
     }
     // Claude's "ask": prompt the user and let the call through if they approve.
     // With no UI (headless) the block stands, which is the safe default.
     if (decision.ask && ctx.hasUI) {
       const approved = await ctx.ui.confirm(`Allow ${event.toolName}?`, decision.reason ?? 'A hook asks you to confirm this tool call.')
-      return approved ? undefined : blockedToolCall(decision.reason)
+      if (!approved) return blockedToolCall(decision.reason)
+      // Claude's duration_ms also excludes time in permission prompts.
+      toolStartTimes.set(event.toolCallId, Date.now())
+      return undefined
     }
     return blockedToolCall(decision.reason)
   })
@@ -451,7 +459,9 @@ export default function hooksExtension(pi: ExtensionAPI) {
     if (commands.length === 0 && pending.length === 0) return
     const translatedInput = alias === undefined ? claudeToolInput(event.toolName, event.input, ctx.cwd) : undefined
     const response = (alias === undefined && !event.isError ? claudeToolResponse(event.toolName, event.input, textContent(event.content), event.isError, ctx.cwd) : undefined) ?? { content: event.content, details: event.details, isError: event.isError }
-    const payload = { hook_event_name: eventName, tool_name: translatedName ?? event.toolName, tool_input: translatedInput ?? event.input, tool_response: response }
+    const startedAt = toolStartTimes.get(event.toolCallId)
+    toolStartTimes.delete(event.toolCallId)
+    const payload = { hook_event_name: eventName, tool_name: translatedName ?? event.toolName, tool_input: translatedInput ?? event.input, tool_response: response, ...(startedAt === undefined ? {} : { duration_ms: Date.now() - startedAt }) }
     const run = boundRunner(ctx, { tool_use_id: event.toolCallId })
     const results = await Promise.all(commands.map((command) => run(command, payload, timeoutMs(command))))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
@@ -515,8 +525,10 @@ export default function hooksExtension(pi: ExtensionAPI) {
       return { action: 'handled' }
     }
     // Claude injects a UserPromptSubmit hook's context ahead of the prompt; transform is
-    // pi's seam for rewriting the submitted text.
-    if (decision.context) return { action: 'transform', text: `${decision.context}\n\n${event.text}` }
+    // pi's seam for rewriting the submitted text. With suppressOriginalPrompt the
+    // context replaces the prompt entirely (honored only when context exists, since
+    // an empty submission would be no turn at all).
+    if (decision.context) return { action: 'transform', text: decision.suppress ? decision.context : `${decision.context}\n\n${event.text}` }
     return { action: 'continue' }
   })
 
@@ -609,13 +621,19 @@ export default function hooksExtension(pi: ExtensionAPI) {
 
   pi.on('session_before_compact', async (event, ctx) => {
     const trigger = claudeSpelling(PRECOMPACT_TRIGGER, event.reason)
-    const results = await runNotifyHooks(matchingCommands(config.PreCompact, trigger.names), { hook_event_name: 'PreCompact', trigger: trigger.value }, boundRunner(ctx))
+    // Claude's custom_instructions: the /compact arguments on a manual run, empty
+    // on an automatic one; pi carries them on the event directly.
+    const payload = { hook_event_name: 'PreCompact', trigger: trigger.value, custom_instructions: event.customInstructions ?? '' }
+    const results = await runNotifyHooks(matchingCommands(config.PreCompact, trigger.names), payload, boundRunner(ctx))
     surfaceSystemMessages(results, (message) => ctx.ui.notify(message, 'warning'))
   })
 
   pi.on('session_compact', async (event, ctx) => {
     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))
+    // Claude's compact_summary: the summary that replaced the compacted history.
+    const summary = (event as { compactionEntry?: { summary?: unknown } }).compactionEntry?.summary
+    const payload = { hook_event_name: 'PostCompact', trigger: trigger.value, ...(typeof summary === 'string' ? { compact_summary: summary } : {}) }
+    const results = await runNotifyHooks(matchingCommands(config.PostCompact, trigger.names), payload, 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,

package/package.json

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