agent-relay-runner 0.22.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/plugins/claude/hooks/pre-compact.sh

@@ -3,4 +3,10 @@ set -euo pipefail
 source "${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}/hooks/relay-status.sh"
 relay_install_hook_guard pre-compact
 
+payload="$(cat || true)"
+transcript_path="$(relay_json_string_field transcript_path "$payload")"
+
 relay_post_timeline_status busy provider-turn "" compacting
+# Pre-destroy seam (#183): compaction is about to discard context — capture this segment's
+# Insights (#184) from the full transcript first. The most common boundary in practice.
+relay_post_session_boundary "$transcript_path" compact

package/plugins/claude/hooks/relay-status.sh

@@ -72,10 +72,11 @@ relay_post_user_prompt() {
     -d "$body" >/dev/null 2>&1 || true
 }
 
-relay_post_session_end() {
-  # Insights #184: tell the runner the session ended so it can compute the
-  # end-of-session context-gathering ratio from the full transcript. Fire-and-forget;
-  # the transcript path is optional (the runner falls back to the last path it saw).
+relay_post_session_boundary() {
+  # Pre-destroy seam (#183): tell the runner a context reset or termination is imminent
+  # (compact/clear/logout/…) so it can run end-of-session work — the #184 context-gathering
+  # ratio capture — from the full transcript before the invasive op. Fire-and-forget; the
+  # transcript path is optional (the runner falls back to the last path it saw).
   local transcript_path="${1:-}"
   local reason="${2:-}"
   local port="${AGENT_RELAY_RUNNER_PORT:-}"
@@ -87,7 +88,7 @@ relay_post_session_end() {
     body="${body}\"reason\":\"$(relay_json_escape "$reason")\""
   fi
   body="${body}}"
-  curl -fsS --max-time 3 -X POST "http://127.0.0.1:${port}/session-end" \
+  curl -fsS --max-time 3 -X POST "http://127.0.0.1:${port}/session-boundary" \
     -H 'Content-Type: application/json' \
     -d "$body" >/dev/null 2>&1 || true
 }

package/plugins/claude/hooks/session-end.sh

@@ -10,14 +10,17 @@ transcript_path="$(relay_json_string_field transcript_path "$payload")"
 case "$reason" in
   clear)
     relay_post_timeline_status idle provider-turn subagent clearing-context
+    # /clear wipes the context — the most common work boundary for a long-lived agent.
+    # Capture this segment's Insights (#183/#184) before it's gone.
+    relay_post_session_boundary "$transcript_path" clear
     ;;
   resume)
     relay_post_status_clearing_subagents idle
     ;;
   logout|prompt_input_exit|bypass_permissions_disabled|other|*)
     relay_post_status_clearing_subagents offline
-    # Real session termination: capture end-of-session Insights (#184). Order after the
+    # Real session termination: capture end-of-session Insights (#183/#184). Order after the
     # status post is arbitrary — the runner reads the transcript file regardless.
-    relay_post_session_end "$transcript_path" "$reason"
+    relay_post_session_boundary "$transcript_path" "$reason"
     ;;
 esac

package/src/adapter.ts

@@ -1,5 +1,6 @@
 import type { AgentProfile, Message } from "agent-relay-sdk";
 import { isRecord } from "agent-relay-sdk";
+import type { SessionEvent } from "./session-insights";
 
 export type SemanticStatus = "idle" | "busy" | "offline" | "error";
 type ProviderWorkKind = "provider-turn" | "subagent";
