Merge remote-tracking branch 'origin/master' into simpl-g-hook-contract

# Conflicts:
#	packages/hooks/hook-protocol/src/events.ts
#	packages/hooks/hook-protocol/tests/events.spec.ts
#	packages/hooks/hooks-claude/README.md
#	packages/hooks/hooks-claude/src/index.ts
#	packages/hooks/hooks-codex/README.md
#	packages/hooks/hooks-codex/src/index.ts

packages/hooks/hook-protocol/src/events.ts

@@ -43,16 +43,32 @@ export interface HookResultRecord {
    * event's semantics live here, in the lib that declares it, not per-bridge.
    */
   output: HookOutput
+  /**
+   * Character cap for the derived `stderrSummary`. The bound is the bridge's
+   * to own (its `stderrSummaryMaxChars` config) and is passed in explicitly —
+   * {@link DEFAULT_STDERR_SUMMARY_MAX_CHARS} is the reference default.
+   */
+  stderrSummaryMaxChars: number
 }
 
-/** How many characters of stderr the `hook/result.stderrSummary` field keeps. */
-const STDERR_SUMMARY_MAX = 500
+/**
+ * The reference default for {@link HookResultRecord.stderrSummaryMaxChars}
+ * (both bridges' config default). It lives here, once, next to the truncation
+ * rule it bounds, so the bridges cannot drift apart on the shared event's
+ * default cap.
+ */
+export const DEFAULT_STDERR_SUMMARY_MAX_CHARS = 500
 
-/** Truncate a stderr blob for the `hook/result.stderrSummary` field (`undefined` when empty). */
-function summarizeStderr(stderr: string): string | undefined {
+/**
+ * Truncate a hook's stderr for {@link HookResultRecord.stderrSummary}: trimmed,
+ * `undefined` when empty, cut at `maxChars` with an ellipsis when over. The
+ * bound is a parameter — like `runHook`'s `defaultTimeoutMs`, each bridge owns
+ * the config default and passes it in.
+ */
+export function summarizeStderr(stderr: string, maxChars: number): string | undefined {
   const t = stderr.trim()
   if (t.length === 0) return undefined
-  return t.length > STDERR_SUMMARY_MAX ? t.slice(0, STDERR_SUMMARY_MAX) + '…' : t
+  return t.length > maxChars ? t.slice(0, maxChars) + '…' : t
 }
 
 /** Append a `hook/invoked` provenance event to `session`. */
@@ -70,12 +86,13 @@ export function appendHookInvoked(session: Session, invocation: HookInvocation):
  * Append a `hook/result` outcome event to `session` (pairs with a prior
  * `hook/invoked`). Owns the durable event's semantics: `decision` is the hook's
  * parsed decision, else `'stop'` when it asked to halt (`continue: false`),
- * else `'pass'`; `stderrSummary` is the trimmed stderr truncated to 500
- * characters (omitted when empty); `exitCode` is omitted when the hook never ran.
+ * else `'pass'`; `stderrSummary` is the trimmed stderr truncated to
+ * `record.stderrSummaryMaxChars` characters (omitted when empty); `exitCode`
+ * is omitted when the hook never ran.
  */
 export function appendHookResult(session: Session, record: HookResultRecord): void {
   const { output } = record
-  const stderrSummary = summarizeStderr(output.stderr)
+  const stderrSummary = summarizeStderr(output.stderr, record.stderrSummaryMaxChars)
   session.append('hook/result', {
     turn: record.turn,
     point: record.point,

packages/hooks/hook-protocol/src/index.ts

@@ -36,5 +36,5 @@ export { DEFAULT_HOOK_TIMEOUT_MS, runHook } from './runner.ts'
 export type { RunHookOptions } from './runner.ts'
 export { mergeHookOutputs } from './merge.ts'
 export type { MergedDecision, MergedHookOutcome } from './merge.ts'
-export { appendHookInvoked, appendHookResult } from './events.ts'
+export { appendHookInvoked, appendHookResult, DEFAULT_STDERR_SUMMARY_MAX_CHARS, summarizeStderr } from './events.ts'
 export type { HookInvocation, HookResultRecord } from './events.ts'

packages/hooks/hook-protocol/src/runner.ts

@@ -20,8 +20,9 @@ import type { CommandHook, HookOutput } from './types.ts'
 /**
  * The reference default per-hook timeout, in ms (10 minutes) — the value both
  * Claude Code and Codex apply to a hook whose config sets no `timeout`. It
- * lives here, once, as the protocol's default; a per-hook {@link CommandHook.timeoutSec}
- * is the override surface.
+ * lives here, once, as the protocol's default; the bridges' `defaultTimeoutMs`
+ * config defaults to it, and a per-hook {@link CommandHook.timeoutSec} is the
+ * override surface.
  */
 export const DEFAULT_HOOK_TIMEOUT_MS = 600_000
 
@@ -37,6 +38,12 @@ export interface RunHookOptions {
   signal?: AbortSignal
   /** Whether to append a trailing newline to the stdin payload (CC yes, Codex no). */
   trailingNewline: boolean
+  /**
+   * Timeout applied when the hook's config sets no `timeout` of its own. The
+   * bridge owns the default (its `defaultTimeoutMs` config, reference default
+   * {@link DEFAULT_HOOK_TIMEOUT_MS}) and passes it in explicitly.
+   */
+  defaultTimeoutMs: number
   /**
    * The event this hook is firing for (e.g. `'PreToolUse'`). When set, a
    * structured `hookSpecificOutput` block whose `hookEventName` names a DIFFERENT
@@ -49,7 +56,7 @@ export interface RunHookOptions {
 /**
  * Run `hook` via `bash` with `options.payload` serialized to its stdin, then
  * decode the result into a {@link HookOutput}. The hook's configured
- * `timeoutSec` (wire unit: seconds) overrides {@link DEFAULT_HOOK_TIMEOUT_MS}.
+ * `timeoutSec` (wire unit: seconds) overrides `options.defaultTimeoutMs`.
  * The command runs with the dialect's `env` merged after the executor's
  * credential scrub (the trusted-plugin path). NEVER throws: an infrastructure
  * failure (the executor rejecting) is surfaced as a {@link HookOutput} with
@@ -61,7 +68,7 @@ export async function runHook(
   hook: CommandHook,
   options: RunHookOptions,
 ): Promise<HookOutput> {
-  const timeoutMs = hook.timeoutSec !== undefined ? hook.timeoutSec * 1000 : DEFAULT_HOOK_TIMEOUT_MS
+  const timeoutMs = hook.timeoutSec !== undefined ? hook.timeoutSec * 1000 : options.defaultTimeoutMs
   const stdin = JSON.stringify(options.payload) + (options.trailingNewline ? '\n' : '')
 
   const request = {