ashlr-plugin 1.36.4

package/hooks/pretooluse-websearch.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+/**
+ * pretooluse-websearch.ts — PreToolUse hook for the WebSearch tool.
+ *
+ * In redirect mode (default) this hook BLOCKS the native WebSearch call and
+ * routes the agent to ashlr__websearch, which deduplicates results by domain,
+ * truncates snippets to ~500 chars, and synthesizes a 1-paragraph summary.
+ *
+ * Set `ASHLR_HOOK_MODE=nudge` to downgrade to a soft suggestion.
+ * Set `ASHLR_HOOK_MODE=off` (or `~/.ashlr/settings.json { toolRedirect: false }`)
+ * for total pass-through.
+ */
+
+import {
+  buildNudgeContext,
+  buildPassThrough,
+  buildRedirectBlock,
+  flushHookTimings,
+  getHookModeFor,
+  parsePayload,
+  readStdin,
+  recordHookTiming,
+} from "./pretooluse-common";
+import { installHookTimeout } from "./pretooluse-common";
+
+if (import.meta.main) installHookTimeout("pretooluse-websearch");
+
+const hookStartedAt = Date.now();
+
+async function exit(code: number, outcome: "ok" | "bypass" | "block" | "error", tool?: string): Promise<never> {
+  recordHookTiming({ hook: "pretooluse-websearch", tool, durationMs: Date.now() - hookStartedAt, outcome });
+  await flushHookTimings();
+  process.exit(code);
+}
+
+const raw = await readStdin();
+const payload = parsePayload(raw);
+if (!payload) await exit(0, "ok");
+
+const tool = payload!.tool_name || undefined;
+if (payload!.tool_name !== "WebSearch") await exit(0, "ok", tool);
+if (payload!.bypass) await exit(0, "bypass", tool);
+
+const mode = getHookModeFor("websearch");
+if (mode === "off") {
+  process.stdout.write(JSON.stringify(buildPassThrough()));
+  await exit(0, "ok", tool);
+}
+
+// Extract query from the raw payload for the redirect message.
+let query = "<query>";
+try {
+  const parsed = JSON.parse(raw) as { tool_input?: { query?: string } };
+  if (typeof parsed?.tool_input?.query === "string") query = parsed.tool_input.query;
+} catch {
+  /* ignore */
+}
+
+if (mode === "nudge") {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext:
+          `[ashlr] Prefer the MCP tool \`ashlr__websearch\` over the built-in WebSearch. ` +
+          `It deduplicates results by domain, truncates snippets to ~500 chars, and synthesizes ` +
+          `a 1-paragraph summary when more than 3 results are returned — saving 40-80% tokens. ` +
+          `Call it with { "query": ${JSON.stringify(query)} }.`,
+      },
+    }),
+  );
+  await exit(0, "ok", tool);
+}
+
+// Default: redirect mode — block and route to ashlr__websearch.
+const safeQuery = query.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+const reason =
+  `[ashlr] Blocking the built-in WebSearch. Call ` +
+  `mcp__plugin_ashlr_ashlr__ashlr__websearch instead — it deduplicates results ` +
+  `by domain, truncates snippets to ~500 chars, and synthesizes a 1-paragraph ` +
+  `summary for result sets > 3 entries. ` +
+  `Equivalent call: { "query": "${safeQuery}" }. ` +
+  `Set ASHLR_HOOK_MODE=nudge to downgrade this redirect to a soft suggestion.`;
+process.stdout.write(JSON.stringify(buildRedirectBlock(reason)));
+await exit(0, "block", tool);