@@ -84,6 +85,9 @@ export interface RunnerSpawnConfig {
   providerConfig: ProviderConfig;
   env: Record<string, string>;
   controlPort: number;
+  // Stage 2 (#215): the MCP endpoint the agent connects to — the runner-local proxy URL when the
+  // proxy is active. Undefined → the adapter targets the relay's MCP endpoint directly (Stage 1).
+  relayMcpEndpoint?: string;
   monitor?: {
     deliver(messages: Message[]): Promise<number[]>;
   };
@@ -130,6 +134,15 @@ export interface ProviderAdapter {
   shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void>;
   compact?(process: ManagedProcess): Promise<Record<string, unknown> | void>;
   clearContext?(process: ManagedProcess): Promise<Record<string, unknown> | void>;
+  // Normalize the session so far into the provider-agnostic SessionEvent stream the
+  // Insights context-ratio signal (#183/#184) reduces. Called by the runner's
+  // pre-session-destroy seam before any compact/clear/restart/shutdown. The runner owns
+  // the per-segment cursor (it slices events since the last capture), so this returns the
+  // full ordered event list for the current process lifetime. `ctx.transcriptPath` is
+  // supplied for transcript-backed providers (Claude); event-stream providers (Codex)
+  // ignore it and return their accumulated log. Return null when there is nothing to
+  // measure. Best-effort: may be omitted by providers without a session view yet.
+  collectSessionEvents?(process: ManagedProcess, ctx: { transcriptPath?: string }): Promise<SessionEvent[] | null>;
   // Interrupt the in-flight turn without ending the session (ESC for Claude's
   // tmux pane, turn/interrupt for the Codex app-server). Provider-independent at
   // the runner boundary; each adapter does what its provider actually supports.

package/src/adapters/claude-transcript.ts

@@ -10,6 +10,8 @@
 // entry carrying text, not just tool_result blocks). We collect the assistant
 // `text` blocks from that turn — thinking and tool_use are dropped.
 
+import { computeContextRatio, type SessionAnalysis, type SessionEvent } from "../session-insights";
+
 interface TranscriptBlock {
   type?: string;
   text?: string;
@@ -194,59 +196,14 @@ export function summarizeToolUse(name: string, input: Record<string, unknown> |
 // paired with cheap outcome proxies (user re-prompts, tool errors) so it's never read
 // alone — see the anti-Goodhart constraint in the epic.
 
-// Tools that acquire context without changing anything. Anything not matched here is
-// treated as an action (mutation, execution, or a delegation/direction decision) —
-// Bash counts as an action because it executes (a conservative, documented choice for
-// v0; `cat`/`ls` via Bash are misclassified, refine later if the data warrants it).
-const GATHERING_TOOLS = new Set([
-  "Read", "Grep", "Glob", "LS", "NotebookRead", "WebFetch", "WebSearch",
-]);
-const GATHERING_NAME = /(?:^|[._-])(read|get|list|search|grep|glob|find|fetch|query|browse|view|show|cat|status|inspect|lookup|symbols|snippet)/i;
-
-function isGatheringTool(name: string): boolean {
-  if (GATHERING_TOOLS.has(name)) return true;
-  // MCP / custom tools: classify by name shape (e.g. mcp__callmux__searxng_web_search).
-  return GATHERING_NAME.test(name);
-}
-
-export interface ContextRatioMetric {
-  /** Session-wide gathering fraction: gatheringCalls / totalToolCalls. The headline metric. */
-  ratio: number;
-  gatheringCalls: number;
-  actionCalls: number;
-  totalToolCalls: number;
-  /** Consecutive gathering calls before the first action — the "read N files before moving" signal. */
-  leadingGather: number;
-  /** Substantive assistant turns (turns that produced text or a tool call). */
-  turns: number;
-}
-
-export interface SessionOutcomeProxy {
-  /** Real user prompts in the session — more back-and-forth ~ more clarification/correction. */
-  userPrompts: number;
-  /** tool_result blocks flagged is_error — failures/workarounds the agent hit. */
-  toolErrors: number;
-}
-
-export interface SessionAnalysis {
-  metric: ContextRatioMetric;
-  outcome: SessionOutcomeProxy;
-}
-
 /**
- * Walk the full transcript and compute the context-gathering ratio plus paired outcome
- * proxies. Returns null when there's nothing substantive to measure (no tool calls) —
- * trivial sessions have nothing to learn from and shouldn't pollute the baselines.
+ * Normalize a full Claude transcript into the provider-agnostic `SessionEvent` stream
+ * (#183/#184). The classifier and ratio math live in `session-insights.ts` and are shared
+ * across providers; this only knows the Claude JSONL shape. Events are emitted in
+ * transcript order so `leadingGather` is meaningful.
  */
-export function analyzeSession(jsonl: string): SessionAnalysis | null {
-  let gatheringCalls = 0;
-  let actionCalls = 0;
-  let leadingGather = 0;
-  let sawAction = false;
-  let userPrompts = 0;
-  let toolErrors = 0;
-  let turns = 0;
-
+export function collectClaudeSessionEvents(jsonl: string): SessionEvent[] {
+  const events: SessionEvent[] = [];
   for (const line of jsonl.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -256,10 +213,10 @@ export function analyzeSession(jsonl: string): SessionAnalysis | null {
     } catch {
       continue;
     }
-    if (isRealUserPrompt(entry)) userPrompts++;
+    if (isRealUserPrompt(entry)) events.push({ type: "user_prompt" });
     if (entry.type === "user") {
       for (const b of blocks(entry.message)) {
-        if (b.type === "tool_result" && b.is_error === true) toolErrors++;
+        if (b.type === "tool_result" && b.is_error === true) events.push({ type: "tool_error" });
       }
       continue;
     }
@@ -269,31 +226,20 @@ export function analyzeSession(jsonl: string): SessionAnalysis | null {
       if (b.type === "text" && b.text?.trim()) producedSomething = true;
       if (b.type !== "tool_use" || typeof b.name !== "string" || !b.name) continue;
       producedSomething = true;
-      if (isGatheringTool(b.name)) {
-        gatheringCalls++;
-        if (!sawAction) leadingGather++;
-      } else {
-        actionCalls++;
-        sawAction = true;
-      }
+      events.push({ type: "tool", name: b.name });
     }
-    if (producedSomething) turns++;
+    if (producedSomething) events.push({ type: "turn" });
   }
+  return events;
+}
 
-  const totalToolCalls = gatheringCalls + actionCalls;
-  if (totalToolCalls === 0) return null;
-
-  return {
-    metric: {
-      ratio: gatheringCalls / totalToolCalls,
-      gatheringCalls,
-      actionCalls,
-      totalToolCalls,
-      leadingGather,
-      turns,
-    },
-    outcome: { userPrompts, toolErrors },
-  };
+/**
+ * Walk the full transcript and compute the context-gathering ratio plus paired outcome
+ * proxies. Returns null when there's nothing substantive to measure (no tool calls) —
+ * trivial sessions have nothing to learn from and shouldn't pollute the baselines.
+ */
+export function analyzeSession(jsonl: string): SessionAnalysis | null {
+  return computeContextRatio(collectClaudeSessionEvents(jsonl));
 }
 
 /** Count substantive assistant turns — used by the #185 introspection gate. */

package/src/adapters/claude.ts

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import type { Message } from "agent-relay-sdk";
@@ -6,6 +7,8 @@ import { shellEscape as shellQuote } from "agent-relay-sdk/shell-utils";
 import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
+import { collectClaudeSessionEvents } from "./claude-transcript";
+import type { SessionEvent } from "../session-insights";
 import { prepareClaudeProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
 import { relayMcpClaudeConfigArg } from "../relay-mcp";
 import { claudeProviderMessageText } from "./claude-delivery";
@@ -64,6 +67,19 @@ export class ClaudeAdapter implements ProviderAdapter {
     return { method: "tmux-inject", command: "/clear" };
   }
 
+  // #183/#184: parse the full Claude transcript into the shared SessionEvent stream. The
+  // runner slices per-segment, so we return the whole transcript's events each call.
+  async collectSessionEvents(_process: ManagedProcess, ctx: { transcriptPath?: string }): Promise<SessionEvent[] | null> {
+    if (!ctx.transcriptPath) return null;
+    let jsonl: string;
+    try {
+      jsonl = await readFile(ctx.transcriptPath, "utf8");
+    } catch {
+      return null;
+    }
+    return collectClaudeSessionEvents(jsonl);
+  }
+
   async interrupt(process: ManagedProcess): Promise<Record<string, unknown>> {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
@@ -204,7 +220,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     const args = [
       ...rigPrefix,
       ...pluginDirs.flatMap((dir) => ["--plugin-dir", dir]),
-      ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpClaudeConfigArg(config.relayUrl) : []),
+      ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpClaudeConfigArg(config.relayUrl, config.relayMcpEndpoint) : []),
       ...(profileAllowsRelayFeature(config, "statusLine") ? sessionStatusLineSettingsArgs(defaultArgs, config.providerArgs) : []),
       ...(config.systemPromptAppend ? ["--append-system-prompt", config.systemPromptAppend] : []),
       ...providerArgs,

package/src/adapters/codex.ts

@@ -8,6 +8,7 @@ import { profileAllowsRelayFeature, providerMessageText, RELAY_CONTEXT, type Man
 import { workspaceDepsNoteFromEnv } from "../relay-instructions";
 import { relayMcpCodexConfigArgs, tomlString } from "../relay-mcp";
 import { logger } from "../logger";
+import type { SessionEvent } from "../session-insights";
 
 /** Relay context prepended to a Codex agent's first turn: the standard relay
  * blurb plus, when running in an isolated workspace, the deps caveat (#159). */
@@ -41,6 +42,13 @@ export class CodexAdapter implements ProviderAdapter {
   private turnMessages: string[] = [];
   private readonly itemTextBuffers = new Map<string, string>();
   private captureMode: "final" | "full" = "final";
+  // #183/#184: the normalized session-event log for the current process lifetime, fed
+  // from the same completed-item stream that drives the chat mirror. The runner slices
+  // this per-segment (since the last compact/clear/restart) via its own cursor, so we
+  // accumulate and never clear mid-session; spawn() resets it for a fresh process. Soft
+  // cap below keeps a runaway session from growing memory unbounded.
+  private sessionEvents: SessionEvent[] = [];
+  private static readonly SESSION_EVENTS_CAP = 50_000;
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
@@ -75,6 +83,7 @@ export class CodexAdapter implements ProviderAdapter {
 
   async spawn(config: RunnerSpawnConfig): Promise<ManagedProcess> {
     this.captureMode = (config.providerConfig as ProviderConfig).chatCaptureMode ?? "final";
+    this.sessionEvents = []; // fresh process → fresh segment cursor (#184)
     const args = this.buildSpawnArgs(config, config.providerConfig as ProviderConfig);
     const appServer = Bun.spawn([args.command, ...args.args], {
       cwd: args.cwd,
@@ -261,7 +270,7 @@ export class CodexAdapter implements ProviderAdapter {
         ...codexModelConfigArgs(config.model, config.effort),
         ...codexApprovalConfigArgs(config.approvalMode),
         ...(profileAllowsRelayFeature(config, "skills") ? bundledSkillConfigArgs() : []),
-        ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpCodexConfigArgs(config.relayUrl) : []),
+        ...(profileAllowsRelayFeature(config, "mcp") ? relayMcpCodexConfigArgs(config.relayUrl, config.relayMcpEndpoint) : []),
         ...codexToolOutputTokenLimitConfigArgs(config),
         ...codexManagedConfigArgs(),
         "--listen",
@@ -377,13 +386,19 @@ export class CodexAdapter implements ProviderAdapter {
     const itemId = codexItemId(item);
     if (type === "agentMessage") {
       const text = (stringValue(item.text) ?? (itemId ? this.itemTextBuffers.get(itemId) : undefined))?.trim();
-      if (text) this.turnMessages.push(text);
+      if (text) {
+        this.turnMessages.push(text);
+        this.recordInsightEvent({ type: "turn" }); // a substantive assistant turn
+      }
       if (itemId) this.itemTextBuffers.delete(itemId);
       return;
     }
     if (type === "userMessage") {
       const text = codexUserMessageText(item.content);
-      if (text) this.sessionEventCb({ type: "prompt", origin: "terminal", body: text, ...(turnId ? { turnId } : {}) });
+      if (text) {
+        this.recordInsightEvent({ type: "user_prompt" });
+        this.sessionEventCb({ type: "prompt", origin: "terminal", body: text, ...(turnId ? { turnId } : {}) });
+      }
       return;
     }
     if (type === "reasoning") {
@@ -394,10 +409,31 @@ export class CodexAdapter implements ProviderAdapter {
       return;
     }
     const tool = codexToolSummary(type, item);
-    if (tool) this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "completed", ...(turnId ? { turnId } : {}) });
+    if (tool) {
+      this.recordInsightEvent({ type: "tool", name: codexInsightToolName(type, item) });
+      if (codexItemFailed(item)) this.recordInsightEvent({ type: "tool_error" });
+      this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "completed", ...(turnId ? { turnId } : {}) });
+    }
     if (itemId) this.itemTextBuffers.delete(itemId);
   }
 
+  // #183/#184: append to the session-event log with a soft cap. On overflow we drop the
+  // oldest half; the runner detects the resulting length shrink and resets its segment
+  // cursor (worst case: one slightly-truncated datapoint on a pathologically long session).
+  private recordInsightEvent(event: SessionEvent): void {
+    this.sessionEvents.push(event);
+    if (this.sessionEvents.length > CodexAdapter.SESSION_EVENTS_CAP) {
+      this.sessionEvents = this.sessionEvents.slice(this.sessionEvents.length >> 1);
+    }
+  }
+
+  // Whole-session event stream for the Insights context-ratio signal (#184). Codex learns
+  // about activity through app-server item events, not a transcript, so we replay the log
+  // accumulated since this process started. The runner owns per-segment slicing.
+  async collectSessionEvents(): Promise<SessionEvent[] | null> {
+    return [...this.sessionEvents];
+  }
+
   private handleCodexItemDelta(method: string, params: Record<string, unknown> | undefined): void {
     if (!method.includes("item/") && !method.includes("item.")) return;
     const item = isRecord(params?.item) ? params.item : undefined;
@@ -492,6 +528,31 @@ export function codexReasoningText(item: Record<string, unknown>): string {
 }
 
 /** Build a compact { label, body } activity summary for a Codex tool item. */
+// Canonical tool name for the #184 gathering/action classifier. Codex item types map to
+// names the shared classifier already understands: commandExecution executes (→ Bash, an
+// action), fileChange mutates (→ Edit), webSearch gathers (→ WebSearch, in the set), and
+// MCP/dynamic calls carry their real tool name so name-shape classification applies.
+export function codexInsightToolName(type: string | undefined, item: Record<string, unknown>): string {
+  switch (type) {
+    case "commandExecution": return "Bash";
+    case "fileChange": return "Edit";
+    case "webSearch": return "WebSearch";
+    case "mcpToolCall":
+    case "dynamicToolCall":
+    case "collabAgentToolCall":
+      return stringValue(item.tool) ?? type ?? "tool";
+    default: return type ?? "tool";
+  }
+}
+
+// Did a completed tool item fail? Mirrors Claude's tool_result is_error outcome proxy.
+export function codexItemFailed(item: Record<string, unknown>): boolean {
+  if (stringValue(item.status) === "failed") return true;
+  if (item.error != null && item.error !== false) return true;
+  const exitCode = item.exitCode ?? item.exit_code;
+  return typeof exitCode === "number" && exitCode !== 0;
+}
+
 export function codexToolSummary(type: string | undefined, item: Record<string, unknown>): { label: string; body: string } | null {
   const oneLine = (value: unknown): string => (typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "");
   const clip = (text: string): string => (text.length > 200 ? `${text.slice(0, 197)}…` : text);

package/src/claim-tracker.ts

@@ -83,14 +83,6 @@ export class ClaimTracker {
     return before !== this.currentStatus();
   }
 
-  clearKind(kind: ClaimKind): boolean {
-    const before = this.currentStatus();
-    for (const key of [...this.claims.keys()]) {
-      if (key.startsWith(`${kind}:`)) this.claims.delete(key);
-    }
-    return before !== this.currentStatus();
-  }
-
   expire(now = Date.now()): boolean {
     const before = this.currentStatus();
     for (const [key, claim] of this.claims) {
@@ -111,10 +103,6 @@ export class ClaimTracker {
     return [...reasons];
   }
 
-  activeClaims(): ClaimRecord[] {
-    return [...this.claims.values()];
-  }
-
   activeWork(): WorkRecord[] {
     return [...this.work.values()];
   }

package/src/control-server.ts

@@ -39,11 +39,12 @@ interface ControlServerOptions {
   // directly into the session (web terminal / TUI) so the runner can mirror it
   // into the dashboard chat and start tailing the turn transcript for reasoning.
   onUserPrompt?(input: { prompt: string; transcriptPath?: string }): Promise<void>;
-  // A provider SessionEnd hook signals the session is over so the runner can
-  // compute end-of-session Insights signals (#184 context ratio) from the full
-  // transcript. transcriptPath is optional — the runner falls back to the last
-  // path it saw during the session.
-  onSessionEnd?(input: { reason?: string; transcriptPath?: string }): Promise<void>;
+  // A provider session-boundary hook (Claude PreCompact / SessionEnd) signals an imminent
+  // context reset or termination so the runner can run end-of-session work (#183 pre-destroy
+  // seam: #184 context-ratio capture) before the invasive operation. `reason` is the raw
+  // provider reason (compact, clear, logout, …); transcriptPath is optional — the runner
+  // falls back to the last path it saw during the session.
+  onSessionBoundary?(input: { reason?: string; transcriptPath?: string }): Promise<void>;
   // Phase 1 observability (#198): a hook reporting an unhandled failure. The
   // control server already logs it FATAL; this is the seam for Phase 2 to also
   // surface it to the server via the runner outbox.
@@ -93,8 +94,8 @@ export function startControlServer(options: ControlServerOptions): ControlServer
       if (url.pathname === "/user-prompt" && req.method === "POST") {
         return handleUserPrompt(req, options);
       }
-      if (url.pathname === "/session-end" && req.method === "POST") {
-        return handleSessionEnd(req, options);
+      if (url.pathname === "/session-boundary" && req.method === "POST") {
+        return handleSessionBoundary(req, options);
       }
       if (url.pathname === "/log-level" && req.method === "GET") {
         return Response.json({ level: logger.getLevel(), levels: LOG_LEVELS });
@@ -375,13 +376,13 @@ async function handleUserPrompt(req: Request, options: ControlServerOptions): Pr
   return Response.json({ ok: true });
 }
 
-async function handleSessionEnd(req: Request, options: ControlServerOptions): Promise<Response> {
-  if (!options.onSessionEnd) return Response.json({ ok: false, reason: "session-end capture unavailable" });
+async function handleSessionBoundary(req: Request, options: ControlServerOptions): Promise<Response> {
+  if (!options.onSessionBoundary) return Response.json({ ok: false, reason: "session-boundary capture unavailable" });
   const body = await req.json().catch(() => null);
   const reason = isRecord(body) && typeof body.reason === "string" ? body.reason : undefined;
   const transcriptPath = isRecord(body) && typeof body.transcriptPath === "string" ? body.transcriptPath : undefined;
-  // Fire-and-forget: the SessionEnd hook must not block Claude shutting down.
-  void Promise.resolve(options.onSessionEnd({ reason, transcriptPath })).catch(() => {});
+  // Fire-and-forget: a PreCompact/SessionEnd hook must not block Claude compacting or exiting.
+  void Promise.resolve(options.onSessionBoundary({ reason, transcriptPath })).catch(() => {});
   return Response.json({ ok: true });
 }