claudish 14.11.0 → 14.13.0

package/dist/index.js

@@ -5491,7 +5491,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.11.0";
+var VERSION = "14.13.0";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -5587,22 +5587,134 @@ function redactForClient(text) {
 function redactSecrets(text) {
   if (!text)
     return "";
-  let out = redactSigningValues(text);
-  out = out.replace(ASSIGNMENT_RE, (match, lhs, value) => isPlaceholder(value) ? match : `${lhs}${MASK}`);
-  for (const { re } of TOKEN_PATTERNS) {
-    out = out.replace(re, (match) => {
-      const scheme = /^(Bearer|Basic|Token)\s/.exec(match);
-      return scheme ? `${scheme[1]} ${MASK}` : MASK;
-    });
+  return redactPatterns(redactSigningValues(text));
+}
+function applyParts(match, parts) {
+  if (parts === null)
+    return match;
+  let out = "";
+  for (const p of parts)
+    out += typeof p === "string" ? p : match.slice(p[0], p[1]);
+  return out;
+}
+function redactPatterns(text) {
+  if (!text)
+    return text;
+  let out = text;
+  for (const rule of PATTERN_RULES) {
+    out = out.replace(rule.re, (match, ...rest) => applyParts(match, rule.parts(match, rest.slice(0, -2))));
   }
   return out;
 }
+
+class SegmentBuilder {
+  segments = [];
+  push(length, origin) {
+    if (length <= 0)
+      return;
+    const last = this.segments[this.segments.length - 1];
+    const bothInserted = last !== undefined && last.origin < 0 && origin < 0;
+    const contiguousOriginal = last !== undefined && last.origin >= 0 && origin >= 0 && last.origin + last.length === origin;
+    if (last && (bothInserted || contiguousOriginal))
+      last.length += length;
+    else
+      this.segments.push({ length, origin });
+  }
+}
+
+class SegmentCursor {
+  segs;
+  idx = 0;
+  segStart = 0;
+  constructor(segs) {
+    this.segs = segs;
+  }
+  copy(from, to, into) {
+    let pos = from;
+    while (pos < to) {
+      let seg = this.segs[this.idx];
+      while (this.segStart + seg.length <= pos) {
+        this.segStart += seg.length;
+        seg = this.segs[++this.idx];
+      }
+      const take = Math.min(to, this.segStart + seg.length) - pos;
+      into.push(take, seg.origin < 0 ? -1 : seg.origin + (pos - this.segStart));
+      pos += take;
+    }
+  }
+}
+function redactPatternsMapped(text) {
+  let cur = text;
+  let segs = text ? [{ length: text.length, origin: 0 }] : [];
+  for (const rule of PATTERN_RULES) {
+    if (!cur)
+      break;
+    const out = new SegmentBuilder;
+    const src = new SegmentCursor(segs);
+    let built = "";
+    let last = 0;
+    let hit = false;
+    for (const m of cur.matchAll(rule.re)) {
+      const parts = rule.parts(m[0], m.slice(1));
+      if (parts === null)
+        continue;
+      hit = true;
+      const at = m.index;
+      built += cur.slice(last, at);
+      src.copy(last, at, out);
+      for (const p of parts) {
+        if (typeof p === "string") {
+          built += p;
+          out.push(p.length, -1);
+        } else {
+          built += cur.slice(at + p[0], at + p[1]);
+          src.copy(at + p[0], at + p[1], out);
+        }
+      }
+      last = at + m[0].length;
+    }
+    if (!hit)
+      continue;
+    built += cur.slice(last);
+    src.copy(last, cur.length, out);
+    cur = built;
+    segs = out.segments;
+  }
+  return { text: cur, segments: segs };
+}
+function signingValueRanges(text) {
+  if (liveSigningValues.size === 0 || !text)
+    return [];
+  if (!sortedSigningValues) {
+    sortedSigningValues = [...liveSigningValues.keys()].sort((a, b) => b.length - a.length);
+  }
+  const found = [];
+  for (const value of sortedSigningValues) {
+    let at = text.indexOf(value);
+    while (at !== -1) {
+      found.push([at, at + value.length]);
+      at = text.indexOf(value, at + 1);
+    }
+  }
+  if (found.length === 0)
+    return [];
+  found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  const merged = [];
+  for (const [s, e] of found) {
+    const last = merged[merged.length - 1];
+    if (last && s <= last[1])
+      last[1] = Math.max(last[1], e);
+    else
+      merged.push([s, e]);
+  }
+  return merged;
+}
 function sanitizeForReport(text) {
   if (!text)
     return "";
   return redactSecrets(text).replace(/\/Users\/[^/\s]+/g, "/Users/***").replace(/\/home\/[^/\s]+/g, "/home/***").replace(/[A-Z]:\\Users\\[^\\\s]+/gi, "C:\\Users\\***").replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "***@***.***");
 }
-var MASK = "***REDACTED***", PLACEHOLDER, ASSIGNMENT_RE, TOKEN_PATTERNS, SIGNING_MASK = "[redacted]", SIGNING_VALUE_MIN_LENGTH = 8, liveSigningValues, sortedSigningValues = null;
+var MASK = "***REDACTED***", PLACEHOLDER, ASSIGNMENT_RE, TOKEN_PATTERNS, SIGNING_MASK = "[redacted]", SIGNING_VALUE_MIN_LENGTH = 8, liveSigningValues, sortedSigningValues = null, PATTERN_RULES;
 var init_redact = __esm(() => {
   PLACEHOLDER = /^(['"`]?)(your[-_a-z0-9]*|<[^>]*>|\.\.\.|x{3,}|\*{3,}|REDACTED|CHANGEME|TODO|\$\{[^}]*\}|)(['"`]?)$/i;
   ASSIGNMENT_RE = /(["']?\b[A-Z][A-Z0-9_]*(?:_API_KEY|_KEY|_TOKEN|_SECRET|_PASSWORD)\b["']?\s*[:=]\s*)(["'`]?\$\{[^}]*\}["'`]?|["'`]?[^\s"'`,}]+["'`]?)/g;
@@ -5617,6 +5729,19 @@ var init_redact = __esm(() => {
     { name: "bearer", re: /\b(?:Bearer|Basic|Token)\s+[A-Za-z0-9_.\-+/=]{12,}/g }
   ];
   liveSigningValues = new Map;
+  PATTERN_RULES = [
+    {
+      re: ASSIGNMENT_RE,
+      parts: (_m, [lhs = "", value = ""]) => isPlaceholder(value) ? null : [[0, lhs.length], MASK]
+    },
+    ...TOKEN_PATTERNS.map(({ re }) => ({
+      re,
+      parts: (m) => {
+        const scheme = /^(Bearer|Basic|Token)\s/.exec(m);
+        return scheme ? [[0, scheme[1].length], ` ${MASK}`] : [MASK];
+      }
+    }))
+  ];
 });
 
 // src/logger.ts
@@ -73038,7 +73163,7 @@ function isTerminalState(s) {
 function contractMeta() {
   return { contract_version: CONTRACT_VERSION, capabilities: [...CAPABILITIES] };
 }
-var CONTRACT_VERSION = 1, CAPABILITIES, SLOT_STATES, TERMINAL_STATES, FAILURE_REASONS, ContractErrorException;
+var CONTRACT_VERSION = 1, CAPABILITIES, SLOT_STATES, TERMINAL_STATES, FAILURE_REASONS, MAX_TRANSCRIPT_LINES = 200, TRANSCRIPT_LINE_MAX_CHARS = 8000, TRANSCRIPT_LINE_MAX_JSON_BYTES = 16000, TRANSCRIPT_ANSWER_MAX_BYTES = 32000, ContractErrorException;
 var init_contract = __esm(() => {
   CAPABILITIES = [
     "list",
@@ -73048,7 +73173,9 @@ var init_contract = __esm(() => {
     "capture_since_seq",
     "capture_spans",
     "resize",
-    "allowance"
+    "allowance",
+    "scroll",
+    "transcript"
   ];
   SLOT_STATES = [
     "STARTING",
@@ -93473,6 +93600,39 @@ var init_screen_classifier = __esm(() => {
   NON_ANSWER_ROW = /^\s+\u23BF|^\s{2}(Ran|Read|Searched|Wrote|Edited|Listed|Updated) \d+ |^\s*[\u00B7\u2722\u2733\u2736\u273B\u273D*\u25CF\u2217]\s|^\s*\(ctrl\+/;
 });
 
+// src/pane/scroll-input.ts
+function isLiveBottom(pos) {
+  return pos.atBottom && pos.lastDirection === null;
+}
+function scrollRowsOf(by) {
+  if (!Number.isFinite(by))
+    return 0;
+  return Math.min(Math.abs(Math.trunc(by)), MAX_SCROLL_ROWS);
+}
+function planScroll(pos, req) {
+  if ("to" in req)
+    return { bytes: CTRL_END, events: 1, next: LIVE_BOTTOM };
+  const n = scrollRowsOf(req.by);
+  if (n === 0)
+    return { bytes: "", events: 0, next: pos };
+  const dir = req.by < 0 ? "up" : "down";
+  const extra = pos.atBottom || pos.lastDirection !== dir ? 1 : 0;
+  const events = n + extra;
+  return {
+    bytes: (dir === "up" ? WHEEL_UP : WHEEL_DOWN).repeat(events),
+    events,
+    next: { atBottom: false, lastDirection: dir }
+  };
+}
+var MAX_SCROLL_ROWS = 200, WHEEL_UP = "\x1B[<64;1;1M", WHEEL_DOWN = "\x1B[<65;1;1M", CTRL_END = "\x1B[1;5F", LIVE_BOTTOM, UNKNOWN_POSITION;
+var init_scroll_input = __esm(() => {
+  LIVE_BOTTOM = Object.freeze({ atBottom: true, lastDirection: null });
+  UNKNOWN_POSITION = Object.freeze({
+    atBottom: false,
+    lastDirection: null
+  });
+});
+
 // src/pane/session-registry.ts
 import { readFileSync as readFileSync40, readdirSync as readdirSync6 } from "fs";
 import { join as join48 } from "path";
@@ -94411,7 +94571,7 @@ class TranscriptFollower {
     let any = false;
     for (const { offset, line } of this.main.read()) {
       any = true;
-      const rec = parse8(line);
+      const rec = parseRecord3(line);
       if (rec)
         applyRecord(this.state, rec, offset + 1);
     }
@@ -94440,7 +94600,7 @@ class TranscriptFollower {
       }
       for (const { line } of tail.read()) {
         any = true;
-        const rec = parse8(line);
+        const rec = parseRecord3(line);
         if (rec)
           applySubagentRecord(this.state, rec, this.main.offset + 1);
       }
@@ -94502,7 +94662,7 @@ function lastHumanPromptOffset(path) {
   const tail = new Tail(path);
   let found = null;
   for (const { offset, line } of tail.read()) {
-    const rec = parse8(line);
+    const rec = parseRecord3(line);
     if (rec && isHumanPrompt(rec))
       found = offset;
   }
@@ -94515,7 +94675,7 @@ function fileSize(p) {
     return 0;
   }
 }
-function parse8(line) {
+function parseRecord3(line) {
   if (!line.trim())
     return null;
   try {
@@ -94617,6 +94777,9 @@ class PaneSessionImpl {
   resizeQuietFrom = 0;
   resizeQuietUntil = 0;
   activityChangedAt = 0;
+  scrollPos = LIVE_BOTTOM;
+  scrollEndsInFlight = 0;
+  scrollEndConfirmedAt = 0;
   gate = null;
   gateTrusted = false;
   gateInFlight = false;
@@ -94649,6 +94812,7 @@ class PaneSessionImpl {
   reaping = false;
   fastReap = false;
   reapPromise = null;
+  verifiedReap = Promise.withResolvers();
   reconnecting = false;
   depth = 0;
   stepFrom = null;
@@ -95407,8 +95571,8 @@ ${gate}`
           await this.pause(adm, TICK_MS);
           continue;
         }
-        if (!this.client || !this.gateTrusted) {
-          await this.awaitTrustedClient(adm);
+        if (!this.trustedConnection() || this.needsAdmissionLiveBottom(adm)) {
+          await this.connectionStep(adm);
           continue;
         }
         if (await this.beforeSend(adm) !== "send")
@@ -95420,8 +95584,22 @@ ${gate}`
       adm.inFlight = false;
     }
   }
+  needsAdmissionLiveBottom(adm) {
+    if (adm.liveBottomClient === this.client)
+      return false;
+    adm.liveBottomClient = this.client;
+    return !isLiveBottom(this.scrollPos);
+  }
+  trustedConnection() {
+    return !!this.client && !this.client.isClosed && this.gateTrusted;
+  }
+  connectionStep(adm) {
+    if (!this.trustedConnection())
+      return this.awaitTrustedClient(adm);
+    return this.returnToLiveBottom(Math.max(0, adm.deadline - Date.now()));
+  }
   awaitTrustedClient(adm) {
-    return this.waitFor(() => !this.admitting(adm) || !!this.client && this.gateTrusted, Math.max(0, adm.deadline - Date.now()));
+    return this.waitFor(() => !this.admitting(adm) || this.trustedConnection(), Math.max(0, adm.deadline - Date.now()));
   }
   async attemptOnce(adm) {
     const c = this.client;
@@ -95846,6 +96024,7 @@ ${screenTailOf(this.screen)}` });
   accept() {
     this.admission = null;
     this.initialDelivery = false;
+    this.scrollPos = LIVE_BOTTOM;
     const now = Date.now();
     this.lastChatSeenAt = now;
     this.turnAcceptedAt = now;
@@ -95922,6 +96101,7 @@ ${screenTailOf(this.screen)}`
       const d = this.currentDelivery;
       this.turnSource = "screen";
       this.anomaly("degraded_mode");
+      this.returnToLiveBottom(SCROLL_REPLY_MS);
       this.screenTurn = {
         echo: d && d.mode !== "refused" ? d.line : "",
         acceptedAt: at,
@@ -96399,11 +96579,21 @@ ${screenTailOf(this.screen)}`
     const g = this.gateNow();
     if (!g || !g.ready || g.dialog !== null || workingAboveBox(this.screen) === true)
       return false;
-    const quiet = this.aboveBoxQuietMs() ?? Date.now() - this.screen.changedAt;
+    let quiet = this.aboveBoxQuietMs() ?? Date.now() - this.screen.changedAt;
+    if (this.scrollEndConfirmedAt > 0)
+      quiet = Math.min(quiet, Date.now() - this.scrollEndConfirmedAt);
     if (view.availability === "off" && quiet >= this.secondaryQuietMs)
       return true;
     return (!!answer || !!apiError) && quiet >= 2 * this.t("screenSettleQuietMs", SCREEN_SETTLE_QUIET_MS);
   }
+  screenViewLive() {
+    if (this.scrollEndsInFlight > 0)
+      return false;
+    if (isLiveBottom(this.scrollPos))
+      return true;
+    this.returnToLiveBottom(SCROLL_REPLY_MS);
+    return false;
+  }
   evalScreenTurn(view) {
     if (this.witnessed(view.current)) {
       this.turnSource = "transcript";
@@ -96418,7 +96608,7 @@ ${screenTailOf(this.screen)}`
     const answer = screenAnswer(this.screen, st.echo);
     const apiError = this.screenApiError(st, answer);
     this.activity = "thinking";
-    if (!this.screenSettleReady(view, answer, apiError))
+    if (!this.screenViewLive() || !this.screenSettleReady(view, answer, apiError))
       return;
     this.follower.poll();
     if (this.witnessed(this.follower.view().current))
@@ -96749,6 +96939,69 @@ ${screenTailOf(this.screen)}`
       answer({ ...set, changed: true, seq: this.screen.seq });
     }
   }
+  async scroll(req) {
+    const refusal = this.scrollRefusal();
+    if (refusal)
+      throw new ContractErrorException("scroll_unavailable", refusal);
+    const c = this.client;
+    if (!c || c.isClosed)
+      throw new ContractErrorException("scroll_unavailable", "the pane's socket is reconnecting");
+    const plan = planScroll(this.scrollPos, req);
+    if (plan.bytes === "")
+      return { seq: this.screen.seq };
+    this.scrollPos = plan.next;
+    const seq0 = this.screen.seq;
+    this.extendResizeQuiet();
+    const r = await c.request({ type: "send", pane: 0, text: plan.bytes, enter: false, noGate: true }, SCROLL_REPLY_MS);
+    if (!r.ok) {
+      this.scrollPos = UNKNOWN_POSITION;
+      if (r.code === "client_lost" || r.code === "client_timeout")
+        this.extendResizeQuiet();
+      throw new ContractErrorException("scroll_unavailable", `magmux did not confirm the scroll: ${r.code}${r.error ? `: ${r.error}` : ""}`);
+    }
+    this.extendResizeQuiet();
+    await this.waitFor(() => isTerminalPhase(this.phase) || this.screen.seq !== seq0, this.t("scrollScreenMs", SCROLL_SCREEN_MS));
+    return { seq: this.screen.seq };
+  }
+  screenTurnActive() {
+    if (this.turnSource !== "screen")
+      return false;
+    return this.phase === "RUNNING" || this.phase === "QUESTION" || this.phase === "PERMISSION";
+  }
+  scrollRefusal() {
+    if (isTerminalPhase(this.phase) || this.final)
+      return "the session has finished";
+    if (this.phase === "BOOTING" || this.screen.seq === 0)
+      return "the session is still starting";
+    if (this.phase === "ADMITTING")
+      return "a prompt is being delivered to the session";
+    if (this.screenTurnActive())
+      return "the session's turn is being read from its screen (no transcript)";
+    if (!this.client || this.client.isClosed || !this.gateTrusted)
+      return "the pane's socket is reconnecting";
+    return null;
+  }
+  async returnToLiveBottom(ms) {
+    if (isLiveBottom(this.scrollPos))
+      return;
+    const c = this.client;
+    if (!c || c.isClosed || !this.gateTrusted || ms <= 0)
+      return;
+    this.scrollPos = LIVE_BOTTOM;
+    this.extendResizeQuiet();
+    this.scrollEndsInFlight++;
+    try {
+      const r = await c.request({ type: "send", pane: 0, text: CTRL_END, enter: false, noGate: true }, Math.min(SCROLL_REPLY_MS, ms));
+      if (r.ok) {
+        this.scrollEndConfirmedAt = Date.now();
+      } else {
+        this.scrollPos = UNKNOWN_POSITION;
+        this.anomaly(`scroll_end_unconfirmed:${r.code}`);
+      }
+    } finally {
+      this.scrollEndsInFlight--;
+    }
+  }
   turnAnswer(index) {
     const done = this.answers.get(index);
     if (done !== undefined)
@@ -96806,6 +97059,9 @@ ${screenTailOf(this.screen)}`
   reaped() {
     return this.reapPromise ?? this.terminal.then(() => this.reapPromise ?? Promise.resolve());
   }
+  reapVerified() {
+    return this.verifiedReap.promise;
+  }
   panePid() {
     return this.panePidValue;
   }
@@ -96932,6 +97188,7 @@ ${screenTailOf(this.screen)}`
     if (groupGone && magGone) {
       removePaneFiles(this.root, this.files());
       this.reapFailed = false;
+      this.verifiedReap.resolve();
       await this.endWatcher();
       unregisterPane(this.paneId);
       return;
@@ -97001,7 +97258,8 @@ function newAdmission(a) {
     clearAfter: 0,
     lostType: null,
     last: null,
-    noted: new Set
+    noted: new Set,
+    liveBottomClient: null
   };
 }
 function markClearFirst(adm) {
@@ -97168,7 +97426,7 @@ async function startPaneSession(o) {
   await session.start({ magmuxBinary: magmux.binary, env: p.magmuxEnv, cwd: p.cwd });
   return session;
 }
-var BOOT_TIMEOUT_MS = 90000, ADMIT_TIMEOUT_MS = 30000, DEGRADED_ENTRY_MS = 1e4, SCREEN_SETTLE_QUIET_MS = 3000, PANEL_SETTLE_MS = 500, SEND_CLIENT_SLACK_MS = 2000, MIN_READY_TIMEOUT_MS = 1000, BUSY_RETRY_MS = 250, MISMATCH_SETTLE_MS = 1000, CLEAR_WAIT_MS = 1000, BOOT_STATIC_MS = 5000, TICK_MS = 250, WATCH_FPS = 4, POLL_BACKSTOP_MS = 1000, TURN_END_MISSING_FACTOR = 3, RESIZE_REPLY_MS = 1e4, RESIZE_SCREEN_MS = 1000, GATE_POLL_MS = 250, GATE_REPLY_MS = 1000, GATE_STALE_MS2 = 1000, GATE_GRACE_MS, GATE_DEAD_BACKSTOP_MS = 1000, EXIT_CODE_QUERY_MS = 2000, EXIT_CODE_RETRY_MS = 50, GATE_KINDLESS_REASONS, RUNTIME_DIALOG_KINDS, REGISTRY_READ_MS = 250, REGISTRY_DISAGREE_MS = 2000, REGISTRY_GATE_BOOT_DISAGREE_MS = 5000, REGISTRY_MISSING_MS = 5000, MAX_ANOMALY_KEYS = 64, KEPT_ANSWERS = 4, DEFAULT_MAX_CONSECUTIVE = 3, EVENT_REASON, VERDICT_EVENT, PaneStartError;
+var BOOT_TIMEOUT_MS = 90000, ADMIT_TIMEOUT_MS = 30000, DEGRADED_ENTRY_MS = 1e4, SCREEN_SETTLE_QUIET_MS = 3000, PANEL_SETTLE_MS = 500, SEND_CLIENT_SLACK_MS = 2000, MIN_READY_TIMEOUT_MS = 1000, BUSY_RETRY_MS = 250, MISMATCH_SETTLE_MS = 1000, CLEAR_WAIT_MS = 1000, BOOT_STATIC_MS = 5000, TICK_MS = 250, WATCH_FPS = 4, POLL_BACKSTOP_MS = 1000, TURN_END_MISSING_FACTOR = 3, RESIZE_REPLY_MS = 1e4, RESIZE_SCREEN_MS = 1000, SCROLL_REPLY_MS = 5000, SCROLL_SCREEN_MS = 1000, GATE_POLL_MS = 250, GATE_REPLY_MS = 1000, GATE_STALE_MS2 = 1000, GATE_GRACE_MS, GATE_DEAD_BACKSTOP_MS = 1000, EXIT_CODE_QUERY_MS = 2000, EXIT_CODE_RETRY_MS = 50, GATE_KINDLESS_REASONS, RUNTIME_DIALOG_KINDS, REGISTRY_READ_MS = 250, REGISTRY_DISAGREE_MS = 2000, REGISTRY_GATE_BOOT_DISAGREE_MS = 5000, REGISTRY_MISSING_MS = 5000, MAX_ANOMALY_KEYS = 64, KEPT_ANSWERS = 4, DEFAULT_MAX_CONSECUTIVE = 3, EVENT_REASON, VERDICT_EVENT, PaneStartError;
 var init_pane_session = __esm(() => {
   init_queue();
   init_parent_session();
@@ -97185,6 +97443,7 @@ var init_pane_session = __esm(() => {
   init_prompt_delivery();
   init_screen_classifier();
   init_screen_model();
+  init_scroll_input();
   init_session_registry();
   init_settle_rule();
   init_slot_state();
@@ -97223,6 +97482,759 @@ var init_pane_session = __esm(() => {
   };
 });
 
+// src/pane/transcript-lines.ts
+function sanitiseText(s) {
+  if (!s)
+    return "";
+  return s.replace(OSC_RE, "").replace(STRING_SEQ_RE, "").replace(CSI_RE, "").replace(CSI8_RE, "").replace(ESC2_RE, "").replace(/\r\n/g, `
+`).replace(CONTROL_RE, "").replace(LONE_SURROGATE_RE, "\uFFFD").trimEnd();
+}
+function jsonUnitBytes(s, i) {
+  const c = s.charCodeAt(i);
+  if (c === 34 || c === 92)
+    return 2;
+  if (c < 32)
+    return c === 8 || c === 9 || c === 10 || c === 12 || c === 13 ? 2 : 6;
+  if (c < 128)
+    return 1;
+  if (c < 2048)
+    return 2;
+  if (c >= 55296 && c <= 56319) {
+    const n = s.charCodeAt(i + 1);
+    return n >= 56320 && n <= 57343 ? 2 : 6;
+  }
+  if (c >= 56320 && c <= 57343) {
+    const p = s.charCodeAt(i - 1);
+    return i > 0 && p >= 55296 && p <= 56319 ? 2 : 6;
+  }
+  return 3;
+}
+function isHigh(c) {
+  return c >= 55296 && c <= 56319;
+}
+function isLow(c) {
+  return c >= 56320 && c <= 57343;
+}
+function nextCut(s, pos, maxChars, maxJsonBytes) {
+  const contentBytes = Math.max(1, maxJsonBytes - 2);
+  let end = pos;
+  let bytes = 0;
+  const limit = Math.min(s.length, pos + Math.max(1, maxChars));
+  while (end < limit) {
+    const b = jsonUnitBytes(s, end);
+    if (bytes + b > contentBytes)
+      break;
+    bytes += b;
+    end++;
+  }
+  if (end === s.length)
+    return end;
+  if (end > pos && isHigh(s.charCodeAt(end - 1)) && isLow(s.charCodeAt(end)))
+    end--;
+  if (end <= pos)
+    return Math.min(s.length, pos + (isHigh(s.charCodeAt(pos)) ? 2 : 1));
+  let space = -1;
+  for (let i = end - 1;i >= pos; i--) {
+    const c = s.charCodeAt(i);
+    if (c === 10)
+      return i + 1;
+    if (space === -1 && (c === 32 || c === 9))
+      space = i;
+  }
+  return space !== -1 ? space + 1 : end;
+}
+function str4(v) {
+  return typeof v === "string" && v.trim() !== "" ? v : undefined;
+}
+function firstStringInput(input) {
+  for (const v of Object.values(input)) {
+    const s = str4(v);
+    if (s !== undefined)
+      return s;
+  }
+  return;
+}
+function collapseWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function ellipsisCut(s, max) {
+  if (s.length <= max)
+    return s.length;
+  let end = max - 1;
+  if (end > 0 && isHigh(s.charCodeAt(end - 1)))
+    end--;
+  return end;
+}
+function toolCall(name, input) {
+  const n = collapseWhitespace(sanitiseText(typeof name === "string" ? name : "")) || "tool";
+  const rec = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const raw = TOOL_ARG[n]?.(rec) ?? firstStringInput(rec);
+  const arg = raw === undefined ? "" : sanitiseText(raw);
+  return arg ? { kind: "tool", text: n, arg } : { kind: "tool", text: n };
+}
+function line(kind, raw) {
+  const text = sanitiseText(raw);
+  return text ? [{ kind, text }] : [];
+}
+function userContentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const b of content) {
+    if (b?.type === "text" && typeof b.text === "string")
+      parts.push(b.text);
+    else if (b?.type === "image")
+      parts.push("[image]");
+    else if (b?.type === "document")
+      parts.push("[document]");
+  }
+  return parts.join(`
+`);
+}
+function isTaskNotificationText(text, origin) {
+  return origin?.kind === "task-notification" || text.includes("<task-notification>");
+}
+function promptTextLines(text, origin, fallback) {
+  if (text.startsWith(INTERRUPT_PREFIX))
+    return line("system", text);
+  if (isTaskNotificationText(text, origin)) {
+    const m = SUMMARY_RE.exec(text);
+    return line("system", m ? m[1] ?? "" : text);
+  }
+  if (isLocalCommandText(text) || COMMAND_TAG_RE.test(text)) {
+    if (CAVEAT_RE.test(text))
+      return [];
+    const name = COMMAND_NAME_RE.exec(text);
+    if (name) {
+      let cmd = (name[1] ?? "").trim();
+      if (cmd && !cmd.startsWith("/"))
+        cmd = `/${cmd}`;
+      const args = (COMMAND_ARGS_RE.exec(text)?.[1] ?? "").trim();
+      return line("user", args ? `${cmd} ${args}` : cmd);
+    }
+    const out = STDOUT_RE.exec(text);
+    return out ? line("system", out[2] ?? "") : [];
+  }
+  return fallback ? line(fallback, text) : [];
+}
+function assistantLines(r) {
+  const content = r.message?.content;
+  const blocks = typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? content : [];
+  if (r.isApiErrorMessage === true) {
+    const text = blocks.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join(`
+`);
+    return line("error", text);
+  }
+  const out = [];
+  for (const b of blocks) {
+    if (b?.type === "text" && typeof b.text === "string") {
+      if (!b.text.trim())
+        continue;
+      out.push(...line(parseInBandApiError(b.text) ? "error" : "assistant", b.text));
+    } else if (b?.type === "tool_use" || b?.type === "server_tool_use") {
+      out.push(toolCall(b.name, b.input));
+    }
+  }
+  return out;
+}
+function userLines(r) {
+  if (r.isCompactSummary === true || r.isMeta === true)
+    return [];
+  const content = r.message?.content;
+  if (Array.isArray(content) && content.some((b) => b?.type === "tool_result")) {
+    const file = r.toolUseResult?.file;
+    const isTaskFile = typeof file?.filePath === "string" && TASK_FILE_RE.test(file.filePath) && typeof file.content === "string";
+    const out = [];
+    let taskFileShown = false;
+    for (const b of content) {
+      if (b?.type === "tool_result") {
+        if (isTaskFile && !taskFileShown) {
+          taskFileShown = true;
+          out.push(...line("task_file", file.content));
+        }
+      } else if (b?.type === "text" && typeof b.text === "string" && b.text.startsWith(INTERRUPT_PREFIX)) {
+        out.push(...line("system", b.text));
+      }
+    }
+    return out;
+  }
+  return promptTextLines(userContentText(content), r.origin, "user");
+}
+function systemLines(r) {
+  const subtype = typeof r.subtype === "string" ? r.subtype : "";
+  const content = typeof r.content === "string" ? r.content : undefined;
+  switch (subtype) {
+    case "compact_boundary":
+      return line("system", content ?? "Conversation compacted");
+    case "local_command":
+      return content === undefined ? [] : promptTextLines(content, null, null);
+    case "scheduled_task_fire":
+    case "agents_killed":
+    case "model_refusal_fallback":
+      return line("system", content ?? SYSTEM_WORDS[subtype] ?? subtype);
+    case "api_error": {
+      const e = r.error;
+      const text = str4(e?.formatted) ?? str4(e?.message) ?? content ?? "API error";
+      return line("error", text);
+    }
+    case "model_refusal_no_fallback":
+      return line("error", content ?? "model refused, no fallback");
+  }
+  if (r.level === "error")
+    return line("error", content ?? subtype.replace(/_/g, " "));
+  return [];
+}
+function renderEntry(rec) {
+  if (!rec || typeof rec !== "object" || Array.isArray(rec))
+    return [];
+  const r = rec;
+  if (r.isSidechain === true)
+    return [];
+  switch (r.type) {
+    case "assistant":
+      return assistantLines(r);
+    case "user":
+      return userLines(r);
+    case "attachment": {
+      const a = r.attachment;
+      if (a?.type !== "queued_command" || typeof a.prompt !== "string")
+        return [];
+      return promptTextLines(a.prompt, a.origin ?? r.origin, "user");
+    }
+    case "system":
+      return systemLines(r);
+    case "continued-in": {
+      const id = typeof r.continuedInSessionId === "string" ? r.continuedInSessionId : "";
+      return line("system", `conversation continued in session ${id}`.trimEnd());
+    }
+    default:
+      return [];
+  }
+}
+var TOOL_ARG_MAX_CHARS = 160, OSC_RE, STRING_SEQ_RE, CSI_RE, CSI8_RE, ESC2_RE, CONTROL_RE, LONE_SURROGATE_RE, TOOL_ARG, TASK_FILE_RE, COMMAND_NAME_RE, COMMAND_ARGS_RE, CAVEAT_RE, COMMAND_TAG_RE, SUMMARY_RE, SYSTEM_WORDS;
+var init_transcript_lines = __esm(() => {
+  init_transcript_follower();
+  OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+  STRING_SEQ_RE = /\x1b[PX^_][\s\S]*?\x1b\\/g;
+  CSI_RE = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+  CSI8_RE = /\x9b[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+  ESC2_RE = /\x1b[\x20-\x7e]/g;
+  CONTROL_RE = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+  LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+  TOOL_ARG = {
+    Bash: (i) => str4(i.command),
+    Monitor: (i) => str4(i.description) ?? str4(i.command),
+    Read: (i) => str4(i.file_path),
+    Write: (i) => str4(i.file_path),
+    Edit: (i) => str4(i.file_path),
+    MultiEdit: (i) => str4(i.file_path),
+    NotebookEdit: (i) => str4(i.notebook_path),
+    Glob: (i) => str4(i.pattern),
+    Grep: (i) => str4(i.pattern),
+    Agent: (i) => str4(i.description) ?? str4(i.subagent_type),
+    Task: (i) => str4(i.description) ?? str4(i.subagent_type),
+    Skill: (i) => str4(i.skill),
+    WebFetch: (i) => str4(i.url),
+    WebSearch: (i) => str4(i.query),
+    ToolSearch: (i) => str4(i.query),
+    SendMessage: (i) => str4(i.to) ?? str4(i.recipient),
+    AskUserQuestion: (i) => Array.isArray(i.questions) ? str4(i.questions[0]?.question) : undefined,
+    TaskStop: (i) => str4(i.task_id),
+    TaskCreate: (i) => str4(i.subject),
+    TaskUpdate: (i) => str4(i.taskId),
+    CronCreate: (i) => str4(i.cron),
+    ScheduleWakeup: (i) => str4(i.reason)
+  };
+  TASK_FILE_RE = /\/launch-[A-Za-z0-9]{6}\/turn-\d+\.md$/;
+  COMMAND_NAME_RE = /<command-name>([\s\S]*?)<\/command-name>/;
+  COMMAND_ARGS_RE = /<command-args>([\s\S]*?)<\/command-args>/;
+  CAVEAT_RE = /^\s*<local-command-caveat>/;
+  COMMAND_TAG_RE = /^\s*<command-(?:message|args)>[\s\S]*<command-name>/;
+  SUMMARY_RE = /<summary>([\s\S]*?)<\/summary>/;
+  SYSTEM_WORDS = {
+    scheduled_task_fire: "scheduled task fired",
+    agents_killed: "agents killed",
+    model_refusal_fallback: "model refusal: fell back"
+  };
+});
+
+// src/pane/transcript-redaction.ts
+function isHigh2(c) {
+  return c >= 55296 && c <= 56319;
+}
+function isLow2(c) {
+  return c >= 56320 && c <= 57343;
+}
+function firstRangeEndingAfter(ranges, pos) {
+  let lo = 0;
+  let hi = ranges.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (ranges[mid][1] <= pos)
+      lo = mid + 1;
+    else
+      hi = mid;
+  }
+  return lo;
+}
+function redactCarrying(t0, find = signingValueRanges) {
+  const ranges = find(t0);
+  const { text: plain, segments } = redactPatternsMapped(t0);
+  if (ranges.length === 0)
+    return { plain, masked: [] };
+  const masked = [];
+  const add = (from, to) => {
+    const splitsStart = from > 0 && isLow2(plain.charCodeAt(from)) && isHigh2(plain.charCodeAt(from - 1));
+    const splitsEnd = to < plain.length && isLow2(plain.charCodeAt(to)) && isHigh2(plain.charCodeAt(to - 1));
+    const s = splitsStart ? from - 1 : from;
+    const e = splitsEnd ? to + 1 : to;
+    const last = masked[masked.length - 1];
+    if (last && s <= last[1])
+      last[1] = Math.max(last[1], e);
+    else
+      masked.push([s, e]);
+  };
+  let p = 0;
+  for (const seg of segments) {
+    if (seg.origin >= 0) {
+      const o = seg.origin;
+      const oEnd = o + seg.length;
+      for (let i = firstRangeEndingAfter(ranges, o);i < ranges.length; i++) {
+        const [s, e] = ranges[i];
+        if (s >= oEnd)
+          break;
+        add(p + Math.max(s, o) - o, p + Math.min(e, oEnd) - o);
+      }
+    }
+    p += seg.length;
+  }
+  return { plain, masked };
+}
+function maskedSlice(r, a, b) {
+  let out = "";
+  if (r.masked.length > 0) {
+    let at = a;
+    for (let i = firstRangeEndingAfter(r.masked, a);i < r.masked.length; i++) {
+      const [s, e] = r.masked[i];
+      if (s >= b)
+        break;
+      const from = Math.max(s, a);
+      const to = Math.min(e, b);
+      out += r.plain.slice(at, from) + r.plain.slice(from, to).replace(/\S/g, SIGNING_UNIT_MASK);
+      at = to;
+    }
+    out += r.plain.slice(at, b);
+  } else
+    out = r.plain.slice(a, b);
+  return out.replace(LONE_SURROGATE_RE2, "\uFFFD");
+}
+function toolText(r, find) {
+  const name = redactCarrying(r.text, find);
+  const nameMasked = maskedSlice(name, 0, name.plain.length);
+  if (!r.arg)
+    return { plain: `${name.plain}()`, masked: `${nameMasked}()` };
+  const arg = redactCarrying(r.arg, find);
+  const plain = collapseWhitespace(arg.plain);
+  const masked = collapseWhitespace(maskedSlice(arg, 0, arg.plain.length));
+  const end = ellipsisCut(plain, TOOL_ARG_MAX_CHARS);
+  const cut = end < plain.length;
+  const tail = cut ? "\u2026" : "";
+  return {
+    plain: `${name.plain}(${plain.slice(0, end)}${tail})`,
+    masked: `${nameMasked}(${masked.slice(0, end)}${tail})`
+  };
+}
+function* finishLine(r, find) {
+  let plain;
+  let slice;
+  if (r.kind === "tool") {
+    const t = toolText(r, find);
+    plain = t.plain;
+    slice = (a, b) => t.masked.slice(a, b);
+  } else {
+    const red = redactCarrying(r.text, find);
+    plain = red.plain;
+    slice = (a, b) => maskedSlice(red, a, b);
+  }
+  let first = true;
+  for (let pos = 0;pos < plain.length; ) {
+    const a = pos;
+    const b = nextCut(plain, pos, TRANSCRIPT_LINE_MAX_CHARS, TRANSCRIPT_LINE_MAX_JSON_BYTES);
+    pos = b;
+    const cont = !first;
+    first = false;
+    yield {
+      kind: r.kind,
+      cont,
+      build: () => cont ? { kind: r.kind, text: slice(a, b), cont: true } : { kind: r.kind, text: slice(a, b) }
+    };
+  }
+}
+function* entryLines(raw, find = signingValueRanges) {
+  const rec = parseRecord3(raw);
+  if (!rec || Array.isArray(rec))
+    return;
+  for (const r of renderEntry(rec))
+    yield* finishLine(r, find);
+}
+var SIGNING_UNIT_MASK = "*", LONE_SURROGATE_RE2;
+var init_transcript_redaction = __esm(() => {
+  init_redact();
+  init_contract();
+  init_transcript_follower();
+  init_transcript_lines();
+  LONE_SURROGATE_RE2 = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+});
+
+// src/pane/transcript-page.ts
+import {
+  constants as constants4,
+  closeSync as closeSync12,
+  fstatSync as fstatSync5,
+  lstatSync as lstatSync6,
+  openSync as openSync12,
+  readSync as readSync5,
+  readdirSync as readdirSync8,
+  readlinkSync,
+  realpathSync as realpathSync6,
+  statSync as statSync16
+} from "fs";
+import { basename as basename4, dirname as dirname20, join as join51, sep } from "path";
+function isUuid(v) {
+  return typeof v === "string" && UUID_RE.test(v);
+}
+function id8Of(uuid) {
+  return uuid.replace(/-/g, "").slice(0, 8).toLowerCase();
+}
+function decodeCursor(s) {
+  const m = typeof s === "string" ? CURSOR_RE.exec(s) : null;
+  if (!m)
+    throw new ContractErrorException("invalid_args", "'since' is not a transcript cursor");
+  const offset = Number(m[1]);
+  const k = Number(m[2]);
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(k))
+    throw new ContractErrorException("invalid_args", "'since' is not a transcript cursor");
+  return { offset, k, id8: m[3] };
+}
+function encodeCursor(c) {
+  return `${CURSOR_PREFIX}.${c.offset}.${c.k}.${c.id8}`;
+}
+
+class LineScanner {
+  fd;
+  size;
+  chunk = Buffer.alloc(0);
+  chunkStart;
+  idx = 0;
+  constructor(fd, size, start) {
+    this.fd = fd;
+    this.size = size;
+    this.chunkStart = start;
+  }
+  get position() {
+    return this.chunkStart + this.idx;
+  }
+  next(collect, maxBytes) {
+    const start = this.position;
+    const parts = [];
+    let len = 0;
+    let keep = collect;
+    for (;; ) {
+      if (this.idx >= this.chunk.length) {
+        const at = this.chunkStart + this.chunk.length;
+        if (at >= this.size)
+          return null;
+        const n = Math.min(READ_CHUNK, this.size - at);
+        const b = Buffer.alloc(n);
+        const got = readSync5(this.fd, b, 0, n, at);
+        if (got <= 0)
+          return null;
+        this.chunk = got < n ? b.subarray(0, got) : b;
+        this.chunkStart = at;
+        this.idx = 0;
+      }
+      const nl = this.chunk.indexOf(10, this.idx);
+      const stop = nl === -1 ? this.chunk.length : nl;
+      if (keep) {
+        const piece = this.chunk.subarray(this.idx, stop);
+        len += piece.length;
+        if (len > maxBytes) {
+          keep = false;
+          parts.length = 0;
+        } else
+          parts.push(piece);
+      }
+      if (nl === -1) {
+        this.idx = this.chunk.length;
+        continue;
+      }
+      this.idx = nl + 1;
+      return { start, end: this.chunkStart + nl, data: keep ? Buffer.concat(parts) : null };
+    }
+  }
+}
+function lineCost(l) {
+  return Buffer.byteLength(JSON.stringify(l)) + 1;
+}
+function absentPage(from) {
+  return { lines: [], next: from, more: false, at: [] };
+}
+function closeQuietly(fd) {
+  try {
+    closeSync12(fd);
+  } catch {}
+}
+function readTranscriptPageFd(fd, from, limits) {
+  const lim = { ...DEFAULT_PAGE_LIMITS, ...limits };
+  const st = fstatSync5(fd);
+  if (!st.isFile())
+    return absentPage(from);
+  const size = st.size;
+  if (from.offset > size)
+    throw new ContractErrorException("invalid_args", "'since' is past the end of the transcript");
+  if (from.offset > 0) {
+    const b = Buffer.alloc(1);
+    const got = readSync5(fd, b, 0, 1, from.offset - 1);
+    if (got !== 1 || b[0] !== 10)
+      throw new ContractErrorException("invalid_args", "'since' is not at a line start");
+  }
+  const scanner = new LineScanner(fd, size, from.offset);
+  const lines = [];
+  const at = [];
+  let bytes = lim.envelopeBytes;
+  let next = { ...from };
+  let more = false;
+  for (;; ) {
+    if (scanner.position - from.offset >= lim.scanBytes) {
+      if (scanner.next(false, 0))
+        more = true;
+      break;
+    }
+    const l = scanner.next(true, lim.maxEntryBytes);
+    if (!l)
+      break;
+    const startK = l.start === from.offset ? from.k : 0;
+    if (l.data) {
+      let j = 0;
+      for (const pending of entryLines(l.data.toString("utf-8"))) {
+        if (j < startK) {
+          j++;
+          continue;
+        }
+        const stop = { lines, next: { offset: l.start, k: j, id8: from.id8 }, more: true, at };
+        if (lines.length >= lim.maxLines)
+          return stop;
+        const line = pending.build();
+        const cost = lineCost(line);
+        if (lines.length > 0 && bytes + cost > lim.maxAnswerBytes)
+          return stop;
+        lines.push(line);
+        at.push({ offset: l.start, k: j, id8: from.id8 });
+        bytes += cost;
+        j++;
+      }
+    }
+    next = { offset: l.end + 1, k: 0, id8: from.id8 };
+  }
+  return { lines, next, more, at };
+}
+function locateTranscriptByUuid(projectsRoot, uuid) {
+  if (!isUuid(uuid))
+    return null;
+  let dirs;
+  try {
+    dirs = readdirSync8(projectsRoot);
+  } catch {
+    return null;
+  }
+  let hit = null;
+  for (const d of dirs) {
+    const p = join51(projectsRoot, d, `${uuid}.jsonl`);
+    try {
+      if (!statSync16(p).isFile())
+        continue;
+    } catch {
+      continue;
+    }
+    if (hit !== null)
+      return null;
+    hit = p;
+  }
+  return hit;
+}
+function writerLiveness(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+    return "unknown";
+  try {
+    process.kill(pid, 0);
+    return "alive";
+  } catch (e) {
+    const code = e?.code;
+    if (code === "ESRCH")
+      return "dead";
+    if (code === "EPERM")
+      return "alive";
+    return "unknown";
+  }
+}
+function fileAgeMs(path, now = Date.now()) {
+  try {
+    return now - statSync16(path).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function transcriptQuiet(path, now, graceMs) {
+  if (path === null)
+    return true;
+  const age = fileAgeMs(path, now);
+  return age === null || age >= graceMs;
+}
+function logRejection(path, why) {
+  if (loggedRejections.has(path) || loggedRejections.size >= MAX_LOGGED_REJECTIONS)
+    return;
+  loggedRejections.add(path);
+  log(`[transcript] refused transcript path ${path}: ${why}`);
+}
+function isEnoent(e) {
+  const code = e?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function errText(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function openContainedTranscript(path, uuid, projectsRoot) {
+  if (basename4(path) !== `${uuid}.jsonl`) {
+    logRejection(path, "basename is not the session uuid");
+    return null;
+  }
+  let real;
+  let root;
+  try {
+    real = realpathSync6(path);
+    root = realpathSync6(projectsRoot);
+  } catch (e) {
+    if (!isEnoent(e))
+      logRejection(path, errText(e));
+    return null;
+  }
+  if (!real.startsWith(root + sep)) {
+    logRejection(path, "outside the Claude Code projects directory");
+    return null;
+  }
+  let fd;
+  try {
+    fd = openSync12(real, OPEN_FLAGS);
+  } catch (e) {
+    if (e?.code === "ELOOP")
+      logRejection(path, "the transcript became a symlink");
+    else if (!isEnoent(e))
+      logRejection(path, errText(e));
+    return null;
+  }
+  try {
+    const st = fstatSync5(fd);
+    if (!st.isFile()) {
+      logRejection(path, "not a regular file");
+      closeQuietly(fd);
+      return null;
+    }
+    const parent = dirname20(real);
+    const named = lstatSync6(real);
+    if (realpathSync6(parent) !== parent || !named.isFile() || named.dev !== st.dev || named.ino !== st.ino || !kernelPathMatches(fd, real)) {
+      logRejection(path, "the opened file is not the one under the projects directory");
+      closeQuietly(fd);
+      return null;
+    }
+    return fd;
+  } catch (e) {
+    if (!isEnoent(e))
+      logRejection(path, errText(e));
+    closeQuietly(fd);
+    return null;
+  }
+}
+function kernelPathMatches(fd, real) {
+  if (process.platform !== "linux")
+    return true;
+  let kernel;
+  try {
+    kernel = readlinkSync(`/proc/self/fd/${fd}`);
+  } catch {
+    return true;
+  }
+  return kernel === real;
+}
+function envelopeBytesOf(address) {
+  return Buffer.byteLength(JSON.stringify({ ...address, cursor: WORST_CASE_CURSOR, lines: [], more: false, final: false }));
+}
+function transcriptAnswer(src, since, address, limits) {
+  const uuid = isUuid(src.sessionUuid) ? src.sessionUuid.toLowerCase() : null;
+  const id8 = uuid ? id8Of(uuid) : NO_UUID_ID8;
+  if (since && since.id8 !== id8)
+    throw new ContractErrorException("invalid_args", "the cursor belongs to another transcript");
+  const from = since ?? { offset: 0, k: 0, id8 };
+  const lim = { envelopeBytes: envelopeBytesOf(address), ...limits };
+  const maxBytes = lim.maxAnswerBytes ?? DEFAULT_PAGE_LIMITS.maxAnswerBytes;
+  let page;
+  if (!uuid) {
+    if (from.offset !== 0 || from.k !== 0)
+      throw new ContractErrorException("invalid_args", "the cursor belongs to another transcript");
+    page = absentPage(from);
+  } else {
+    const fd = src.transcriptPath === null ? null : openContainedTranscript(src.transcriptPath, uuid, src.projectsRoot);
+    if (fd === null)
+      page = absentPage(from);
+    else {
+      try {
+        page = readTranscriptPageFd(fd, from, lim);
+      } finally {
+        closeQuietly(fd);
+      }
+    }
+  }
+  const build = () => ({
+    ...address,
+    cursor: encodeCursor(page.next),
+    lines: page.lines,
+    more: page.more,
+    final: src.writerGone && !page.more
+  });
+  let answer = build();
+  while (page.lines.length > 1 && Buffer.byteLength(JSON.stringify(answer)) > maxBytes) {
+    const last = page.at[page.lines.length - 1];
+    page = {
+      lines: page.lines.slice(0, -1),
+      at: page.at.slice(0, -1),
+      next: last,
+      more: true
+    };
+    answer = build();
+  }
+  return answer;
+}
+var NO_UUID_ID8 = "00000000", CURSOR_PREFIX = "v1", CURSOR_RE, UUID_RE, WORST_CASE_CURSOR, DEFAULT_PAGE_LIMITS, READ_CHUNK, OPEN_FLAGS, TRANSCRIPT_GRACE_MS = 30000, loggedRejections, MAX_LOGGED_REJECTIONS = 256;
+var init_transcript_page = __esm(() => {
+  init_logger();
+  init_contract();
+  init_transcript_redaction();
+  CURSOR_RE = /^v1\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.([0-9a-f]{8})$/;
+  UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  WORST_CASE_CURSOR = `${CURSOR_PREFIX}.${"9".repeat(16)}.${"9".repeat(16)}.${"f".repeat(8)}`;
+  DEFAULT_PAGE_LIMITS = {
+    maxLines: MAX_TRANSCRIPT_LINES,
+    maxAnswerBytes: TRANSCRIPT_ANSWER_MAX_BYTES,
+    envelopeBytes: 0,
+    scanBytes: 16 * 1024 * 1024,
+    maxEntryBytes: 32 * 1024 * 1024
+  };
+  READ_CHUNK = 1024 * 1024;
+  OPEN_FLAGS = constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0) | (constants4.O_NONBLOCK ?? 0);
+  loggedRejections = new Set;
+});
+
 // src/pane/types.ts
 function chainAnswerOf(t) {
   return [...t.chainAnswers, t.answer].filter((a) => a !== "").join(`
@@ -97239,6 +98251,10 @@ var init_pane = __esm(() => {
   init_pane_launch();
   init_pane_registry();
   init_pane_session();
+  init_scroll_input();
+  init_transcript_lines();
+  init_transcript_redaction();
+  init_transcript_page();
   init_contract();
 });
 
@@ -97259,10 +98275,10 @@ __export(exports_session_discovery, {
   transcriptPathFor: () => transcriptPathFor
 });
 import { execFile as execFile4, execFileSync as execFileSync3 } from "child_process";
-import { closeSync as closeSync12, openSync as openSync12, readSync as readSync5, readdirSync as readdirSync8, realpathSync as realpathSync6, statSync as statSync16 } from "fs";
-import { basename as basename4, join as join51 } from "path";
+import { closeSync as closeSync13, openSync as openSync13, readSync as readSync6, readdirSync as readdirSync9, realpathSync as realpathSync7, statSync as statSync17 } from "fs";
+import { basename as basename5, join as join52 } from "path";
 function projectsDir(env = process.env) {
-  return join51(claudeConfigDir(env), "projects");
+  return join52(claudeConfigDir(env), "projects");
 }
 function slugForPath(absPath) {
   return projectDirNameFor(absPath);
@@ -97270,9 +98286,9 @@ function slugForPath(absPath) {
 function transcriptPathFor(cwd, sessionUuid, projectsRoot = projectsDir()) {
   let real = cwd;
   try {
-    real = realpathSync6(cwd);
+    real = realpathSync7(cwd);
   } catch {}
-  return join51(projectsRoot, slugForPath(real), `${sessionUuid}.jsonl`);
+  return join52(projectsRoot, slugForPath(real), `${sessionUuid}.jsonl`);
 }
 function isAgentSession(row) {
   return row.entrypoint !== undefined && row.entrypoint !== "cli";
@@ -97313,28 +98329,28 @@ function getRepoContext(cwd = process.cwd()) {
 }
 function projectDirs() {
   try {
-    return readdirSync8(projectsDir(), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync9(projectsDir(), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
 }
 function sessionsIn2(dirName) {
-  const dir = join51(projectsDir(), dirName);
+  const dir = join52(projectsDir(), dirName);
   let names;
   try {
-    names = readdirSync8(dir).filter((n) => n.endsWith(".jsonl"));
+    names = readdirSync9(dir).filter((n) => n.endsWith(".jsonl"));
   } catch {
     return [];
   }
   const rows = [];
   for (const n of names) {
-    const file = join51(dir, n);
+    const file = join52(dir, n);
     try {
-      const st = statSync16(file);
+      const st = statSync17(file);
       if (st.size === 0)
         continue;
       const row = {
-        id: basename4(n, ".jsonl"),
+        id: basename5(n, ".jsonl"),
         file,
         mtimeMs: st.mtimeMs,
         birthtimeMs: st.birthtimeMs,
@@ -97436,7 +98452,7 @@ function discoverWorktreeGroups(repo) {
     if (hit) {
       path = hit.path;
       live = true;
-      name = hit.path === repo.root ? "(root)" : basename4(hit.path);
+      name = hit.path === repo.root ? "(root)" : basename5(hit.path);
     } else if (at !== -1 && dir.startsWith(rootSlug)) {
       path = null;
       live = false;
@@ -97491,7 +98507,7 @@ function discoverWorktreeGroups(repo) {
     g.activeNow = g.sessions.some((s) => isActive(s));
     if (g.path) {
       try {
-        g.createdMs = statSync16(g.path).birthtimeMs;
+        g.createdMs = statSync17(g.path).birthtimeMs;
       } catch {}
     }
     if (!g.createdMs && g.sessions.length > 0) {
@@ -97509,16 +98525,16 @@ function readChunk(file, pos, len) {
     return "";
   let fd = null;
   try {
-    fd = openSync12(file, "r");
+    fd = openSync13(file, "r");
     const buf = Buffer.allocUnsafe(len);
-    const n = readSync5(fd, buf, 0, len, pos);
+    const n = readSync6(fd, buf, 0, len, pos);
     return buf.subarray(0, n).toString("utf-8");
   } catch {
     return "";
   } finally {
     if (fd !== null) {
       try {
-        closeSync12(fd);
+        closeSync13(fd);
       } catch {}
     }
   }
@@ -97579,7 +98595,7 @@ function hydrateSession(row) {
   row.hydrated = true;
   if (isActive(row)) {
     try {
-      row.sizeBytes = statSync16(row.file).size;
+      row.sizeBytes = statSync17(row.file).size;
     } catch {}
   }
   const head = parseRecords(readChunk(row.file, 0, Math.min(HEAD_BYTES, row.sizeBytes)), false);
@@ -97707,16 +98723,16 @@ var init_session_discovery = __esm(() => {
 import { randomBytes as randomBytes13, randomUUID as randomUUID8 } from "crypto";
 import {
   existsSync as existsSync36,
-  lstatSync as lstatSync6,
+  lstatSync as lstatSync7,
   mkdirSync as mkdirSync24,
   readFileSync as readFileSync42,
-  readdirSync as readdirSync9,
-  realpathSync as realpathSync7,
+  readdirSync as readdirSync10,
+  realpathSync as realpathSync8,
   rmSync as rmSync12,
-  statSync as statSync17,
+  statSync as statSync18,
   writeFileSync as writeFileSync22
 } from "fs";
-import { basename as basename5, dirname as dirname20, join as join52, resolve as resolve5, sep } from "path";
+import { basename as basename6, dirname as dirname21, join as join53, resolve as resolve5, sep as sep2 } from "path";
 function slotTerminal(e) {
   if (!e.session)
     return true;
@@ -97785,7 +98801,7 @@ function notableAnomalies(snap) {
   return snap.anomalies.filter((a) => a.startsWith("background_shell_open") || a.startsWith("turn_end_record_missing") || a.startsWith("agent_count_mismatch") || a.startsWith("prompt_not_read"));
 }
 function upstreamLogPath(path, id) {
-  return join52(path, "errors", `${id}-upstream.jsonl`);
+  return join53(path, "errors", `${id}-upstream.jsonl`);
 }
 function neverSpawnedRow(e, m) {
   return {
@@ -97882,9 +98898,9 @@ function teamRunRowFromDisk(path, status) {
   const settled = slots.length > 0 && slots.every((s) => isTerminalState(s.state));
   const completions = Object.values(status.models ?? {}).map((m) => m?.completedAt ? Date.parse(m.completedAt) : Number.NaN).filter(Number.isFinite);
   return {
-    run_id: status.runId ?? basename5(path),
+    run_id: status.runId ?? basename6(path),
     path,
-    kind: status.kind ?? (basename5(path) === "judging" ? "judge" : "run"),
+    kind: status.kind ?? (basename6(path) === "judging" ? "judge" : "run"),
     started_at: status.startedAt,
     finished_at: settled ? new Date(completions.length ? Math.max(...completions) : statusMtimeMs(path) ?? Date.parse(status.startedAt)).toISOString() : null,
     state: settled ? "SETTLED" : "ACTIVE",
@@ -97894,14 +98910,14 @@ function teamRunRowFromDisk(path, status) {
 }
 function statusMtimeMs(path) {
   try {
-    return statSync17(join52(path, "status.json")).mtimeMs;
+    return statSync18(join53(path, "status.json")).mtimeMs;
   } catch {
     return null;
   }
 }
 function readManifestOrNull(path) {
   try {
-    return JSON.parse(readFileSync42(join52(path, "manifest.json"), "utf-8"));
+    return JSON.parse(readFileSync42(join53(path, "manifest.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -97967,6 +98983,68 @@ async function resizeTeamSlot(path, slot, cols, rows, runId) {
     return { ...where, cols: DEFAULT_PANE_COLS, rows: DEFAULT_PANE_ROWS, changed: false, seq: 0 };
   return { ...where, ...await e.session.resize(cols, rows) };
 }
+async function scrollTeamSlot(path, slot, req, runId) {
+  const run = addressRun(path, runId);
+  if (!run)
+    throw unknownRun(path, runId);
+  const e = run.slots.get(slot);
+  if (!e)
+    throw new ContractErrorException("unknown_slot", `run ${run.runId} has no slot ${JSON.stringify(slot)}`);
+  if (!e.session) {
+    const state = run.status.models[e.id]?.state;
+    throw new ContractErrorException("scroll_unavailable", state === undefined || isTerminalState(state) ? "the slot has finished" : "the slot is still starting");
+  }
+  const r = await e.session.scroll(req);
+  return { run_id: run.runId, path: run.path, slot, seq: r.seq };
+}
+function transcriptTeamSlot(path, slot, since, runId, opts = {}) {
+  const graceMs = opts.graceMs ?? TRANSCRIPT_GRACE_MS;
+  const run = addressRun(path, runId);
+  if (run) {
+    const e = run.slots.get(slot);
+    if (!e)
+      throw new ContractErrorException("unknown_slot", `run ${run.runId} has no slot ${JSON.stringify(slot)}`);
+    const m = run.status.models[e.id];
+    const writerGone = e.session ? isTerminalState(e.session.snapshot().state) && e.reapVerified === true : m?.state === undefined || isTerminalState(m.state);
+    const src = {
+      transcriptPath: m?.transcriptPath || null,
+      sessionUuid: m?.sessionUuid || null,
+      writerGone,
+      projectsRoot: run.projectsRoot
+    };
+    return transcriptAnswer(src, since, { run_id: run.runId, path: run.path, slot });
+  }
+  if (path === undefined)
+    throw unknownRun(path, runId);
+  const resolved = resolve5(path);
+  let status;
+  try {
+    status = getStatus(resolved);
+  } catch {
+    throw unknownRun(path, runId);
+  }
+  if (!status || typeof status !== "object" || !status.models || typeof status.models !== "object")
+    throw unknownRun(path, runId);
+  const fileRunId = typeof status.runId === "string" && status.runId ? status.runId : basename6(resolved);
+  if (runId !== undefined && runId !== fileRunId)
+    throw unknownRun(path, runId);
+  const m = Object.hasOwn(status.models, slot) ? status.models[slot] : undefined;
+  if (!m || typeof m !== "object")
+    throw new ContractErrorException("unknown_slot", `run ${fileRunId} has no slot ${JSON.stringify(slot)}`);
+  const now = Date.now();
+  const endedMs = typeof m.completedAt === "string" ? Date.parse(m.completedAt) : Number.NaN;
+  const mtime = statusMtimeMs(resolved);
+  const age = Number.isFinite(endedMs) ? now - endedMs : mtime === null ? null : now - mtime;
+  const terminal = typeof m.state === "string" && SLOT_STATES.includes(m.state) && isTerminalState(m.state);
+  const transcriptPath = typeof m.transcriptPath === "string" && m.transcriptPath ? m.transcriptPath : null;
+  const src = {
+    transcriptPath,
+    sessionUuid: typeof m.sessionUuid === "string" && m.sessionUuid ? m.sessionUuid : null,
+    writerGone: terminal && age !== null && age >= graceMs && transcriptQuiet(transcriptPath, now, graceMs),
+    projectsRoot: projectsDir(opts.parentEnv ?? process.env)
+  };
+  return transcriptAnswer(src, since, { run_id: fileRunId, path: resolved, slot });
+}
 function teamLiveMaps(path, runId) {
   const run = addressRun(path, runId);
   if (!run)
@@ -98099,20 +99177,20 @@ function answerFailureDetail(v, answer, requirePattern, outcomes) {
 function readWrittenFile(path, root) {
   let realRoot;
   try {
-    realRoot = realpathSync7(root);
+    realRoot = realpathSync8(root);
   } catch {
     realRoot = resolve5(root);
   }
   let real;
   try {
-    real = realpathSync7(resolve5(root, path));
+    real = realpathSync8(resolve5(root, path));
   } catch {
     return { skip: "missing" };
   }
-  if (real !== realRoot && !real.startsWith(realRoot + sep))
+  if (real !== realRoot && !real.startsWith(realRoot + sep2))
     return { skip: "outside the working directory" };
   try {
-    const st = statSync17(real);
+    const st = statSync18(real);
     if (!st.isFile())
       return { skip: "not a regular file" };
     if (st.size > MAX_FILE_ANSWER_BYTES)
@@ -98165,24 +99243,24 @@ function validateSessionPath(sessionPath) {
   const tail = [];
   for (;; ) {
     try {
-      lstatSync6(existing);
+      lstatSync7(existing);
       break;
     } catch {
-      const parent = dirname20(existing);
+      const parent = dirname21(existing);
       if (parent === existing)
         break;
-      tail.unshift(basename5(existing));
+      tail.unshift(basename6(existing));
       existing = parent;
     }
   }
   let real;
   try {
-    real = join52(realpathSync7(existing), ...tail);
+    real = join53(realpathSync8(existing), ...tail);
   } catch {
     throw outside();
   }
-  const cwd = realpathSync7(process.cwd());
-  if (real !== cwd && !real.startsWith(cwd + sep)) {
+  const cwd = realpathSync8(process.cwd());
+  if (real !== cwd && !real.startsWith(cwd + sep2)) {
     throw outside();
   }
   return resolved;
@@ -98206,14 +99284,14 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync36(join52(sessionPath, "manifest.json"))) {
+  if (existsSync36(join53(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
-  mkdirSync24(join52(sessionPath, "work"), { recursive: true });
-  mkdirSync24(join52(sessionPath, "errors"), { recursive: true });
+  mkdirSync24(join53(sessionPath, "work"), { recursive: true });
+  mkdirSync24(join53(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync22(join52(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync36(join52(sessionPath, "input.md"))) {
+    writeFileSync22(join53(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync36(join53(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -98230,9 +99308,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync24(join52(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync24(join53(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync22(join52(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync22(join53(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -98247,7 +99325,7 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileAtomic(join52(sessionPath, "status.json"), JSON.stringify(status, null, 2));
+  writeFileAtomic(join53(sessionPath, "status.json"), JSON.stringify(status, null, 2));
   return manifest;
 }
 function assertValidRequirePattern(pattern) {
@@ -98282,7 +99360,7 @@ async function preflightTeamRun(opts) {
     throw new Error(`pane_limit: ${live} live panes for this user, ${opts.slots} more would exceed ${MAX_LIVE_PANES}`);
 }
 function mintRunId(path, startMs) {
-  return `${basename5(path)}-${startMs.toString(36)}-${randomBytes13(3).toString("hex")}`;
+  return `${basename6(path)}-${startMs.toString(36)}-${randomBytes13(3).toString("hex")}`;
 }
 function startModels(sessionPath, opts = {}) {
   const flight = { aborted: false };
@@ -98308,9 +99386,9 @@ async function startModelsIn(flight, sessionPath, opts) {
     throw new Error(`invalid_args: ${flagCheck.message}`);
   const agentRequested = requestedAgentOf(claudeFlags);
   const path = resolve5(sessionPath);
-  const manifest = JSON.parse(readFileSync42(join52(path, "manifest.json"), "utf-8"));
-  const statusPath = join52(path, "status.json");
-  const inputContent = readFileSync42(join52(path, "input.md"), "utf-8");
+  const manifest = JSON.parse(readFileSync42(join53(path, "manifest.json"), "utf-8"));
+  const statusPath = join53(path, "status.json");
+  const inputContent = readFileSync42(join53(path, "input.md"), "utf-8");
   const readAvailable = !flagsRemoveRead(claudeFlags);
   const refusal = deliveryRefusal(inputContent, readAvailable);
   if (refusal)
@@ -98350,7 +99428,7 @@ async function startModelsIn(flight, sessionPath, opts) {
   mkdirSync24(statsDir(path), { recursive: true });
   const entries = new Map;
   let run = null;
-  const errorLogPathOf = (id) => join52(path, "errors", `${id}.log`);
+  const errorLogPathOf = (id) => join53(path, "errors", `${id}.log`);
   const upstreamLogOf = (id) => upstreamLogPath(path, id);
   const flagsOf = (e) => {
     const effort = opts.efforts?.[e.model];
@@ -98360,7 +99438,7 @@ async function startModelsIn(flight, sessionPath, opts) {
   function writeResponse(e, text) {
     e.answer = text;
     try {
-      writeFileSync22(join52(path, `response-${e.id}.md`), text, "utf-8");
+      writeFileSync22(join53(path, `response-${e.id}.md`), text, "utf-8");
     } catch (err) {
       persistErrorLog(errorLogPathOf(e.id), `response file not written: ${String(err)}`, []);
     }
@@ -98370,7 +99448,7 @@ async function startModelsIn(flight, sessionPath, opts) {
     if (e.answer !== null || !e.session)
       return;
     try {
-      writeFileSync22(join52(path, `response-${e.id}.md`), e.session.chainText(), "utf-8");
+      writeFileSync22(join53(path, `response-${e.id}.md`), e.session.chainText(), "utf-8");
     } catch (err) {
       persistErrorLog(errorLogPathOf(e.id), `response file not written: ${String(err)}`, []);
     }
@@ -98567,7 +99645,7 @@ async function startModelsIn(flight, sessionPath, opts) {
   }
   async function startSlot(e, uuid, transcriptPath) {
     let session;
-    e.inboxPath = createHookInbox(join52(path, "work"), `${e.id}.hook-inbox.jsonl`);
+    e.inboxPath = createHookInbox(join53(path, "work"), `${e.id}.hook-inbox.jsonl`);
     const binding = bindingFor(e, uuid);
     e.binding = binding;
     try {
@@ -98607,6 +99685,9 @@ async function startModelsIn(flight, sessionPath, opts) {
       return;
     }
     e.session = session;
+    session.reapVerified?.().then(() => {
+      e.reapVerified = true;
+    });
     session.reaped().then(() => {
       if (!binding && e.inboxPath)
         reportOwnerWithoutHooks(e.inboxPath, hookEngine, { model: e.model, sessionId: uuid });
@@ -98746,7 +99827,8 @@ async function startModelsIn(flight, sessionPath, opts) {
     finishedAt: null,
     status: statusCache,
     slots: entries,
-    settled
+    settled,
+    projectsRoot: projects
   };
   teamRuns.set(runId, run);
   newestRunByPath.set(path, runId);
@@ -98782,7 +99864,7 @@ async function startModelsIn(flight, sessionPath, opts) {
   done.catch((err) => log(`[team] run failed at ${path}: ${err instanceof Error ? err.message : String(err)}`));
   return {
     runId,
-    teamSessionId: basename5(path),
+    teamSessionId: basename6(path),
     sessionPath: path,
     slots: Object.fromEntries(Object.entries(manifest.models).map(([anonId, entry]) => [entry.model, anonId])),
     done
@@ -98796,20 +99878,20 @@ async function judgeResponses(sessionPath, opts = {}) {
   const active = activeRunAt(resolve5(sessionPath));
   if (active)
     throw new Error(`invalid_args: the team run at ${resolve5(sessionPath)} is still ACTIVE (run_id ${active.runId}); judge it once it has settled`);
-  const responseFiles = readdirSync9(sessionPath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  const responseFiles = readdirSync10(sessionPath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
   if (responseFiles.length < 2) {
     throw new Error(`Need at least 2 responses to judge, found ${responseFiles.length}`);
   }
   const responses = {};
   for (const file of responseFiles) {
     const id = file.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync42(join52(sessionPath, file), "utf-8");
+    responses[id] = readFileSync42(join53(sessionPath, file), "utf-8");
   }
-  const input = readFileSync42(join52(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync42(join53(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync22(join52(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync22(join53(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join52(sessionPath, "judging");
+  const judgePath = join53(sessionPath, "judging");
   mkdirSync24(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, {
@@ -98821,11 +99903,11 @@ async function judgeResponses(sessionPath, opts = {}) {
   });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync22(join52(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync22(join53(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync42(join52(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync42(join53(sessionPath, "status.json"), "utf-8"));
 }
 function readTeamStatus(sessionPath) {
   try {
@@ -98865,7 +99947,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync42(join52(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync42(join53(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -98923,12 +100005,12 @@ function buildJudgePrompt(input, responses) {
 }
 function parseJudgeVotes(judgePath, responseIds) {
   const votes = [];
-  const responseFiles = readdirSync9(judgePath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  const responseFiles = readdirSync10(judgePath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
   for (const file of responseFiles) {
     const judgeId = file.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync42(join52(judgePath, file), "utf-8");
+      content = readFileSync42(join53(judgePath, file), "utf-8");
     } catch (err) {
       log(`[team] judge answer ${file} unreadable: ${err instanceof Error ? err.message : String(err)}`);
       continue;
@@ -98981,7 +100063,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync42(join52(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync42(join53(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -99037,8 +100119,8 @@ var init_team_orchestrator = __esm(() => {
 });
 
 // src/mcp-session/inherited-settings.ts
-import { existsSync as existsSync37, readFileSync as readFileSync43, statSync as statSync18 } from "fs";
-import { join as join53, resolve as resolve6 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync43, statSync as statSync19 } from "fs";
+import { join as join54, resolve as resolve6 } from "path";
 function isPlainObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -99092,7 +100174,7 @@ function readSettingsValue(value) {
 function buildInheritedSettingsLayer(setupFrom, callerFlags) {
   const layers = [];
   for (const name of ["settings.json", "settings.local.json"]) {
-    const file = join53(setupFrom, ".claude", name);
+    const file = join54(setupFrom, ".claude", name);
     if (!existsSync37(file))
       continue;
     layers.push(parseLayer(readFileSync43(file, "utf-8"), file));
@@ -99125,7 +100207,7 @@ function resolveSetupFrom(arg, workDir, serverCwd) {
   let setupFrom = serverCwd;
   if (typeof arg === "string") {
     setupFrom = resolve6(arg);
-    if (!statSync18(setupFrom, { throwIfNoEntry: false })?.isDirectory()) {
+    if (!statSync19(setupFrom, { throwIfNoEntry: false })?.isDirectory()) {
       throw new Error(`invalid_args: setup_from ${setupFrom} is not an existing directory`);
     }
   } else if (arg !== undefined) {
@@ -99139,19 +100221,19 @@ var init_inherited_settings = () => {};
 import { randomUUID as randomUUID9 } from "crypto";
 import {
   appendFileSync as appendFileSync7,
-  closeSync as closeSync13,
+  closeSync as closeSync14,
   createWriteStream,
   existsSync as existsSync38,
   mkdirSync as mkdirSync25,
-  openSync as openSync13,
+  openSync as openSync14,
   readFileSync as readFileSync44,
-  readSync as readSync6,
+  readSync as readSync7,
   renameSync as renameSync10,
   rmSync as rmSync13,
-  statSync as statSync19,
+  statSync as statSync20,
   writeFileSync as writeFileSync23
 } from "fs";
-import { join as join54, resolve as resolve7, sep as sep2 } from "path";
+import { join as join55, resolve as resolve7, sep as sep3 } from "path";
 function normaliseTimeoutSeconds(raw) {
   const n = typeof raw === "string" && raw.trim() !== "" ? Number(raw) : raw;
   if (typeof n !== "number" || !Number.isFinite(n))
@@ -99255,21 +100337,21 @@ function anomalyKey(a) {
 function readTailText(path, maxBytes) {
   let fd = null;
   try {
-    const size = statSync19(path).size;
+    const size = statSync20(path).size;
     if (size === 0)
       return { text: "", truncated: false };
     const start = Math.max(0, size - maxBytes);
     const length = size - start;
     const buf = Buffer.alloc(length);
-    fd = openSync13(path, "r");
-    readSync6(fd, buf, 0, length, start);
+    fd = openSync14(path, "r");
+    readSync7(fd, buf, 0, length, start);
     return { text: buf.toString("utf-8"), truncated: start > 0 };
   } catch {
     return null;
   } finally {
     if (fd !== null) {
       try {
-        closeSync13(fd);
+        closeSync14(fd);
       } catch {}
     }
   }
@@ -99286,7 +100368,7 @@ function readTailLines2(path, maxBytes) {
 }
 function fileSize2(path) {
   try {
-    return statSync19(path).size;
+    return statSync20(path).size;
   } catch {
     return 0;
   }
@@ -99321,7 +100403,7 @@ function dropLeadingFragment(tail) {
   return firstBreak === -1 ? tail.text : tail.text.slice(firstBreak + 1);
 }
 function diskAccounting(sessionDir) {
-  const stats = readTokenStatsAt(join54(sessionDir, "tokens.json"));
+  const stats = readTokenStatsAt(join55(sessionDir, "tokens.json"));
   return {
     tokensIn: stats?.billed_input_tokens ?? null,
     tokensOut: stats?.output_tokens ?? null,
@@ -99361,6 +100443,7 @@ class SessionManager {
   scrollbackCapacity;
   sessionsDir;
   terminalRetentionMs;
+  transcriptGraceMs;
   parentEnv;
   paneTimings;
   starting = 0;
@@ -99380,6 +100463,7 @@ class SessionManager {
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.scrollbackCapacity = options?.scrollbackCapacity ?? DEFAULT_SCROLLBACK;
     this.terminalRetentionMs = options?.terminalRetentionMs ?? TERMINAL_RETENTION_MS;
+    this.transcriptGraceMs = options?.transcriptGraceMs ?? TRANSCRIPT_GRACE_MS;
     this.sessionsDir = options?.sessionsDir ?? sessionsDirFrom(process.env);
     this.parentEnv = options?.parentEnv ?? process.env;
     this.paneTimings = options?.paneTimings;
@@ -99404,7 +100488,7 @@ class SessionManager {
     let dir = "";
     for (let attempt = 0;; attempt++) {
       id = `team-${randomUUID9().replace(/-/g, "").slice(0, 8)}`;
-      dir = join54(this.sessionsDir, id);
+      dir = join55(this.sessionsDir, id);
       try {
         mkdirSync25(dir);
         break;
@@ -99436,9 +100520,9 @@ class SessionManager {
       if (dir === null)
         throw new Error("not a record id");
       const completedAt = new Date().toISOString();
-      const startedAt = this.teamRunStarts.get(record) ?? metaString(readJsonObject(join54(dir, "spawn.json"), META_READ_LIMIT)?.startedAt) ?? completedAt;
+      const startedAt = this.teamRunStarts.get(record) ?? metaString(readJsonObject(join55(dir, "spawn.json"), META_READ_LIMIT)?.startedAt) ?? completedAt;
       const elapsedMs = Date.parse(completedAt) - Date.parse(startedAt);
-      writeJsonAtomic(join54(dir, "meta.json"), {
+      writeJsonAtomic(join55(dir, "meta.json"), {
         kind: "team",
         status: outcome.status,
         startedAt,
@@ -99470,7 +100554,7 @@ class SessionManager {
       startedAt,
       ...rest
     };
-    writeJsonAtomic(join54(dir, "spawn.json"), body);
+    writeJsonAtomic(join55(dir, "spawn.json"), body);
   }
   async createSession(opts) {
     if (this.activeSessions + this.starting >= this.maxSessions) {
@@ -99510,7 +100594,7 @@ class SessionManager {
         throw err;
       }
       if (inherited.layer) {
-        flags = [...inherited.restFlags, "--settings", join54(entry.sessionDir, INHERITED_SETTINGS)];
+        flags = [...inherited.restFlags, "--settings", join55(entry.sessionDir, INHERITED_SETTINGS)];
       }
       this.sessions.set(entry.info.sessionId, entry);
       uncount();
@@ -99535,10 +100619,10 @@ class SessionManager {
     const timeout = normaliseTimeoutSeconds(opts.timeoutSeconds);
     const agentRequested = requestedAgentOf(opts.claudishFlags ?? []);
     const startedAt = new Date().toISOString();
-    const sessionDir = opts.sessionDir ?? join54(this.sessionsDir, sessionId);
+    const sessionDir = opts.sessionDir ?? join55(this.sessionsDir, sessionId);
     mkdirSync25(sessionDir, { recursive: true });
     if (opts.prompt)
-      writeFileSync23(join54(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync23(join55(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     this.writeSpawnRecord(sessionDir, {
       kind: "session",
       sessionId,
@@ -99551,13 +100635,13 @@ class SessionManager {
       ...agentRequested ? { agentRequested } : {}
     });
     if (inheritedLayer) {
-      writeFileSync23(join54(sessionDir, INHERITED_SETTINGS), `${JSON.stringify(inheritedLayer, null, 2)}
+      writeFileSync23(join55(sessionDir, INHERITED_SETTINGS), `${JSON.stringify(inheritedLayer, null, 2)}
 `, { encoding: "utf-8", mode: 384 });
     }
     const cwd = opts.cwd ?? process.cwd();
     const parentEnv = opts.parentEnv ?? this.parentEnv;
     const spawnModel = opts.spawnModel ?? null;
-    const tokenFile = opts.tokenFile ?? join54(sessionDir, "tokens.json");
+    const tokenFile = opts.tokenFile ?? join55(sessionDir, "tokens.json");
     return {
       info: {
         sessionId,
@@ -99595,18 +100679,18 @@ class SessionManager {
       },
       session: null,
       scrollback: new ScrollbackBuffer(this.scrollbackCapacity),
-      outputLogStream: createWriteStream(join54(sessionDir, "output.log")),
+      outputLogStream: createWriteStream(join55(sessionDir, "output.log")),
       sessionDir,
       cwd,
       tokenFile,
-      eventLogPath: join54(sessionDir, "events.jsonl"),
+      eventLogPath: join55(sessionDir, "events.jsonl"),
       eventLogBytes: 0,
-      upstreamErrorLogPath: join54(sessionDir, "upstream-errors.jsonl"),
+      upstreamErrorLogPath: join55(sessionDir, "upstream-errors.jsonl"),
       eventRing: [],
       proseBytes: 0,
       answeredTurns: new Map,
       inboxPath: null,
-      waitLogPath: join54(sessionDir, "waits.jsonl"),
+      waitLogPath: join55(sessionDir, "waits.jsonl"),
       waitLogBytes: 0,
       waitSince: null,
       ended: false,
@@ -99614,7 +100698,9 @@ class SessionManager {
       lastLoggedTool: null,
       assistantIdsLogged: 0,
       anomaliesLogged: new Set,
-      requestedSize: null
+      requestedSize: null,
+      reapVerified: false,
+      projectsRoot: projectsDir(parentEnv)
     };
   }
   async startPane(entry, opts, p) {
@@ -99669,6 +100755,9 @@ class SessionManager {
       session.resize(asked.cols, asked.rows).catch(() => {
         return;
       });
+    session.reapVerified?.().then(() => {
+      entry.reapVerified = true;
+    });
     session.reaped().then(() => {
       if (!binding && entry.inboxPath)
         reportOwnerWithoutHooks(entry.inboxPath, engine, {
@@ -99796,7 +100885,7 @@ class SessionManager {
       try {
         const text = screenLines.join(`
 `).replace(/\s+$/, "");
-        writeFileSync23(join54(entry.sessionDir, "screen.txt"), `${redactSecrets(text)}
+        writeFileSync23(join55(entry.sessionDir, "screen.txt"), `${redactSecrets(text)}
 `, "utf-8");
       } catch {}
     }
@@ -99810,7 +100899,7 @@ class SessionManager {
       entry.waitSince = null;
     }
     try {
-      writeJsonAtomic(join54(entry.sessionDir, "meta.json"), toMetaRecord(entry.info, entry.cwd));
+      writeJsonAtomic(join55(entry.sessionDir, "meta.json"), toMetaRecord(entry.info, entry.cwd));
     } catch (err) {
       process.stderr.write(`[claudish] session ${entry.info.sessionId}: could not write meta.json: ` + `${err instanceof Error ? err.message : String(err)}
 `);
@@ -100007,6 +101096,15 @@ class SessionManager {
     const r = await entry.session.resize(cols, rows);
     return { session_id: sessionId, ...r };
   }
+  async scrollSession(sessionId, req) {
+    const entry = this.liveEntry(sessionId);
+    if (!entry)
+      throw unknownSession(sessionId);
+    if (!entry.session)
+      throw new ContractErrorException("scroll_unavailable", isTerminalState(entry.info.state) ? "the session has finished" : "the session is still starting");
+    const r = await entry.session.scroll(req);
+    return { session_id: sessionId, seq: r.seq };
+  }
   captureSession(sessionId, sinceSeq, spans) {
     const entry = this.liveEntry(sessionId);
     if (!entry)
@@ -100015,6 +101113,71 @@ class SessionManager {
       return sinceSeq === 0 ? { unchanged: true, seq: 0, final: true } : blankFinalCapture();
     return entry.session.capture(sinceSeq, { spans: spans === true });
   }
+  transcriptSession(sessionId, since) {
+    const address = { session_id: sessionId };
+    const entry = this.sessions.get(sessionId);
+    const src = entry ? this.liveTranscriptSource(entry) : this.diskTranscriptSource(sessionId);
+    if (!src)
+      throw unknownSession(sessionId);
+    return transcriptAnswer(src, since, address);
+  }
+  liveTranscriptSource(entry) {
+    const writerGone = entry.session ? isTerminalState(entry.session.snapshot().state) && entry.reapVerified : isTerminalState(entry.info.state);
+    return {
+      transcriptPath: entry.info.transcriptPath || null,
+      sessionUuid: entry.info.claudeSessionId || null,
+      writerGone,
+      projectsRoot: entry.projectsRoot
+    };
+  }
+  diskTranscriptSource(sessionId) {
+    const sessionDir = this.diskSessionDir(sessionId);
+    if (sessionDir === null)
+      return null;
+    try {
+      if (!statSync20(sessionDir).isDirectory())
+        return null;
+    } catch {
+      return null;
+    }
+    const spawnPath = join55(sessionDir, "spawn.json");
+    const metaPath = join55(sessionDir, "meta.json");
+    const spawnRecord = readJsonObject(spawnPath, META_READ_LIMIT);
+    if (spawnRecord?.kind === "team")
+      return null;
+    const meta = readJsonObject(metaPath, META_READ_LIMIT);
+    if (meta?.kind === "team")
+      return null;
+    const projectsRoot = projectsDir(this.parentEnv);
+    const uuid = metaString(meta?.claudeSessionId) ?? metaString(spawnRecord?.claudeSessionId) ?? null;
+    const now = Date.now();
+    let writerGone;
+    let transcriptPath = null;
+    if (meta !== null) {
+      const completedAt = metaString(meta.completedAt);
+      const endedMs = completedAt ? Date.parse(completedAt) : Number.NaN;
+      const age = Number.isFinite(endedMs) ? now - endedMs : fileAgeMs(metaPath, now);
+      if (uuid) {
+        const stored = metaString(meta.transcriptPath);
+        const cwd = metaString(meta.cwd);
+        if (stored && existsSync38(stored))
+          transcriptPath = stored;
+        else if (cwd)
+          transcriptPath = transcriptPathFor(cwd, uuid, projectsRoot);
+        else
+          transcriptPath = locateTranscriptByUuid(projectsRoot, uuid);
+      }
+      writerGone = rawStateTerminal(meta) && age !== null && age >= this.transcriptGraceMs && transcriptQuiet(transcriptPath, now, this.transcriptGraceMs);
+    } else {
+      const pid = spawnRecord?.mcpPid;
+      const liveness = pid === process.pid ? "dead" : writerLiveness(pid);
+      if (uuid)
+        transcriptPath = locateTranscriptByUuid(projectsRoot, uuid);
+      const quiet = (transcriptPath !== null ? fileAgeMs(transcriptPath, now) : null) ?? fileAgeMs(spawnPath, now);
+      writerGone = liveness === "dead" && quiet !== null && quiet >= this.transcriptGraceMs;
+    }
+    return { transcriptPath, sessionUuid: uuid, writerGone, projectsRoot };
+  }
   listSessions(includeCompleted = false) {
     const sessions = [];
     for (const entry of this.sessions.values()) {
@@ -100072,9 +101235,9 @@ class SessionManager {
       return null;
     const root = resolve7(this.sessionsDir);
     const dir = resolve7(root, sessionId);
-    if (dir !== join54(root, sessionId))
+    if (dir !== join55(root, sessionId))
       return null;
-    if (!dir.startsWith(root + sep2))
+    if (!dir.startsWith(root + sep3))
       return null;
     return dir;
   }
@@ -100084,17 +101247,17 @@ class SessionManager {
       return null;
     let dirMtimeMs;
     try {
-      const stat = statSync19(sessionDir);
+      const stat = statSync20(sessionDir);
       if (!stat.isDirectory())
         return null;
       dirMtimeMs = stat.mtimeMs;
     } catch {
       return null;
     }
-    const spawnRecord = readJsonObject(join54(sessionDir, "spawn.json"), META_READ_LIMIT);
+    const spawnRecord = readJsonObject(join55(sessionDir, "spawn.json"), META_READ_LIMIT);
     if (spawnRecord?.kind === "team")
       return null;
-    const meta = readJsonObject(join54(sessionDir, "meta.json"), META_READ_LIMIT);
+    const meta = readJsonObject(join55(sessionDir, "meta.json"), META_READ_LIMIT);
     if (meta?.kind === "team")
       return null;
     const partial = meta === null;
@@ -100116,7 +101279,7 @@ class SessionManager {
     return stored;
   }
   diskOutput(record, tailLines) {
-    const tail = readTailText(join54(record.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
+    const tail = readTailText(join55(record.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
     const buffer = new ScrollbackBuffer(this.scrollbackCapacity);
     if (tail?.text)
       buffer.append(dropLeadingFragment(tail));
@@ -100136,12 +101299,12 @@ class SessionManager {
   }
   diskDiagnostics(record, limit) {
     const { sessionDir, info } = record;
-    const eventLogPath = join54(sessionDir, "events.jsonl");
-    const upstreamErrorLogPath = join54(sessionDir, "upstream-errors.jsonl");
-    const outputLogPath = join54(sessionDir, "output.log");
+    const eventLogPath = join55(sessionDir, "events.jsonl");
+    const upstreamErrorLogPath = join55(sessionDir, "upstream-errors.jsonl");
+    const outputLogPath = join55(sessionDir, "output.log");
     const events = readTailLines2(eventLogPath, EVENT_TAIL_BYTES);
     const outputTail = readTailText(outputLogPath, OUTPUT_TAIL_BYTES);
-    const screen = readTailText(join54(sessionDir, "screen.txt"), SCREEN_READ_BYTES);
+    const screen = readTailText(join55(sessionDir, "screen.txt"), SCREEN_READ_BYTES);
     return {
       sessionId: info.sessionId,
       state: info.state,
@@ -100337,6 +101500,13 @@ function diskState(meta) {
     return { state, reason: "timeout" };
   return { state, reason: null };
 }
+function rawStateTerminal(meta) {
+  const raw = meta.state;
+  if (typeof raw === "string" && SLOT_STATES.includes(raw))
+    return isTerminalState(raw);
+  const status = typeof meta.status === "string" ? STATE_OF_10_4_STATUS[meta.status] : undefined;
+  return status !== undefined && isTerminalState(status);
+}
 function diskInfo(d) {
   const { meta, spawnRecord, measured } = d;
   const startedAt = metaString(meta?.startedAt) ?? metaString(spawnRecord?.startedAt) ?? new Date(d.dirMtimeMs).toISOString();
@@ -100442,7 +101612,7 @@ var NESTED_MCP_TOOL_NAMES, NESTED_INSTRUCTIONS = `Claudish MCP server provides a
 
 ## Nested mode \u2014 no sessions
 
-This server runs inside a session that a claudish MCP server started (CLAUDISH_PANE_CHILD=1). One level of nesting is the limit, so these tools are not registered: create_session, team, send_input, get_output, cancel_session, list_sessions, get_diagnostics, capture_session, preflight, report_error. No channel notifications are sent.
+This server runs inside a session that a claudish MCP server started (CLAUDISH_PANE_CHILD=1). One level of nesting is the limit, so these tools are not registered: create_session, team, send_input, get_output, cancel_session, list_sessions, get_diagnostics, capture_session, resize_session, scroll_session, transcript_session, preflight, report_error. No channel notifications are sent.
 
 - run_prompt or compare_models: a one-shot answer from another model.
 - list_models, search_models: find a model.
@@ -100540,7 +101710,7 @@ var init_progress_heartbeat = __esm(() => {
 import { spawn as spawn2 } from "child_process";
 import { mkdirSync as mkdirSync26, mkdtempSync as mkdtempSync3, rmSync as rmSync14, writeFileSync as writeFileSync24 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 function claudeCodePrintArgv(model, systemPromptFile) {
   const head = [PRINT_FLAGS[0], "--model", model, ...PRINT_FLAGS.slice(1)];
   return systemPromptFile !== undefined ? [...head, "--system-prompt-file", systemPromptFile] : [...head, "--system-prompt", ""];
@@ -100658,13 +101828,13 @@ async function runPromptViaClaudeCode(model, prompt, systemPrompt, opts = {}) {
   } catch (e) {
     throw new Error(`cannot start claudish (${parentEnv.CLAUDISH_BIN?.trim() || "claudish"}): ${e instanceof Error ? e.message : String(e)}`);
   }
-  const root = mkdtempSync3(join55(tmpdir2(), "claudish-run-prompt-"));
+  const root = mkdtempSync3(join56(tmpdir2(), "claudish-run-prompt-"));
   try {
-    const cwd = join55(root, "cwd");
+    const cwd = join56(root, "cwd");
     mkdirSync26(cwd, { mode: 448 });
     let systemPromptFile;
     if (typeof systemPrompt === "string" && systemPrompt.length > 0) {
-      systemPromptFile = join55(root, "system-prompt.txt");
+      systemPromptFile = join56(root, "system-prompt.txt");
       writeFileSync24(systemPromptFile, systemPrompt, { mode: 384 });
     }
     const argv = claudeCodePrintArgv(model, systemPromptFile);
@@ -100964,9 +102134,9 @@ var init_preflight_chain = __esm(() => {
 });
 
 // src/mcp-server.ts
-import { existsSync as existsSync39, readFileSync as readFileSync45, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync45, readdirSync as readdirSync11 } from "fs";
 import { homedir as homedir37 } from "os";
-import { dirname as dirname21, join as join56, resolve as resolve8 } from "path";
+import { dirname as dirname22, join as join57, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync39(OPENROUTER_MODELS_CACHE_PATH)) {
@@ -101539,6 +102709,36 @@ function requiredInteger(raw, name, mode) {
     throw new ContractErrorException("invalid_args", `'${name}' is required${mode ? ` for mode '${mode}'` : ""}`);
   return n;
 }
+function scrollArgs(args) {
+  const by = optionalInteger(args.by, "by");
+  const to = args.to;
+  if (to !== undefined && to !== null && to !== "end")
+    throw new ContractErrorException("invalid_args", `'to' must be "end"`);
+  const hasTo = to === "end";
+  if (by !== undefined && hasTo)
+    throw new ContractErrorException("invalid_args", "give exactly one of 'by' and 'to', not both");
+  if (hasTo)
+    return { to: "end" };
+  if (by === undefined)
+    throw new ContractErrorException("invalid_args", "one of 'by' and 'to' is required");
+  if (by === 0)
+    throw new ContractErrorException("invalid_args", "'by' must not be 0");
+  return { by };
+}
+function transcriptSince(raw) {
+  const since = givenString(raw, "since");
+  return since === undefined ? undefined : decodeCursor(since);
+}
+function givenString(raw, name) {
+  if (raw === undefined)
+    return;
+  if (typeof raw !== "string" || !raw)
+    throw new ContractErrorException("invalid_args", `'${name}' must be a non-empty string`);
+  return raw;
+}
+function grouped(n) {
+  return n.toLocaleString("en-US");
+}
 function teamStatusAnswer(path, runId) {
   let row = null;
   if (runId) {
@@ -101577,12 +102777,14 @@ async function teamContractVerb(mode, args) {
     if (mode === "list")
       return contractAnswer(listTeamRuns());
     const path = contractPath(args.path, mode);
-    const runId = optionalString(args.run_id, "run_id");
+    const runId = mode === "transcript" ? givenString(args.run_id, "run_id") : optionalString(args.run_id, "run_id");
     const slot = optionalString(args.slot, "slot");
-    const since = optionalInteger(args.since_seq, "since_seq");
+    const sinceSeq = optionalInteger(args.since_seq, "since_seq");
     const spans = optionalBoolean(args.spans, "spans");
     const cols = mode === "resize" ? requiredInteger(args.cols, "cols", mode) : undefined;
     const rows = mode === "resize" ? requiredInteger(args.rows, "rows", mode) : undefined;
+    const scroll = mode === "scroll" ? scrollArgs(args) : undefined;
+    const since = mode === "transcript" ? transcriptSince(args.since) : undefined;
     switch (mode) {
       case "status":
         return contractAnswer(teamStatusAnswer(path, runId));
@@ -101591,13 +102793,23 @@ async function teamContractVerb(mode, args) {
       case "capture": {
         if (slot === undefined)
           throw new ContractErrorException("invalid_args", "'slot' is required for mode 'capture'");
-        return contractAnswer(captureTeamSlot(path, slot, since, spans, runId));
+        return contractAnswer(captureTeamSlot(path, slot, sinceSeq, spans, runId));
       }
       case "resize": {
         if (slot === undefined)
           throw new ContractErrorException("invalid_args", "'slot' is required for mode 'resize'");
         return contractAnswer(await resizeTeamSlot(path, slot, cols, rows, runId));
       }
+      case "scroll": {
+        if (slot === undefined)
+          throw new ContractErrorException("invalid_args", "'slot' is required for mode 'scroll'");
+        return contractAnswer(await scrollTeamSlot(path, slot, scroll, runId));
+      }
+      case "transcript": {
+        if (slot === undefined)
+          throw new ContractErrorException("invalid_args", "'slot' is required for mode 'transcript'");
+        return compactAnswer(transcriptTeamSlot(path, slot, since, runId));
+      }
     }
   } catch (e) {
     return contractErrorAnswer(e);
@@ -101945,18 +103157,29 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
   });
   tools.push({
     name: "team",
-    description: "Run AI models on a task with anonymized outputs and optional blind judging. Every slot is an interactive Claude Code session in its own headless magmux pane. " + "Modes: 'run' (START the models and return once each has taken its prompt \u2014 it does " + "NOT wait for answers), 'status' (per-slot state; read `run.slots`), 'list' (every run this server holds), 'capture' (one slot's screen), 'resize' (set one slot's terminal size), 'cancel' (stop one slot or the whole run), 'judge'(blind-vote on existing outputs), 'run-and-judge' (the blocking pipeline). Poll 'status' (read run.slots) or 'list'. NO SLOT IS EVER KILLED ON A TIMER once its prompt is accepted. A team slot is a full Claude Code session and may work for a long time; a slot inside a build or test suite emits nothing for minutes and is working, not stuck. Judge the silence against the task you set, and use 'cancel' if you decide a slot is wedged. A slot that stops on a question it cannot answer is FAILED 'blocked' (team has no way to answer it). JUDGING A WORKING SLOT: read live_output_bytes_by_slot, idle_seconds_by_slot and activity_by_slot (or each row's idle_seconds and " + "activity). Do NOT use 'outputSize' \u2014 it is the size of the final answer, written " + "only when a slot finishes, so it is 0 for every working slot no matter how much that slot has produced.",
+    description: "Run AI models on a task with anonymized outputs and optional blind judging. Every slot is an interactive Claude Code session in its own headless magmux pane. " + "Modes: 'run' (START the models and return once each has taken its prompt \u2014 it does " + "NOT wait for answers), 'status' (per-slot state; read `run.slots`), 'list' (every run this server holds), 'capture' (one slot's screen), 'resize' (set one slot's terminal size), 'scroll' (scroll one slot's transcript view), 'transcript' (one slot's conversation as text lines), 'cancel' (stop one slot or the whole run), 'judge'(blind-vote on existing outputs), 'run-and-judge' (the blocking pipeline). Poll 'status' (read run.slots) or 'list'. NO SLOT IS EVER KILLED ON A TIMER once its prompt is accepted. A team slot is a full Claude Code session and may work for a long time; a slot inside a build or test suite emits nothing for minutes and is working, not stuck. Judge the silence against the task you set, and use 'cancel' if you decide a slot is wedged. A slot that stops on a question it cannot answer is FAILED 'blocked' (team has no way to answer it). JUDGING A WORKING SLOT: read live_output_bytes_by_slot, idle_seconds_by_slot and activity_by_slot (or each row's idle_seconds and " + "activity). Do NOT use 'outputSize' \u2014 it is the size of the final answer, written " + "only when a slot finishes, so it is 0 for every working slot no matter how much that slot has produced.",
     inputSchema: {
       type: "object",
       properties: {
         mode: {
           type: "string",
-          enum: ["run", "judge", "run-and-judge", "status", "cancel", "list", "capture", "resize"],
-          description: "Operation mode. 'run' STARTS the models and returns once every slot has taken " + "its prompt (or failed to) \u2014 it does not wait for answers. Poll 'status' (read " + "`run.slots`) or 'list' for progress, then 'judge' once the slots have finished. 'capture' returns one slot's screen; 'resize' sets its terminal size. 'run-and-judge' is the blocking pipeline and holds the call open for the whole run. 'cancel' stops one slot or the whole run."
+          enum: [
+            "run",
+            "judge",
+            "run-and-judge",
+            "status",
+            "cancel",
+            "list",
+            "capture",
+            "resize",
+            "scroll",
+            "transcript"
+          ],
+          description: "Operation mode. 'run' STARTS the models and returns once every slot has taken " + "its prompt (or failed to) \u2014 it does not wait for answers. Poll 'status' (read " + "`run.slots`) or 'list' for progress, then 'judge' once the slots have finished. 'capture' returns one slot's screen; 'resize' sets its terminal size; 'scroll' scrolls its transcript view (`by` or `to`). 'transcript' reads one slot's conversation as text lines (`since` pages; a `cont` chain may continue in the next answer after `cursor`, in order, never reordered or lost). 'run-and-judge' is the blocking pipeline and holds the call open for the whole run. 'cancel' stops one slot or the whole run."
         },
         slot: {
           type: "string",
-          description: "For 'cancel', 'capture' and 'resize': the anonymised slot id (e.g. '02') from the slot map 'run' returned. 'capture' and 'resize' require it; for 'cancel', omit it to stop every slot in the run."
+          description: "For 'cancel', 'capture', 'resize', 'scroll' and 'transcript': the anonymised slot id (e.g. '02') from the slot map 'run' returned. 'capture', 'resize', 'scroll' and 'transcript' require it; for 'cancel', omit it to stop every slot in the run."
         },
         path: {
           type: "string",
@@ -101964,11 +103187,15 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
         },
         run_id: {
           type: "string",
-          description: "For 'status', 'cancel', 'capture' and 'resize': the run_id a 'run' answer returned. It addresses THAT run while this server retains it, even after a newer run reused the path. Omit it to address the newest run at 'path'."
+          description: "For 'status', 'cancel', 'capture', 'resize', 'scroll' and 'transcript': the run_id a 'run' answer returned. It addresses THAT run while this server retains it, even after a newer run reused the path. Omit it to address the newest run at 'path'."
         },
         since_seq: {
           type: "number",
-          description: "For 'capture': the `seq` of the screen you already hold. When it is still current the answer is `{unchanged:true}`; any other value returns the full screen."
+          description: "For 'capture' only: the `seq` of the screen you already hold. When it is still current the answer is `{unchanged:true}`; any other value returns the full screen."
+        },
+        since: {
+          type: "string",
+          description: `For 'transcript' only (capture uses since_seq): the \`cursor\` of a previous answer; returns only the lines after it. Omit to read from the start. Answer {run_id, path, slot, cursor, lines, more, final}, at most ${MAX_TRANSCRIPT_LINES} lines and ${grouped(TRANSCRIPT_ANSWER_MAX_BYTES)} bytes per call; a \`cont\` chain may continue in the next answer after \`cursor\`, in order, never reordered or lost.`
         },
         spans: {
           type: "boolean",
@@ -101982,6 +103209,15 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
           type: "integer",
           description: "For 'resize' (required): the terminal height in rows, clamped to 24\u20139999 and to " + "at most 4 000 000 cells (cols \xD7 rows)."
         },
+        by: {
+          type: "integer",
+          description: "For 'scroll': rows to scroll the slot's transcript view; negative = toward older " + `content, positive = toward the live bottom. A target, \xB1 1 row; |by| is capped at ${MAX_SCROLL_ROWS}. Not 0. Give exactly one of 'by' and 'to'. The answer {run_id, path, slot, seq} carries the screen's seq after the scroll.`
+        },
+        to: {
+          type: "string",
+          enum: ["end"],
+          description: `For 'scroll': "end" returns the slot's view to the live bottom. Give exactly one of 'by' and 'to'.`
+        },
         models: {
           type: "array",
           items: { type: "string" },
@@ -102038,7 +103274,7 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
     heartbeat: true,
     handler: async (args, ctx) => {
       const mode = args.mode;
-      if (mode === "list" || mode === "status" || mode === "cancel" || mode === "capture" || mode === "resize") {
+      if (mode === "list" || mode === "status" || mode === "cancel" || mode === "capture" || mode === "resize" || mode === "scroll" || mode === "transcript") {
         return teamContractVerb(mode, args);
       }
       try {
@@ -102092,7 +103328,7 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
         const promptText = () => {
           if (input !== undefined)
             return input;
-          const existing = join56(resolved, "input.md");
+          const existing = join57(resolved, "input.md");
           return existsSync39(existing) ? readFileSync45(existing, "utf-8") : undefined;
         };
         const choice = modelChoiceStop([
@@ -102275,26 +103511,26 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
         const sp = session_path;
         for (const file of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file] = readFileSync45(join56(sp, file), "utf-8");
+            sessionData[file] = readFileSync45(join57(sp, file), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join56(sp, "errors");
+          const errorDir = join57(sp, "errors");
           if (existsSync39(errorDir)) {
-            for (const f of readdirSync10(errorDir)) {
+            for (const f of readdirSync11(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync45(join56(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync45(join57(errorDir, f), "utf-8");
                 } catch {}
               }
             }
           }
         } catch {}
         try {
-          for (const f of readdirSync10(sp)) {
+          for (const f of readdirSync11(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync45(join56(sp, f), "utf-8");
+                const content = readFileSync45(join57(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -102303,7 +103539,7 @@ This searched OpenRouter's listing only. Subscription wire ids and catalog alias
       }
       let version = "unknown";
       try {
-        const pkgPath = join56(__dirname3, "../package.json");
+        const pkgPath = join57(__dirname3, "../package.json");
         if (existsSync39(pkgPath)) {
           version = JSON.parse(readFileSync45(pkgPath, "utf-8")).version;
         }
@@ -102739,6 +103975,65 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
       }
     }
   });
+  tools.push({
+    name: "scroll_session",
+    description: "Scroll a session's transcript view, as a mouse wheel over the child's Claude Code would: the next capture_session shows the child scrolled. `by` is a signed row count (negative = toward older content, positive = toward the live bottom); it is a " + `target, \xB1 1 row, and |by| is capped at ${MAX_SCROLL_ROWS} per call. \`to:"end"\` returns to the live bottom. Give exactly one of \`by\` and \`to\`; \`by:0\` is refused. It never types into the prompt, submits or answers a dialog, and a prompt claudish delivers next returns the view to the bottom first. The answer {session_id, seq} carries the screen's seq after the scroll (the first changed screen within 1 s, else the current one). Errors are a JSON ContractError: \`scroll_unavailable\` while the session is still starting, finished, delivering a prompt, reading its turn from the screen or reconnecting, or when magmux did not confirm the send (the scroll may still land). Nothing is queued.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from create_session" },
+        by: {
+          type: "integer",
+          description: `Rows to scroll; negative = older content. Not 0; |by| capped at ${MAX_SCROLL_ROWS}; a target, \xB1 1 row`
+        },
+        to: {
+          type: "string",
+          enum: ["end"],
+          description: '"end" returns the view to the live bottom'
+        }
+      },
+      required: ["session_id"]
+    },
+    group: "session",
+    handler: async (args) => {
+      try {
+        const sessionId = optionalString(args.session_id, "session_id");
+        if (sessionId === undefined)
+          throw new ContractErrorException("invalid_args", "'session_id' is required");
+        const req = scrollArgs(args);
+        return contractAnswer(await sessionManager.scrollSession(sessionId, req));
+      } catch (e) {
+        return contractErrorAnswer(e);
+      }
+    }
+  });
+  tools.push({
+    name: "transcript_session",
+    description: `Read a session's conversation as plain text lines, from its Claude Code transcript: prompts (\`user\`), replies (\`assistant\`), one line per tool call (\`tool\`, e.g. \`Bash(git status)\`), the content of a prompt delivered as a file (\`task_file\`), notices (\`system\`) and errors (\`error\`). Works while the session runs and after it finished. Page with \`since\`: pass the previous answer's \`cursor\` to get only newer lines; the cursor can move even when no line is returned. At most ${MAX_TRANSCRIPT_LINES} lines (and ${grouped(TRANSCRIPT_ANSWER_MAX_BYTES)} bytes) per call; \`more: true\` means call again now. A text over ${grouped(TRANSCRIPT_LINE_MAX_CHARS)} characters is split into lines marked \`cont: true\`; a \`cont\` chain may continue in the next answer after \`cursor\`, in order, never reordered or lost. \`final: true\` means the session finished, its process exited and every line has been returned; until then keep polling. Read only: it never sends anything to the session. The answer is {session_id, cursor, lines:[{kind, text, cont?}], more, final}. Errors are a JSON ContractError: \`unknown_session\`, \`invalid_args\` (a malformed cursor, or one from another session).`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: { type: "string", description: "Session ID from create_session" },
+        since: {
+          type: "string",
+          description: "The `cursor` of a previous answer; returns only the lines after it. Omit to read from the start. Opaque; valid for this session only."
+        }
+      },
+      required: ["session_id"]
+    },
+    group: "session",
+    handler: async (args) => {
+      try {
+        const sessionId = optionalString(args.session_id, "session_id");
+        if (sessionId === undefined)
+          throw new ContractErrorException("invalid_args", "'session_id' is required");
+        const since = transcriptSince(args.since);
+        return compactAnswer(sessionManager.transcriptSession(sessionId, since));
+      } catch (e) {
+        return contractErrorAnswer(e);
+      }
+    }
+  });
   return tools;
 }
 function resolveToolGroups(mode) {
@@ -102882,7 +104177,7 @@ Each session is an interactive Claude Code running the model in its own headless
 3. send_input may be called at any time; it is queued until the session is idle.
 4. COMPLETED: call get_output for the answer.
 5. FAILED or TIMEOUT \u2014 or COMPLETED with an empty or surprising answer \u2014 call get_diagnostics. It returns the child's final screen, the upstream error bodies, the recent state records, the resolved model chain and the paths to the full records. It needs no re-run and no debug flag.
-6. capture_session reads a session's current screen; resize_session sets its terminal size (any time, mid-turn included); cancel_session stops it. Nothing stops a session for being idle: a child inside a long build is silent and working.
+6. capture_session reads a session's current screen; resize_session sets its terminal size (any time, mid-turn included); scroll_session scrolls the child's transcript view (by rows, or back to the live bottom); transcript_session reads the conversation as text lines (also after the session finished); cancel_session stops it. Nothing stops a session for being idle: a child inside a long build is silent and working.
 
 The session_id from create_session is the key for every session tool.`, proxyInstance = null, proxyStarting = null, SCORE_TIE_EPSILON = 0.000001, NEXT_STEP, KEEP_EFFORT = "default", USER_REQUIRED_MODEL_DESCRIPTION, sanitize2, TOOL_MODES;
 var init_mcp_server = __esm(() => {
@@ -102925,9 +104220,9 @@ var init_mcp_server = __esm(() => {
   init_team_orchestrator();
   init_preflight_chain();
   __filename3 = fileURLToPath3(import.meta.url);
-  __dirname3 = dirname21(__filename3);
-  CLAUDISH_CACHE_DIR = join56(homedir37(), ".claudish");
-  OPENROUTER_MODELS_CACHE_PATH = join56(CLAUDISH_CACHE_DIR, "openrouter-models.json");
+  __dirname3 = dirname22(__filename3);
+  CLAUDISH_CACHE_DIR = join57(homedir37(), ".claudish");
+  OPENROUTER_MODELS_CACHE_PATH = join57(CLAUDISH_CACHE_DIR, "openrouter-models.json");
   NEXT_STEP = {
     cancelled: "you stopped this slot; nothing is wrong with it. Re-run it if you still want its vote",
     timeout: "grid mode only \u2014 magmux ended the pane. The orchestrator has no deadline",
@@ -103056,9 +104351,9 @@ var init_serve_command = __esm(() => {
 var HOOKS_AMBIENT_DTS = '// claudish hook types \u2014 written by `claudish hooks init`. Do not edit: run\n// `claudish hooks init` from a newer claudish to refresh it.\n// With this file beside your hook, `import type { HookDefinition } from\n// "claudish/hooks"` type-checks with nothing installed.\ndeclare module "claudish/hooks" {\n  /**\n   * claudish/hooks \u2014 the public hook contract.\n   *\n   * Everything a hook author can import lives here, and nothing else does. This\n   * file imports nothing from the rest of claudish and has no side effects, so it\n   * can be built on its own into `dist/hooks.js` + `dist/hooks.d.ts` and served to\n   * user modules as the `claudish/hooks` virtual module (see `loader.ts`).\n   *\n   * Every internal hooks module takes its types from here, so the contract has a\n   * single source.\n   *\n   * ## Process isolation\n   *\n   * A hook module\'s top-level state is PER PROCESS. In the interactive launcher,\n   * proxy events (`request` \u2026 `responseEnd`, raw) and session events\n   * (`sessionStart` \u2026 `sessionEnd`) run in one process. In `create_session` and\n   * team children they do not: proxy events run in the pane child, and session\n   * events run in the MCP server or the CLI process that drives the pane. Pass\n   * per-turn data from a proxy event to `sessionIdle` with `annotateTurn`, never\n   * with module variables.\n   *\n   * ## Execution: a hook chain\n   *\n   * The hooks of one event run one after another, in effective order. Each hook\'s\n   * actions are applied before the next hook is called, so `ctx.request`,\n   * `ctx.tool.args` and `ctx.response` show what the earlier hooks did, and\n   * `ctx.prior` lists it. A warn-severity or failing hook changes nothing for the\n   * next one. Each event has a budget for all its hooks together; a hook\'s timeout\n   * is cut to what is left of it.\n   *\n   * ## Output\n   *\n   * Log with `ctx.log`. `console.*` and `process.stdout`/`stderr` writes made by a\n   * hook are routed to claudish\'s debug log, never to the terminal or the MCP\n   * protocol stream.\n   */\n  export const HOOK_API_VERSION = 1;\n  export type Severity = "off" | "warn" | "fix";\n  export type HookOrder = "pre" | "normal" | "post";\n  /** native = RouteInfo.native true; foreign = RouteInfo.native false; all = both */\n  export type RouteScope = "foreign" | "native" | "all";\n  export type HostMode = "interactive" | "pane-child" | "serve" | "mcp" | "other";\n  export type JsonValue = string | number | boolean | null | ReadonlyArray<JsonValue> | {\n      readonly [k: string]: JsonValue;\n  };\n  export interface HarnessFacts {\n      readonly planModeActive: boolean;\n      readonly planFilePath?: string;\n      readonly planDir?: string;\n      /** Claude Code session id from request metadata */\n      readonly sessionId?: string;\n      /** empty = no listing found, not "no skills" */\n      readonly skills?: ReadonlyArray<{\n          name: string;\n          description: string;\n      }>;\n  }\n  export interface RouteInfo {\n      /** bare model name the handler serves, e.g. "glm-5" */\n      readonly modelId: string;\n      /** claudish provider name, e.g. "openrouter"; "anthropic" for native */\n      readonly provider: string;\n      /**\n       * true when the request is served by the native Anthropic handler, OR when\n       *   !forceForeignModel && (/^claude[-.]/i.test(modelId) || provider === "anthropic")\n       * where forceForeignModel is the provider profile\'s opt-in override. This is the exact\n       * rule the plan-mode built-in has always used (a claude-* uid on an aggregator that sets\n       * forceForeignModel is foreign).\n       */\n      readonly native: boolean;\n  }\n  export interface ClaudeTool {\n      name: string;\n      description?: string;\n      input_schema?: unknown;\n  }\n  /** A Claude-format content block. Only `text` blocks are editable by closed actions. */\n  export type ClaudeContentBlock = {\n      type: "text";\n      text: string;\n  } | {\n      type: "tool_use";\n      id: string;\n      name: string;\n      input: unknown;\n  } | {\n      type: "tool_result";\n      tool_use_id: string;\n      content?: unknown;\n      is_error?: boolean;\n  } | {\n      type: "thinking";\n      thinking: string;\n      signature?: string;\n  } | {\n      type: string;\n      [k: string]: unknown;\n  };\n  export interface ClaudeMessage {\n      role: "user" | "assistant";\n      content: string | ReadonlyArray<ClaudeContentBlock>;\n  }\n  /**\n   * In `request`, the request as the earlier steps of the hook chain left it. On\n   * the response side and in `claims()`, the request chain\'s final view.\n   */\n  export interface RequestFacts {\n      /** as Claude Code asked for it; frozen */\n      readonly model: string;\n      /** frozen */\n      readonly stream: boolean;\n      /** system prompt flattened to text, after earlier steps */\n      readonly systemText: string;\n      /** read-only view after earlier steps; change it through actions */\n      readonly messages: ReadonlyArray<ClaudeMessage>;\n      /**\n       * read-only view after earlier steps; `description` includes earlier description actions as\n       * stage B will apply them to the Claude-format tool (the provider copy may be summarised)\n       */\n      readonly tools: ReadonlyArray<ClaudeTool>;\n  }\n  /** Which session a proxy event belongs to, when claudish knows. */\n  export interface ProxySessionRef {\n      readonly kind: SessionKind;\n      readonly id: string;\n      readonly role: "slot" | "judge" | null;\n  }\n  /** One action an earlier step of this hook chain applied or handed on. */\n  export interface PriorAction {\n      readonly hookId: string;\n      readonly action: HookAction;\n  }\n  interface BaseContext {\n      readonly hookId: string;\n      /** "warn" or "fix" (an "off" hook is never called) */\n      readonly severity: Severity;\n      /** writes to claudish\'s debug log; never to the terminal */\n      log(message: string): void;\n      /**\n       * this step\'s own signal: aborted when its step timeout elapses (its own timeout, or the\n       * event budget left, whichever is shorter) or when the dispatch is aborted. Never shared\n       * with another hook\'s step.\n       */\n      readonly signal: AbortSignal;\n      /**\n       * actions earlier steps of this hook chain applied (or, for responseEnd/sessionStart/\n       * sessionIdle, handed on), in order. Empty for the first step and in claims()/the toolCall\n       * predicate. Never lists warn actions or anything a warn-severity hook returned.\n       */\n      readonly prior: ReadonlyArray<PriorAction>;\n  }\n  export interface ProxyContext extends BaseContext {\n      readonly host: {\n          mode: HostMode;\n      };\n      readonly route: RouteInfo;\n      readonly request: RequestFacts;\n      readonly harness: HarnessFacts;\n      readonly session: ProxySessionRef | null;\n  }\n  export interface RequestContext extends ProxyContext {\n      readonly event: "request";\n  }\n  export interface ToolCallContext extends ProxyContext {\n      readonly event: "toolCall";\n      readonly tool: {\n          id: string;\n          name: string;\n          /** the arguments after every repair earlier hooks in the chain applied */\n          args: Readonly<Record<string, unknown>>;\n          /** the argument JSON exactly as the model produced it; never rewritten */\n          rawArgs: string;\n      };\n  }\n  export type ResponseBlock = {\n      type: "text";\n      text: string;\n  } | {\n      type: "thinking";\n      thinking: string;\n  } | {\n      type: "tool_use";\n      id: string;\n      name: string;\n      input: unknown;\n  } | {\n      type: "other";\n      blockType: string;\n  };\n  export interface ResponseView {\n      blocks: ReadonlyArray<ResponseBlock>;\n      /** every text block, joined with "\\n\\n" */\n      text: string;\n      /** every thinking block, joined with "\\n\\n" */\n      reasoning: string;\n      toolNames: ReadonlyArray<string>;\n      /** "tool_use" = an intermediate step of a tool loop; the turn continues after the tool runs */\n      stopReason: string | null;\n  }\n  /** response = the held response after every text action earlier hooks in the chain applied */\n  export interface ResponseRewriteContext extends ProxyContext {\n      readonly event: "responseRewrite";\n      readonly response: ResponseView;\n  }\n  /** response = the final bytes the client received: after any rewrite AND any raw `response` replacement */\n  export interface ResponseEndContext extends ProxyContext {\n      readonly event: "responseEnd";\n      readonly response: ResponseView;\n  }\n  export type SessionKind = "interactive" | "channel" | "team";\n  export interface SessionInfo {\n      kind: SessionKind;\n      /** team only; null otherwise */\n      role: "slot" | "judge" | null;\n      /** channel: the 8-hex session_id \xB7 team: "<run_id>:<slot id>" \xB7 interactive: the Claude Code session id */\n      id: string;\n      claudeSessionId: string | null;\n      /** as the caller asked for it */\n      model: string;\n      cwd: string;\n      /** a one-shot session stays "one-shot" through a hook-extended turn chain */\n      shape: "interactive" | "one-shot";\n      injection: "available" | "unavailable";\n  }\n  export interface SessionStartContext extends BaseContext {\n      readonly event: "sessionStart";\n      readonly session: SessionInfo;\n  }\n  export interface TurnAnnotation {\n      hookId: string;\n      key: string;\n      value: JsonValue;\n  }\n  export interface SessionIdleContext extends BaseContext {\n      readonly event: "sessionIdle";\n      readonly session: SessionInfo;\n      readonly turn: {\n          /** 1-based within the session; a re-woken turn keeps its index */\n          index: number;\n          /** this turn\'s assistant text */\n          answer: string;\n          stopReason: string | null;\n          apiError: boolean;\n          /** this turn was started by an injection */\n          hookCaused: boolean;\n          /** annotateTurn actions from this turn\'s responses, in arrival order */\n          annotations: ReadonlyArray<TurnAnnotation>;\n      };\n      readonly consecutiveHookTurns: number;\n      /** caller/human input is queued; an injection returned now will be dropped as stale */\n      readonly callerInputPending: boolean;\n  }\n  export interface SessionBlockedContext extends BaseContext {\n      readonly event: "sessionBlocked";\n      readonly session: SessionInfo;\n      readonly block: {\n          kind: "question" | "permission";\n          text: string;\n      };\n  }\n  export interface SessionEndContext extends BaseContext {\n      readonly event: "sessionEnd";\n      readonly session: SessionInfo;\n      readonly outcome: {\n          state: string;\n          reason: string | null;\n          exitCode: number | null;\n      };\n  }\n  type TextMatch = {\n      find: string;\n      regex?: boolean;\n      flags?: string;\n  };\n  /** default ["user"] */\n  type MessageRoles = {\n      roles?: ReadonlyArray<"user" | "assistant">;\n  };\n  export type InjectSystemNote = {\n      type: "injectSystemNote";\n      text: string;\n  };\n  export type AppendUserText = {\n      type: "appendUserText";\n      text: string;\n  };\n  export type ReplaceMessageText = {\n      type: "replaceMessageText";\n      replace: string;\n  } & TextMatch & MessageRoles;\n  export type RemoveMessageText = {\n      type: "removeMessageText";\n  } & TextMatch & MessageRoles;\n  export type RewriteToolDescription = {\n      type: "rewriteToolDescription";\n      tool: string;\n      append: string;\n  };\n  export type ReplaceToolDescription = {\n      type: "replaceToolDescription";\n      tool: string;\n      description: string;\n  };\n  export type ReplaceToolSchema = {\n      type: "replaceToolSchema";\n      tool: string;\n      inputSchema: {\n          type: "object";\n          [k: string]: unknown;\n      };\n  };\n  export type RemoveTool = {\n      type: "removeTool";\n      tool: string;\n  };\n  export type RepairToolArgs = {\n      type: "repairToolArgs";\n      args: Record<string, unknown>;\n      reason: string;\n  };\n  export type AppendText = {\n      type: "appendText";\n      text: string;\n  };\n  export type PrependText = {\n      type: "prependText";\n      text: string;\n  };\n  export type ReplaceText = {\n      type: "replaceText";\n      replace: string;\n  } & TextMatch;\n  export type RemoveText = {\n      type: "removeText";\n  } & TextMatch;\n  export type InjectUserTurn = {\n      type: "injectUserTurn";\n      text: string;\n  };\n  export type AnnotateTurn = {\n      type: "annotateTurn";\n      key: string;\n      value: JsonValue;\n  };\n  export type Warn = {\n      type: "warn";\n      message: string;\n  };\n  export type RequestAction = InjectSystemNote | AppendUserText | ReplaceMessageText | RemoveMessageText | RewriteToolDescription | ReplaceToolDescription | ReplaceToolSchema | RemoveTool | Warn;\n  export type ToolCallAction = RepairToolArgs | Warn;\n  export type RewriteAction = AppendText | PrependText | ReplaceText | RemoveText | Warn;\n  export type ResponseEndAction = InjectSystemNote | InjectUserTurn | AnnotateTurn | Warn;\n  export type SessionAction = InjectUserTurn | Warn;\n  export type ObserveAction = Warn;\n  export type HookAction = RequestAction | ToolCallAction | RewriteAction | ResponseEndAction | SessionAction;\n  export type HookResult<A> = A[] | void | Promise<A[] | void>;\n  export interface HookHandlers {\n      request?(ctx: RequestContext): HookResult<RequestAction>;\n      toolCall?: {\n          /** tool names whose completed arguments this hook sees; "*" = every tool (costs streaming of all tool input) */\n          tools: ReadonlyArray<string>;\n          /** synchronous, per request; default true. false = not armed for this request */\n          armed?(ctx: RequestContext): boolean;\n          /** true = see the call after it was forwarded; can only warn; never holds the stream */\n          observe?: boolean;\n          handle(ctx: ToolCallContext): HookResult<ToolCallAction>;\n      };\n      responseRewrite?: {\n          /** synchronous, per request, evaluated before the response starts; default true */\n          claims?(ctx: RequestContext): boolean;\n          handle(ctx: ResponseRewriteContext): HookResult<RewriteAction>;\n      };\n      responseEnd?(ctx: ResponseEndContext): HookResult<ResponseEndAction>;\n      sessionStart?(ctx: SessionStartContext): HookResult<SessionAction>;\n      sessionIdle?(ctx: SessionIdleContext): HookResult<SessionAction>;\n      sessionBlocked?(ctx: SessionBlockedContext): HookResult<ObserveAction>;\n      sessionEnd?(ctx: SessionEndContext): HookResult<ObserveAction>;\n  }\n  export interface RawProviderRequestContext {\n      readonly hookId: string;\n      readonly route: RouteInfo;\n      claudeRequest: any;\n      messages: any[];\n      tools: any[];\n  }\n  export interface RawProviderChunkContext {\n      readonly hookId: string;\n      readonly route: RouteInfo;\n      /** A clone of the parsed provider event. Whatever this field holds when the call returns is\n       *  what the parser reads from then on, so it may be edited in place or replaced. */\n      chunk: any;\n      /** The delta object inside `chunk` at call time (Responses wire: `chunk` itself). Edit it in\n       *  place; assigning a new object to this field has no effect. */\n      delta: any;\n      /** per-stream, shared across this hook\'s chunk calls; never cloned */\n      metadata: Map<string, unknown>;\n  }\n  export interface RawProviderStreamEndContext {\n      readonly hookId: string;\n      readonly route: RouteInfo;\n      metadata: Map<string, unknown>;\n  }\n  export interface RawResponseContext {\n      readonly hookId: string;\n      readonly route: RouteInfo;\n      readonly request: RequestFacts;\n      /** A replay of the current Claude-format response (SSE, or JSON for stream:false), read at the\n       *  hook\'s own pace. claudish drains the original itself, so leaving this unread delays nothing. */\n      response: Response;\n  }\n  export interface RawMiddleware {\n      /**\n       * Receives clones. They replace the live request only when this call returns (or its promise\n       * resolves) within its timeout. A throw, a rejection or a timeout discards every change.\n       */\n      providerRequest?(ctx: RawProviderRequestContext): void | Promise<void>;\n      /**\n       * MUST be synchronous. Called on the parser\'s loop, on a clone of the chunk. On a normal return\n       * of anything but a thenable, the clone (whatever `ctx.chunk` holds then) is committed: it\n       * becomes the object the parser reads, deletions included. On a throw nothing is committed.\n       * A declared `async` function is rejected at load. Any other thenable return is an invalid\n       * invocation: the clone is discarded even if the hook mutated it before returning, the call is\n       * journaled `invalid` (`async_return`) and counts toward the circuit breaker, and a rejection\n       * handler is attached, so a rejection is journaled `error` and never becomes an\n       * unhandledRejection.\n       */\n      providerChunk?(ctx: RawProviderChunkContext): void;\n      providerStreamEnd?(ctx: RawProviderStreamEndContext): void | Promise<void>;\n      /**\n       * Return a replacement Response, or nothing to keep the current one. A replacement is read\n       * whole and forwarded only when it completes cleanly; on any failure the original is forwarded.\n       * The client never sees a partial replacement. A replacement must close within this hook\'s\n       * timeout after the later of this call\'s return and the end of the original; the original\'s end\n       * never depends on whether `ctx.response` is read.\n       */\n      response?(ctx: RawResponseContext): Response | void | Promise<Response | void>;\n  }\n  interface HookBase {\n      apiVersion: 1;\n      id: string;\n      description?: string;\n      /** default "fix" for user hooks */\n      defaultSeverity?: Severity;\n      /** default "normal" */\n      order?: HookOrder;\n      /** globs on RouteInfo.modelId; default "*"; proxy events only */\n      models?: string | ReadonlyArray<string>;\n      /** default "all"; proxy events only */\n      routes?: RouteScope;\n      /** per call; clamped to the event\'s maximum and to the event budget left when the hook\'s turn comes */\n      timeoutMs?: number;\n      on?: HookHandlers;\n  }\n  export interface SafeHook extends HookBase {\n      unsafe?: never;\n      raw?: never;\n  }\n  export interface UnsafeHook extends HookBase {\n      unsafe: true;\n      raw: RawMiddleware;\n  }\n  /**\n   * One hook. Module-level state is per process: in `create_session` and team\n   * children, proxy events run in the pane child and session events in the MCP\n   * server or CLI process. Pass per-turn data from proxy events to `sessionIdle`\n   * with `annotateTurn`, never with module variables.\n   */\n  export type HookDefinition = SafeHook | UnsafeHook;\n  /** Identity function: gives editor type-checking and inference. */\n  export function defineHook<const H extends HookDefinition>(hook: H): H;\n  /** Action constructors (plain data; equivalent to writing the object literal). */\n  export const act: {\n      injectSystemNote(text: string): InjectSystemNote;\n      appendUserText(text: string): AppendUserText;\n      replaceMessageText(find: string, replace: string, opts?: {\n          regex?: boolean;\n          flags?: string;\n          roles?: ReadonlyArray<"user" | "assistant">;\n      }): ReplaceMessageText;\n      removeMessageText(find: string, opts?: {\n          regex?: boolean;\n          flags?: string;\n          roles?: ReadonlyArray<"user" | "assistant">;\n      }): RemoveMessageText;\n      rewriteToolDescription(tool: string, append: string): RewriteToolDescription;\n      replaceToolDescription(tool: string, description: string): ReplaceToolDescription;\n      replaceToolSchema(tool: string, inputSchema: {\n          type: "object";\n          [k: string]: unknown;\n      }): ReplaceToolSchema;\n      removeTool(tool: string): RemoveTool;\n      repairToolArgs(args: Record<string, unknown>, reason: string): RepairToolArgs;\n      appendText(text: string): AppendText;\n      prependText(text: string): PrependText;\n      replaceText(find: string, replace: string, opts?: {\n          regex?: boolean;\n          flags?: string;\n      }): ReplaceText;\n      removeText(find: string, opts?: {\n          regex?: boolean;\n          flags?: string;\n      }): RemoveText;\n      injectUserTurn(text: string): InjectUserTurn;\n      annotateTurn(key: string, value: JsonValue): AnnotateTurn;\n      warn(message: string): Warn;\n  };\n}\n';
 
 // src/hooks/observer/corpus.ts
-import { appendFileSync as appendFileSync8, readFileSync as readFileSync47, readdirSync as readdirSync11, statSync as statSync20 } from "fs";
+import { appendFileSync as appendFileSync8, readFileSync as readFileSync47, readdirSync as readdirSync12, statSync as statSync21 } from "fs";
 import { homedir as homedir38 } from "os";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 function directoryOf2(filePath) {
   const slash = filePath.lastIndexOf("/");
   return slash > 0 ? filePath.slice(0, slash) : undefined;
@@ -103132,31 +104427,31 @@ function listTranscripts(root) {
   const files = [];
   let projects;
   try {
-    projects = readdirSync11(root);
+    projects = readdirSync12(root);
   } catch {
     return files;
   }
   for (const project of projects) {
-    const dir = join57(root, project);
+    const dir = join58(root, project);
     try {
-      if (!statSync20(dir).isDirectory())
+      if (!statSync21(dir).isDirectory())
         continue;
-      for (const f of readdirSync11(dir)) {
+      for (const f of readdirSync12(dir)) {
         if (f.endsWith(".jsonl"))
-          files.push(join57(dir, f));
+          files.push(join58(dir, f));
       }
     } catch {}
   }
   return files;
 }
 function buildCorpus(options = {}) {
-  const root = options.projectsRoot ?? join57(homedir38(), ".claude", "projects");
+  const root = options.projectsRoot ?? join58(homedir38(), ".claude", "projects");
   const files = listTranscripts(root);
   const records = [];
   for (const f of files)
     records.push(...replayTranscript(f));
   if (options.write && records.length > 0) {
-    const outputPath = options.outputPath ?? join57(homedir38(), ".claudish", "behavior-divergences.jsonl");
+    const outputPath = options.outputPath ?? join58(homedir38(), ".claudish", "behavior-divergences.jsonl");
     try {
       appendFileSync8(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -103174,7 +104469,7 @@ var init_corpus = __esm(() => {
 // src/hooks-command.ts
 import { existsSync as existsSync41, mkdirSync as mkdirSync27, readFileSync as readFileSync48, writeFileSync as writeFileSync25 } from "fs";
 import { homedir as homedir39 } from "os";
-import { join as join58, resolve as resolve9 } from "path";
+import { join as join59, resolve as resolve9 } from "path";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -103297,10 +104592,10 @@ async function check(file, json) {
   return valid ? 0 : 1;
 }
 function init(dirArg) {
-  const dir = dirArg ? resolve9(process.cwd(), dirArg) : join58(homedir39(), ".claudish", "hooks");
+  const dir = dirArg ? resolve9(process.cwd(), dirArg) : join59(homedir39(), ".claudish", "hooks");
   const files = [
-    [join58(dir, "example-hook.ts"), EXAMPLE_HOOK],
-    [join58(dir, "claudish-hooks.d.ts"), HOOKS_AMBIENT_DTS]
+    [join59(dir, "example-hook.ts"), EXAMPLE_HOOK],
+    [join59(dir, "claudish-hooks.d.ts"), HOOKS_AMBIENT_DTS]
   ];
   const existing = files.filter(([path]) => existsSync41(path)).map(([path]) => path);
   if (existing.length > 0) {
@@ -103503,7 +104798,7 @@ var init_hooks_command = __esm(() => {
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync42, readFileSync as readFileSync49, writeFileSync as writeFileSync26 } from "fs";
 import { connect as netConnect2 } from "net";
-import { join as join59 } from "path";
+import { join as join60 } from "path";
 import { setTimeout as wait } from "timers/promises";
 function paneRouteLine(explanation) {
   const origin = describeRouteExplanation(explanation);
@@ -103653,9 +104948,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join59(sessionPath, "gridfile.txt");
-  const prompt = readFileSync49(join59(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync49(join59(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join60(sessionPath, "gridfile.txt");
+  const prompt = readFileSync49(join60(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync49(join60(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const routeLines = mode === "interactive" ? new Map : await resolvePaneRouteLines(Object.values(manifest.models).map((entry) => entry.model));
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
@@ -103687,7 +104982,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join59(sessionPath, "status.json");
+  const statusPath = join60(sessionPath, "status.json");
   writeFileSync26(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -103708,7 +105003,7 @@ var init_team_grid = __esm(() => {
 
 // src/team-cli.ts
 import { readFileSync as readFileSync50 } from "fs";
-import { join as join60 } from "path";
+import { join as join61 } from "path";
 async function runPaneTeam(sessionPath, models, input, opts) {
   installPaneShutdownHooks({ exitAfter: true });
   try {
@@ -103853,7 +105148,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync50(join60(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync50(join61(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -103869,7 +105164,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync50(join60(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync50(join61(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -105797,7 +107092,7 @@ var init_account_command = __esm(() => {
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync43, unlinkSync as unlinkSync12 } from "fs";
 import { homedir as homedir40 } from "os";
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 async function defaultSuggestModel() {
   try {
     const token = await getValidAntigravityAccessToken();
@@ -105916,7 +107211,7 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join61(homedir40(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      const tokenFile = join62(homedir40(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
       if (existsSync43(tokenFile))
         unlinkSync12(tokenFile);
     } catch {}
@@ -114194,8 +115489,8 @@ var init_own_pane = __esm(() => {
 });
 
 // src/hooks/session/interactive-driver.ts
-import { existsSync as existsSync44, statSync as statSync21 } from "fs";
-import { join as join62 } from "path";
+import { existsSync as existsSync44, statSync as statSync22 } from "fs";
+import { join as join63 } from "path";
 function nextDriverPhase(phase, ev) {
   const row = EDGES[phase];
   return row[ev] ?? null;
@@ -114413,7 +115708,7 @@ class InteractiveDriver {
   }
   follow(sid, offset) {
     const path = transcriptPathFor(this.o.cwd, sid, this.o.projectsRoot);
-    this.follower = new TranscriptFollower(path, join62(path.replace(/\.jsonl$/, ""), "subagents"));
+    this.follower = new TranscriptFollower(path, join63(path.replace(/\.jsonl$/, ""), "subagents"));
     this.sessionId = sid;
     this.settledTurn = null;
     this.lastPollAt = Date.now();
@@ -114958,7 +116253,7 @@ function assertNeverPhase(p) {
 }
 function fileSizeOf(path) {
   try {
-    return statSync21(path).size;
+    return statSync22(path).size;
   } catch {
     return 0;
   }
@@ -115515,20 +116810,20 @@ import { spawn as spawn4, spawnSync as spawnSync4 } from "child_process";
 import { randomUUID as randomUUID11 } from "crypto";
 import {
   chmodSync as chmodSync5,
-  closeSync as closeSync14,
+  closeSync as closeSync15,
   existsSync as existsSync46,
   mkdirSync as mkdirSync28,
   mkdtempSync as mkdtempSync4,
-  openSync as openSync14,
+  openSync as openSync15,
   readFileSync as readFileSync51,
-  readdirSync as readdirSync12,
+  readdirSync as readdirSync13,
   rmSync as rmSync15,
-  statSync as statSync22,
+  statSync as statSync23,
   unlinkSync as unlinkSync13,
   writeFileSync as writeFileSync27
 } from "fs";
 import { homedir as homedir42, tmpdir as tmpdir3 } from "os";
-import { dirname as dirname22, join as join63 } from "path";
+import { dirname as dirname23, join as join64 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -115600,7 +116895,7 @@ function hasResolvableAnthropicAuth(deps = {}) {
   if (isRealAnthropicEnvCredential(env, "ANTHROPIC_API_KEY") || isRealAnthropicEnvCredential(env, "ANTHROPIC_AUTH_TOKEN")) {
     return true;
   }
-  if (fileExists(join63(homedir42(), ".claude", ".credentials.json")))
+  if (fileExists(join64(homedir42(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
 }
@@ -115700,10 +116995,10 @@ function readableClaudeSettingsLayers(config, env, deps) {
   const cwd = deps.cwd ?? process.cwd();
   const files = [
     managedSettingsPath(),
-    join63(home, ".claude", "settings.json"),
-    ...env.CLAUDE_CONFIG_DIR ? [join63(env.CLAUDE_CONFIG_DIR, "settings.json")] : [],
-    join63(cwd, ".claude", "settings.json"),
-    join63(cwd, ".claude", "settings.local.json")
+    join64(home, ".claude", "settings.json"),
+    ...env.CLAUDE_CONFIG_DIR ? [join64(env.CLAUDE_CONFIG_DIR, "settings.json")] : [],
+    join64(cwd, ".claude", "settings.json"),
+    join64(cwd, ".claude", "settings.local.json")
   ];
   const layers = [];
   for (const file of files) {
@@ -115735,7 +117030,7 @@ function readSettingsSource(source, readFile) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join63(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join64(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
@@ -115756,8 +117051,8 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir3();
-  const claudishDir = join63(homeDir, ".claudish");
-  const scriptPath = join63(claudishDir, `status-${process.pid}-${Date.now()}.js`);
+  const claudishDir = join64(homeDir, ".claudish");
+  const scriptPath = join64(claudishDir, `status-${process.pid}-${Date.now()}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const light = getThemeMode() === "light";
   const cyanCode = light ? "38;2;14;116;144" : "96";
@@ -115917,7 +117212,7 @@ process.stdin.on('end', () => {
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync28(dirname22(tokenFilePath), { recursive: true });
+    mkdirSync28(dirname23(tokenFilePath), { recursive: true });
     writeFileSync27(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
@@ -115937,7 +117232,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
   let removed = 0;
   let entries;
   try {
-    entries = readdirSync12(dir);
+    entries = readdirSync13(dir);
   } catch {
     return 0;
   }
@@ -115949,9 +117244,9 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join63(dir, name);
+    const full = join64(dir, name);
     try {
-      if (statSync22(full).mtimeMs >= cutoff)
+      if (statSync23(full).mtimeMs >= cutoff)
         continue;
       unlinkSync13(full);
       removed++;
@@ -115978,9 +117273,9 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join63(homedir42(), ".claude", "settings.json"),
-    join63(cwd, ".claude", "settings.json"),
-    join63(cwd, ".claude", "settings.local.json")
+    join64(homedir42(), ".claude", "settings.json"),
+    join64(cwd, ".claude", "settings.json"),
+    join64(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
@@ -116021,11 +117316,11 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir3();
-  const claudishDir = join63(homeDir, ".claudish");
+  const claudishDir = join64(homeDir, ".claudish");
   try {
     mkdirSync28(claudishDir, { recursive: true });
   } catch {}
-  const tempPath = join63(claudishDir, `settings-${process.pid}-${Date.now()}.json`);
+  const tempPath = join64(claudishDir, `settings-${process.pid}-${Date.now()}.json`);
   const assignedFile = assignedTokenFile(process.env) !== null;
   const tokenFilePath = resolveTokenFilePath(port);
   cleanupStaleTokenFiles(claudishDir);
@@ -116084,6 +117379,7 @@ function buildClaudishSettingsOverlay(statusLine, proxyAuthMode, paneChild = isP
   if (paneChild) {
     settings.skipDangerousModePermissionPrompt = true;
     settings.editorMode = "normal";
+    settings.wheelScrollAccelerationEnabled = false;
   }
   return settings;
 }
@@ -116108,6 +117404,9 @@ function mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyA
     if (paneChild) {
       userSettings.editorMode = "normal";
     }
+    if (paneChild) {
+      userSettings.wheelScrollAccelerationEnabled = false;
+    }
     chmodSync5(tempSettingsPath, 384);
     writeFileSync27(tempSettingsPath, JSON.stringify(userSettings, null, 2), {
       encoding: "utf-8",
@@ -116412,7 +117711,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir42();
-    const localPath = isWindows2() ? join63(home, ".claude", "local", "claude.exe") : join63(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join64(home, ".claude", "local", "claude.exe") : join64(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -116423,11 +117722,11 @@ Or set CLAUDE_PATH to your custom installation:`);
   const childWantsTty = config.interactive && !process.stdout.isTTY && Boolean(process.stdin.isTTY);
   if (childWantsTty) {
     try {
-      const fd = openSync14("/dev/fd/0", "r+");
+      const fd = openSync15("/dev/fd/0", "r+");
       if (isatty(fd)) {
         ttyFd = fd;
       } else {
-        closeSync14(fd);
+        closeSync15(fd);
       }
     } catch {
       ttyFd = undefined;
@@ -116447,7 +117746,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   let driverLaunch = null;
   if (surfaces.driver) {
     const minted = sessionFlags.sessionId || sessionFlags.resumes ? null : randomUUID11();
-    const turnDir = mkdtempSync4(join63(tmpdir3(), "claudish-turns-"));
+    const turnDir = mkdtempSync4(join64(tmpdir3(), "claudish-turns-"));
     chmodSync5(turnDir, 448);
     claudeArgs.unshift(...driverLeadingArgs({ mintedSessionId: minted, turnDir }));
     const sink = new InProcessSink;
@@ -116530,7 +117829,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     const fdToClose = ttyFd;
     proc.on("spawn", () => {
       try {
-        closeSync14(fdToClose);
+        closeSync15(fdToClose);
       } catch {}
     });
   }
@@ -116596,15 +117895,15 @@ async function findClaudeBinary() {
     }
   }
   const home = homedir42();
-  const localPath = isWindows ? join63(home, ".claude", "local", "claude.exe") : join63(home, ".claude", "local", "claude");
+  const localPath = isWindows ? join64(home, ".claude", "local", "claude.exe") : join64(home, ".claude", "local", "claude");
   if (existsSync46(localPath)) {
     return localPath;
   }
   if (isWindows) {
     const windowsPaths = [
-      join63(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join63(home, ".npm-global", "claude.cmd"),
-      join63(home, "node_modules", ".bin", "claude.cmd")
+      join64(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join64(home, ".npm-global", "claude.cmd"),
+      join64(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path of windowsPaths) {
       if (existsSync46(path)) {
@@ -116615,11 +117914,11 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join63(home, ".npm-global/bin/claude"),
-      join63(home, ".local/bin/claude"),
-      join63(home, "node_modules/.bin/claude"),
+      join64(home, ".npm-global/bin/claude"),
+      join64(home, ".local/bin/claude"),
+      join64(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join63(home, "../usr/bin/claude")
+      join64(home, "../usr/bin/claude")
     ];
     for (const path of commonPaths) {
       if (existsSync46(path)) {
@@ -116728,16 +118027,16 @@ var init_claude_runner = __esm(() => {
 // src/diag-output.ts
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync29, unlinkSync as unlinkSync14, writeFileSync as writeFileSync28 } from "fs";
 import { homedir as homedir43 } from "os";
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 function getClaudishDir() {
-  const dir = join64(homedir43(), ".claudish");
+  const dir = join65(homedir43(), ".claudish");
   try {
     mkdirSync29(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join64(getClaudishDir(), `diag-${process.pid}.log`);
+  return join65(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -117302,7 +118601,7 @@ var init_advisor_startup = __esm(() => {
 });
 
 // src/session/conversation.ts
-import { closeSync as closeSync15, openSync as openSync15, readSync as readSync7, statSync as statSync23 } from "fs";
+import { closeSync as closeSync16, openSync as openSync16, readSync as readSync8, statSync as statSync24 } from "fs";
 import { StringDecoder } from "string_decoder";
 function looksLikeTurn(line) {
   const assistant = line.includes('"type":"assistant"');
@@ -117357,8 +118656,8 @@ function readConversation(file, opts = {}) {
   };
   let fd = null;
   try {
-    const size = statSync23(file).size;
-    fd = openSync15(file, "r");
+    const size = statSync24(file).size;
+    fd = openSync16(file, "r");
     const buf = Buffer.allocUnsafe(chunkBytes);
     const decoder = new StringDecoder("utf-8");
     let pending = "";
@@ -117390,7 +118689,7 @@ function readConversation(file, opts = {}) {
       take({ role: raw.role, text, elided });
     };
     while (pos < size) {
-      const n = readSync7(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
+      const n = readSync8(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
       if (n <= 0)
         break;
       pos += n;
@@ -117414,7 +118713,7 @@ function readConversation(file, opts = {}) {
   } catch {} finally {
     if (fd !== null) {
       try {
-        closeSync15(fd);
+        closeSync16(fd);
       } catch {}
     }
   }
@@ -119399,7 +120698,7 @@ init_op_source();
 init_startup_trace();
 init_picker_cancelled();
 import { existsSync as existsSync47, readFileSync as readFileSync53 } from "fs";
-import { join as join65, resolve as resolve11 } from "path";
+import { join as join66, resolve as resolve11 } from "path";
 
 // src/tui/runtime/should-open-picker.ts
 function noModelConfigured(gate) {
@@ -119416,7 +120715,7 @@ function requiresExplicitModel(gate, tty) {
 var autoloadDropped = [...droppedAtLaunch, ...takeLauncherDropped(process.env)];
 var dotenvText;
 try {
-  dotenvText = readFileSync53(join65(process.cwd(), ".env"));
+  dotenvText = readFileSync53(join66(process.cwd(), ".env"));
 } catch {}
 if (dotenvText !== undefined) {
   await Promise.resolve().then(() => init_dotenv_allowlist());
@@ -119764,7 +121063,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join65(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join66(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         await Promise.resolve().then(() => init_pane());
         await Promise.resolve().then(() => init_team_orchestrator());
@@ -119784,7 +121083,7 @@ async function runCli() {
         const status = await runModels(sessionPath);
         const result = { ...status, responses: {} };
         for (const anonId of Object.keys(status.models)) {
-          const responsePath = join65(sessionPath, `response-${anonId}.md`);
+          const responsePath = join66(sessionPath, `response-${anonId}.md`);
           try {
             const raw = readFileSync53(responsePath, "utf-8").trim();
             try {