package/hooks/pretooluse-write.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+/**
+ * pretooluse-write.ts — PreToolUse hook for the Write tool (new-file creation).
+ *
+ * v1.22 (Track C): covers the Write tool for cases where ashlr__write provides
+ * compression benefit. The key distinction:
+ *
+ *   - Write on a NON-EXISTENT path (new-file creation): pass through.
+ *     ashlr__write on a new file still avoids echoing content, but since Claude
+ *     Code's native Write for a new file doesn't echo content back either, the
+ *     savings differential is minimal — don't block the agent.
+ *
+ *   - Write on an EXISTING file (full rewrite): redirect to ashlr__write.
+ *     Native Write echoes the full new content back; ashlr__write delegates to
+ *     ashlr__edit (diff format) — ~80% token savings on large files.
+ *
+ * Note: The existing pretooluse-edit.ts hook also fires for Write (via its
+ * "Edit|Write|MultiEdit" matcher) and handles large existing files. This hook
+ * specifically targets Write with a Write-focused redirect message pointing at
+ * ashlr__write rather than ashlr__edit. The two hooks can coexist — each
+ * provides a redirect; Claude Code will use the first deny it sees.
+ *
+ * Size threshold: same 5KB as pretooluse-edit (smaller files: savings don't
+ * materialize, pass through to avoid friction).
+ */
+
+import {
+  buildPassThrough,
+  buildRedirectBlock,
+  fileSize,
+  flushHookTimings,
+  getHookModeFor,
+  isInsideCwd,
+  isInsidePluginRoot,
+  parsePayload,
+  pluginRootFrom,
+  readStdin,
+  recordHookTiming,
+} from "./pretooluse-common";
+import { installHookTimeout } from "./pretooluse-common";
+
+if (import.meta.main) installHookTimeout("pretooluse-write");
+
+const THRESHOLD = 5120;
+const hookStartedAt = Date.now();
+
+async function exit(code: number, outcome: "ok" | "bypass" | "block" | "error", tool?: string): Promise<never> {
+  recordHookTiming({ hook: "pretooluse-write", tool, durationMs: Date.now() - hookStartedAt, outcome });
+  await flushHookTimings();
+  process.exit(code);
+}
+
+const raw = await readStdin();
+const payload = parsePayload(raw);
+if (!payload) await exit(0, "ok");
+
+const tool = payload!.tool_name || undefined;
+if (payload!.tool_name !== "Write") await exit(0, "ok", tool);
+if (!payload!.file_path) await exit(0, "ok", tool);
+if (payload!.bypass) await exit(0, "bypass", tool);
+
+const pluginRoot = pluginRootFrom(import.meta.url);
+if (isInsidePluginRoot(payload!.file_path, pluginRoot)) await exit(0, "ok", tool);
+
+const mode = getHookModeFor("write");
+if (mode === "off") {
+  process.stdout.write(JSON.stringify(buildPassThrough()));
+  await exit(0, "ok", tool);
+}
+
+// Nudge mode: soft suggestion for existing files only. New-file Write never nudged.
+if (mode === "nudge") {
+  const size = fileSize(payload!.file_path);
+  if (size === null) {
+    // New file — pass through silently.
+    process.stdout.write(JSON.stringify(buildPassThrough()));
+    await exit(0, "ok", tool);
+  }
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext:
+          `[ashlr] You're rewriting an existing file with the built-in Write tool. ` +
+          `Prefer \`ashlr__write\` — it delegates to ashlr__edit (diff format) for ` +
+          `existing files, returning only a compact diff summary instead of the full new content. ` +
+          `Call it with { "filePath": "${payload!.file_path}", "content": "..." }.`,
+      },
+    }),
+  );
+  await exit(0, "ok", tool);
+}
+
+// Redirect mode: only redirect existing files above the size threshold.
+const size = fileSize(payload!.file_path);
+if (size === null) {
+  // New file — not compressible, pass through.
+  process.stdout.write(JSON.stringify(buildPassThrough()));
+  await exit(0, "ok", tool);
+}
+if (size! <= THRESHOLD) await exit(0, "ok", tool);
+
+// Outside cwd: nudge only, don't block.
+if (!isInsideCwd(payload!.file_path)) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext:
+          `[ashlr] You're rewriting an existing file with the built-in Write tool. ` +
+          `Prefer \`ashlr__write\` for compact diff output. ` +
+          `Call it with { "filePath": "${payload!.file_path}", "content": "..." }.`,
+      },
+    }),
+  );
+  await exit(0, "ok", tool);
+}
+
+const mcp = "mcp__plugin_ashlr_ashlr__ashlr__write";
+const reason =
+  `[ashlr] To bypass: set ASHLR_HOOK_MODE=nudge in ~/.ashlr/config.json. ` +
+  `Current rule: blocking built-in Write on ${payload!.file_path} (${size} bytes) — ` +
+  `call ${mcp} instead, which delegates to ashlr__edit (diff format) for existing ` +
+  `files and returns only a compact diff summary, avoiding the full content echo ` +
+  `(~80% token savings on files this size). ` +
+  `Equivalent call: { "filePath": "${payload!.file_path}", "content": "..." }.`;
+process.stdout.write(JSON.stringify(buildRedirectBlock(reason)));
+await exit(0, "block", tool);

package/hooks/pulse-emit.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env bun
+/**
+ * pulse-emit.ts — opt-in Pulse emitter.
+ *
+ * When `ASHLR_PULSE_OTLP_ENDPOINT` is set, fires one OTLP/HTTP-JSON span
+ * per tool call to a Pulse server (the repo next door, `ashlrai/ashlr-pulse`).
+ * When it's unset, the hook is a 1-ms exit — the plugin's zero-telemetry-by-
+ * default posture is preserved. There is no implicit "cloud" path; users who
+ * want shared visibility point at their own pulse server.
+ *
+ * Privacy
+ *   - No prompts, completions, cwd paths, or tool input contents are sent.
+ *   - The cwd is hashed (`claude.project.hash`); repo name + branch are sent
+ *     as plain strings because those are already on the user's remote.
+ *   - Token counts are NULL at the plugin layer — provider token usage lives
+ *     in the LLM response, which the plugin doesn't see. Pulse correctly
+ *     maps these to NULL columns.
+ *
+ * Kill switches / env
+ *   - `ASHLR_PULSE_OTLP_ENDPOINT`  — set to `http://host/api/otlp/v1/traces`
+ *   - `ASHLR_PULSE_PAT`            — Bearer PAT minted on the Pulse server.
+ *                                    When set, takes precedence over the
+ *                                    x-ashlr-user dev fallback. Required for
+ *                                    production servers (NODE_ENV=production
+ *                                    rejects the dev header).
+ *   - `ASHLR_PULSE_USER`           — overrides the `x-ashlr-user` header (dev only)
+ *   - `ASHLR_PULSE_TIMEOUT_MS`     — per-POST timeout (default 1500)
+ *
+ * Hook contract: PostToolUse receives tool_name / tool_input / tool_result on
+ * stdin as JSON. We never exit non-zero; the hook is fail-open.
+ */
+
+import { createHash } from "crypto";
+import { spawnSync } from "child_process";
+
+const ENDPOINT = process.env.ASHLR_PULSE_OTLP_ENDPOINT;
+if (!ENDPOINT) process.exit(0);
+
+const TIMEOUT_MS = Number(process.env.ASHLR_PULSE_TIMEOUT_MS ?? "1500");
+const USER = process.env.ASHLR_PULSE_USER ?? process.env.USER ?? "dev-local";
+const PAT = process.env.ASHLR_PULSE_PAT;
+
+function size(v: unknown): number {
+  if (v == null) return 0;
+  if (typeof v === "string") return Buffer.byteLength(v, "utf-8");
+  try { return Buffer.byteLength(JSON.stringify(v), "utf-8"); } catch { return 0; }
+}
+
+function gitInfo(cwd: string): { repo: string | null; branch: string | null } {
+  try {
+    const branch = spawnSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf-8",
+      timeout: 500,
+    });
+    const remote = spawnSync("git", ["-C", cwd, "config", "--get", "remote.origin.url"], {
+      encoding: "utf-8",
+      timeout: 500,
+    });
+    const br = branch.status === 0 ? branch.stdout.trim() : null;
+    let repo: string | null = null;
+    if (remote.status === 0) {
+      const url = remote.stdout.trim();
+      // Extract owner/name from either https://host/owner/name(.git) or git@host:owner/name(.git)
+      const m = url.match(/[:\/]([^:\/]+\/[^:\/]+?)(?:\.git)?$/);
+      if (m) repo = m[1] ?? null;
+    }
+    return { repo, branch: br };
+  } catch {
+    return { repo: null, branch: null };
+  }
+}
+
+function sessionId(): string {
+  const explicit = process.env.CLAUDE_SESSION_ID;
+  if (explicit && explicit.trim().length > 0) return explicit.trim();
+  const seed = `${process.cwd()}:${process.ppid ?? "?"}`;
+  let h = 0;
+  for (let i = 0; i < seed.length; i++) h = ((h << 5) - h + seed.charCodeAt(i)) | 0;
+  return `h${(h >>> 0).toString(16)}`;
+}
+
+function nowUnixNano(): string {
+  // hrtime.bigint() is process-local; map via wall clock + high-res offset so
+  // Pulse can sort across processes. OTLP accepts the int-as-string form.
+  return String(BigInt(Date.now()) * 1_000_000n);
+}
+
+interface HookInput {
+  tool_name?: string;
+  tool_input?: unknown;
+  tool_result?: unknown;
+  tool_response?: unknown;
+}
+
+function buildPayload(input: HookInput): unknown {
+  const tool = typeof input.tool_name === "string" ? input.tool_name : "unknown";
+  const inBytes = size(input.tool_input);
+  const outBytes = size(input.tool_result ?? input.tool_response);
+  const cwd = process.cwd();
+  const projectHash = createHash("sha256").update(cwd).digest("hex");
+  const { repo, branch } = gitInfo(cwd);
+  const sid = sessionId();
+  const ts = nowUnixNano();
+
+  const attributes: Array<{ key: string; value: Record<string, unknown> }> = [
+    // GenAI marker — Pulse's spanToActivityEvent requires at least one of
+    // gen_ai.system or a claude.* attribute.
+    { key: "gen_ai.system",              value: { stringValue: "anthropic" } },
+    { key: "claude.session.id",          value: { stringValue: sid } },
+    { key: "claude.tool.calls_count",    value: { intValue: "1" } },
+    { key: "claude.tool.calls_types",    value: { stringValue: tool } },
+    { key: "claude.project.hash",        value: { stringValue: projectHash } },
+    { key: "claude.tool.input_bytes",    value: { intValue: String(inBytes) } },
+    { key: "claude.tool.output_bytes",   value: { intValue: String(outBytes) } },
+  ];
+  if (repo)   attributes.push({ key: "claude.repo.name",   value: { stringValue: repo } });
+  if (branch) attributes.push({ key: "claude.git.branch",  value: { stringValue: branch } });
+
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [
+            { key: "service.name",     value: { stringValue: "ashlr-plugin" } },
+            { key: "service.instance", value: { stringValue: sid } },
+          ],
+        },
+        scopeSpans: [
+          {
+            scope: { name: "ashlr-plugin", version: "1" },
+            spans: [
+              {
+                name: `tool.${tool}`,
+                startTimeUnixNano: ts,
+                endTimeUnixNano:   ts,
+                attributes,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+async function postOtlp(payload: unknown): Promise<void> {
+  const ctl = new AbortController();
+  const t = setTimeout(() => ctl.abort(), TIMEOUT_MS);
+  try {
+    // PAT (Bearer) takes precedence — required for production Pulse
+    // servers. Falls back to the x-ashlr-user dev header for local-only
+    // setups. Only one auth header is sent so the server's auth path
+    // stays unambiguous.
+    const headers: Record<string, string> = { "content-type": "application/json" };
+    if (PAT) headers["authorization"] = `Bearer ${PAT}`;
+    else headers["x-ashlr-user"] = USER;
+
+    await fetch(ENDPOINT as string, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: ctl.signal,
+    });
+  } catch (e) {
+    // best-effort — never surface to the agent, but leave a stderr trace so
+    // production failures can be grepped.
+    process.stderr.write("[ashlr-pulse-emit] OTLP POST failed: " + (e instanceof Error ? e.message : String(e)) + "\n");
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+// Drain stdin (hook input JSON), build payload, POST, exit 0.
+const chunks: Buffer[] = [];
+process.stdin.on("data", (c: Buffer) => chunks.push(c));
+process.stdin.on("end", async () => {
+  let input: HookInput = {};
+  try {
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (raw) input = JSON.parse(raw) as HookInput;
+  } catch (e) {
+    // best-effort — leave a stderr trace.
+    process.stderr.write("[ashlr-pulse-emit] stdin parse failed: " + (e instanceof Error ? e.message : String(e)) + "\n");
+  }
+
+  try {
+    const payload = buildPayload(input);
+    await postOtlp(payload);
+  } catch (e) {
+    // never block, but leave a stderr trace.
+    process.stderr.write("[ashlr-pulse-emit] payload build/post failed: " + (e instanceof Error ? e.message : String(e)) + "\n");
+  }
+  process.exit(0);
+});
+
+// Expose for tests.
+export { buildPayload };

package/hooks/session-end-consolidate.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# ashlr-plugin SessionEnd: consolidate pending genome proposals.
+#
+# Invoked by Claude Code on session shutdown. Hands off to
+# scripts/genome-auto-consolidate.ts which reads proposals.jsonl in the
+# current project's genome, merges them into their target sections, and
+# truncates the queue.
+#
+# Best-effort: a failed consolidation should never disturb the user's
+# session exit. All output goes to stderr; the hook exits 0 always.
+
+set +e
+
+if [ "${ASHLR_GENOME_AUTO:-1}" = "0" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(dirname "$SCRIPT_DIR")}"
+CONSOLIDATE_TS="$PLUGIN_ROOT/scripts/genome-auto-consolidate.ts"
+
+if ! command -v bun >/dev/null 2>&1; then
+  exit 0
+fi
+if [ ! -f "$CONSOLIDATE_TS" ]; then
+  exit 0
+fi
+
+TARGET_DIR="${PROJECT_ROOT:-$PWD}"
+
+# Run in background so session teardown isn't delayed by filesystem latency.
+# The script is idempotent and bounded, so fire-and-forget is safe.
+bun run "$CONSOLIDATE_TS" --dir "$TARGET_DIR" 1>&2 2>/dev/null &
+
+exit 0

package/hooks/session-end-consolidate.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+/**
+ * session-end-consolidate.ts — Cross-platform replacement for session-end-consolidate.sh.
+ *
+ * Invoked by Claude Code on session shutdown. Two responsibilities:
+ *   1. Consolidate — hand off to scripts/genome-auto-consolidate.ts which
+ *      reads proposals.jsonl in the current project's genome, merges them
+ *      into target sections, and truncates the queue.
+ *   2. Push (v1.17 T2.5, opt-in) — after consolidation, fire
+ *      scripts/genome-cloud-push.ts so teammates pulling on SessionStart see
+ *      this session's merged state. No-op when the repo has no
+ *      .ashlrcode/genome/.cloud-id.
+ *
+ * Best-effort: a failed consolidation or push must never disturb the user's
+ * session exit. All output goes to stderr. Exits 0 always.
+ */
+
+import { resolve, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+
+if (process.env.ASHLR_GENOME_AUTO === "0") process.exit(0);
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT ?? resolve(scriptDir, "..");
+const consolidateTs    = join(pluginRoot, "scripts", "genome-auto-consolidate.ts");
+const pushTs           = join(pluginRoot, "scripts", "genome-cloud-push.ts");
+const telemetryFlushTs = join(pluginRoot, "scripts", "telemetry-flush.ts");
+const sessionEventEmitTs = join(pluginRoot, "scripts", "session-event-emit.ts");
+const refreshTs        = join(pluginRoot, "scripts", "genome-refresh-worker.ts");
+const hookPerfEmitTs   = join(pluginRoot, "hooks", "_hook-perf-emit.ts");
+const hookHealthNudgeTs = join(pluginRoot, "hooks", "sessionend-hook-health-nudge.ts");
+const statusLineNudgeTs = join(pluginRoot, "hooks", "sessionend-status-line-nudge.ts");
+
+if (!existsSync(consolidateTs)) process.exit(0);
+
+const targetDir = process.env.PROJECT_ROOT ?? process.cwd();
+
+// Consolidation bound to 10s — generous for local fs; prevents a pathological
+// consolidate from stalling session shutdown. Push is opt-in and bounded
+// separately by its own network timeout.
+const CONSOLIDATE_BUDGET_MS = 10_000;
+const POST_HOOK_BUDGET_MS   = 15_000;
+
+const deadline = Date.now() + POST_HOOK_BUDGET_MS;
+
+async function awaitWithBudget(
+  proc: { exited: Promise<number> },
+  budgetMs: number,
+): Promise<"ok" | "timeout"> {
+  let to: ReturnType<typeof setTimeout> | null = null;
+  const timeout = new Promise<"timeout">((resolveP) => {
+    to = setTimeout(() => resolveP("timeout"), budgetMs);
+  });
+  const done = proc.exited.then(() => "ok" as const);
+  const result = await Promise.race([done, timeout]);
+  if (to) clearTimeout(to);
+  return result;
+}
+
+async function main(): Promise<void> {
+  // 1. Consolidate. Await so the push path below sees the merged state.
+  try {
+    const proc = Bun.spawn(["bun", "run", consolidateTs, "--dir", targetDir], {
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    await awaitWithBudget(proc, CONSOLIDATE_BUDGET_MS);
+  } catch {
+    /* best-effort */
+  }
+
+  // 2. Push — only if the push script exists (older plugin versions don't
+  // ship it) and we still have budget. Fire-and-forget; network latency
+  // doesn't block shutdown.
+  if (existsSync(pushTs) && Date.now() < deadline) {
+    try {
+      Bun.spawn(["bun", "run", pushTs, "--quiet", "--cwd", targetDir], {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  // 3. Genome incremental refresh — process pending edits accumulated during
+  // the session. Fire-and-forget with a 10s budget; a slow refresh never
+  // blocks session exit. Uses --quiet so no output pollutes the hook channel.
+  if (existsSync(refreshTs) && Date.now() < deadline) {
+    try {
+      Bun.spawn(["bun", "run", refreshTs, "--quiet"], {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+    } catch {
+      /* best-effort — refresh never blocks shutdown */
+    }
+  }
+
+  // 4. Hook-perf telemetry rollup (opt-in). Reads hook-timings.jsonl, computes
+  // p50/p99 per hook, and writes hook_perf events to the telemetry buffer.
+  // Fire-and-forget; runs before the flush so events are captured in this batch.
+  if (existsSync(hookPerfEmitTs) && Date.now() < deadline) {
+    try {
+      Bun.spawn(["bun", "run", hookPerfEmitTs], {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+    } catch {
+      /* best-effort — hook perf telemetry never blocks shutdown */
+    }
+  }
+
+  // 5. Hook health nudges (errors + regression). Bounded by a 1.5s budget
+  // and runs awaitably so its stdout reaches the SessionEnd channel before
+  // shutdown. Tail-bounded reads keep this well under the 2s hook safety net.
+  if (existsSync(hookHealthNudgeTs) && Date.now() < deadline) {
+    try {
+      const proc = Bun.spawn(["bun", "run", hookHealthNudgeTs], {
+        stdin: "ignore",
+        stdout: "inherit",
+        stderr: "pipe",
+      });
+      await awaitWithBudget(proc, 1_500);
+    } catch {
+      /* best-effort — hook health nudges never block shutdown */
+    }
+  }
+
+  // 6. Status-line discovery nudge — one-shot per user. Bounded by a
+  // 1s budget and runs awaitably so stdout reaches the SessionEnd channel
+  // before shutdown. Tiny JSON reads only; never touches jsonls.
+  if (existsSync(statusLineNudgeTs) && Date.now() < deadline) {
+    try {
+      const proc = Bun.spawn(["bun", "run", statusLineNudgeTs], {
+        stdin: "ignore",
+        stdout: "inherit",
+        stderr: "pipe",
+      });
+      await awaitWithBudget(proc, 1_000);
+    } catch {
+      /* best-effort — status-line discovery nudge never blocks shutdown */
+    }
+  }
+
+  // 7. Telemetry flush (opt-in, no-op when telemetry is off). Fire-and-forget;
+  // network errors are silently dropped by the flush script itself. We spawn
+  // rather than import so a crash in the flush script never affects shutdown.
+  if (existsSync(telemetryFlushTs) && Date.now() < deadline) {
+    try {
+      Bun.spawn(["bun", "run", telemetryFlushTs], {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+    } catch {
+      /* best-effort — telemetry never blocks shutdown */
+    }
+  }
+
+  // 8. Q4 session-event emit. Last step in the chain.
+  // Posts ONE structured event per session (tool counts, savings totals,
+  // discovery refs, branch SHA) to /v1/session-events. Honors the same
+  // opt-in telemetry consent gate as the telemetry buffer flush above.
+  //
+  // Awaited against a 500ms budget so SessionEnd never exceeds the 2s
+  // hook safety net (v1.29) even when the network is slow — the script
+  // also enforces its own AbortSignal.timeout(500) internally.
+  if (existsSync(sessionEventEmitTs) && Date.now() < deadline) {
+    try {
+      const proc = Bun.spawn(["bun", "run", sessionEventEmitTs, "--dir", targetDir], {
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "pipe",
+      });
+      await awaitWithBudget(proc, 500);
+    } catch {
+      /* best-effort — session-event emit never blocks shutdown */
+    }
+  }
+}
+
+main().finally(() => process.exit(0));