claudish 14.10.2 → 14.12.0

package/dist/index.js

@@ -5491,7 +5491,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.10.2";
+var VERSION = "14.12.0";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -26267,6 +26267,7 @@ var init_antigravity_token = __esm(() => {
 var exports_antigravity_user = {};
 __export(exports_antigravity_user, {
   antigravityHost: () => antigravityHost,
+  antigravityUserAgentFor: () => antigravityUserAgentFor,
   buildAntigravityUserAgent: () => buildAntigravityUserAgent,
   fetchAntigravityAvailableModelsRaw: () => fetchAntigravityAvailableModelsRaw,
   getAntigravityTierDisplayName: () => getAntigravityTierDisplayName,
@@ -26299,6 +26300,9 @@ function antigravityClientVersion() {
 function userAgentFor(version) {
   return `antigravity/cli/${version} (aidev_client; os_type=${process.platform}; arch=${process.arch}; auth_method=consumer)`;
 }
+function antigravityUserAgentFor(version) {
+  return userAgentFor(version);
+}
 function buildAntigravityUserAgent() {
   return userAgentFor(antigravityClientVersion());
 }
@@ -73044,7 +73048,8 @@ var init_contract = __esm(() => {
     "capture_since_seq",
     "capture_spans",
     "resize",
-    "allowance"
+    "allowance",
+    "scroll"
   ];
   SLOT_STATES = [
     "STARTING",
@@ -90429,6 +90434,10 @@ ${h("SUBCOMMANDS")}
   ${green("claudish subscription models antigravity")} ${yellow("--raw --json")}
                                           Print the raw Antigravity fetchAvailableModels
                                           ${dim("body as one JSON line (for models-index)")}
+  ${green("claudish subscription probe antigravity")} ${yellow("--model <id> --request-file <path> --raw --json")}
+                                          Send the file's Gemini request once through the
+                                          Antigravity login (generateContent, no retry, model
+                                          ${dim("id unchanged); print the raw answer as one JSON line")}
   ${green("claudish update")}                        Check for updates and install the latest version
 
   ${bold("Profiles:")}
@@ -93465,6 +93474,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";
@@ -94609,6 +94651,9 @@ class PaneSessionImpl {
   resizeQuietFrom = 0;
   resizeQuietUntil = 0;
   activityChangedAt = 0;
+  scrollPos = LIVE_BOTTOM;
+  scrollEndsInFlight = 0;
+  scrollEndConfirmedAt = 0;
   gate = null;
   gateTrusted = false;
   gateInFlight = false;
@@ -95399,8 +95444,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")
@@ -95412,8 +95457,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;
@@ -95838,6 +95897,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;
@@ -95914,6 +95974,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,
@@ -96391,11 +96452,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";
@@ -96410,7 +96481,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))
@@ -96741,6 +96812,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)
@@ -96993,7 +97127,8 @@ function newAdmission(a) {
     clearAfter: 0,
     lostType: null,
     last: null,
-    noted: new Set
+    noted: new Set,
+    liveBottomClient: null
   };
 }
 function markClearFirst(adm) {
@@ -97160,7 +97295,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();
@@ -97177,6 +97312,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();
@@ -97231,6 +97367,7 @@ var init_pane = __esm(() => {
   init_pane_launch();
   init_pane_registry();
   init_pane_session();
+  init_scroll_input();
   init_contract();
 });
 
@@ -97959,6 +98096,20 @@ 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 teamLiveMaps(path, runId) {
   const run = addressRun(path, runId);
   if (!run)
@@ -99999,6 +100150,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)
@@ -100434,7 +100594,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, 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.
@@ -101531,6 +101691,22 @@ 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 teamStatusAnswer(path, runId) {
   let row = null;
   if (runId) {
@@ -101575,6 +101751,7 @@ async function teamContractVerb(mode, args) {
     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;
     switch (mode) {
       case "status":
         return contractAnswer(teamStatusAnswer(path, runId));
@@ -101590,6 +101767,11 @@ async function teamContractVerb(mode, args) {
           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));
+      }
     }
   } catch (e) {
     return contractErrorAnswer(e);
@@ -101937,18 +102119,28 @@ 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), '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"
+          ],
+          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`). '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' and 'scroll': the anonymised slot id (e.g. '02') from the slot map 'run' returned. 'capture', 'resize' and 'scroll' require it; for 'cancel', omit it to stop every slot in the run."
         },
         path: {
           type: "string",
@@ -101956,7 +102148,7 @@ 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' and 'scroll': 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",
@@ -101974,6 +102166,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" },
@@ -102030,7 +102231,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") {
         return teamContractVerb(mode, args);
       }
       try {
@@ -102731,6 +102932,38 @@ 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);
+      }
+    }
+  });
   return tools;
 }
 function resolveToolGroups(mode) {
@@ -102874,7 +103107,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); 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(() => {
@@ -104456,68 +104689,20 @@ var init_keychain_command = __esm(() => {
   VALUE_FLAGS = new Set(["--config", "--from", "--only"]);
 });
 
-// src/subscription-models-command.ts
-var exports_subscription_models_command = {};
-__export(exports_subscription_models_command, {
-  EXIT: () => EXIT,
-  FAILURE_CODES: () => FAILURE_CODES,
-  INTERNAL_ERROR_MESSAGE: () => INTERNAL_ERROR_MESSAGE,
-  SECRET_GUARD_MESSAGE: () => SECRET_GUARD_MESSAGE,
-  SUBSCRIPTION_MODELS_USAGE: () => SUBSCRIPTION_MODELS_USAGE,
-  SUBSCRIPTION_MODEL_LIST_SCHEMA: () => SUBSCRIPTION_MODEL_LIST_SCHEMA,
-  defaultSubscriptionModelsDeps: () => defaultSubscriptionModelsDeps,
-  exitCodeFor: () => exitCodeFor,
-  parseSubscriptionModelsArgs: () => parseSubscriptionModelsArgs,
-  reportSubscriptionInternalError: () => reportSubscriptionInternalError,
-  runAntigravityRawModelList: () => runAntigravityRawModelList,
-  subscriptionModelsCommand: () => subscriptionModelsCommand
-});
-function exitCodeFor(failure) {
-  if (failure.class === "internal")
-    return failure.code === "usage" ? EXIT.usage : EXIT.internal;
-  return EXIT[failure.class];
-}
-function defaultSubscriptionModelsDeps() {
-  return {
-    platform: () => process.platform,
-    readStore: readAntigravityStoreClassified,
-    tokenDeps: defaultAntigravityTokenDeps,
-    now: () => Date.now(),
-    httpTimeoutMs: 30000,
-    keychainDeadlineMs: 1e4,
-    writeStdout: (line) => new Promise((resolve, reject) => {
-      process.stdout.write(line, (err) => err ? reject(err) : resolve());
-    }),
-    writeStderr: (line) => {
-      process.stderr.write(line);
-    }
-  };
-}
-function parseSubscriptionModelsArgs(argv) {
-  const positionals = argv.filter((a) => !a.startsWith("-"));
-  const flags = argv.filter((a) => a.startsWith("-"));
-  const positionalsOk = positionals.length === 2 && positionals[0] === "models" && positionals[1] === "antigravity";
-  const flagsOk = flags.length === 2 && flags.includes("--raw") && flags.includes("--json");
-  return positionalsOk && flagsOk ? { ok: true, provider: "antigravity" } : { ok: false };
+// src/subscription-antigravity-session.ts
+function newSecrets() {
+  return { values: new Set };
 }
 function addSecret(secrets, value) {
   if (typeof value === "string" && value.length > 0)
     secrets.values.add(value);
 }
-function buildEnvelope(facts, failure, body) {
-  return {
-    schema: SUBSCRIPTION_MODEL_LIST_SCHEMA,
-    ...facts.provider !== undefined ? { provider: facts.provider } : {},
-    claudishVersion: VERSION,
-    ...facts.fetchedAt !== undefined ? { fetchedAt: facts.fetchedAt } : {},
-    ...facts.sourceUrl !== undefined ? { sourceUrl: facts.sourceUrl } : {},
-    ...facts.clientVersion !== undefined ? { clientVersion: facts.clientVersion } : {},
-    ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
-    tokenRefreshed: facts.tokenRefreshed,
-    ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
-    ...failure ? { failure } : {},
-    ...body !== undefined ? { body } : {}
-  };
+function containsSecret(secrets, ...texts) {
+  for (const secret of secrets.values) {
+    if (texts.some((text) => text?.includes(secret)))
+      return true;
+  }
+  return false;
 }
 function failureOf2(cls, code, httpStatus) {
   return { class: cls, code, ...httpStatus !== undefined ? { httpStatus } : {} };
@@ -104532,6 +104717,19 @@ function stripUserinfo(url) {
     return url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^@/]*@/i, "$1");
   }
 }
+async function raceTimeout(work, ms) {
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMED_OUT), ms);
+  });
+  work.catch(() => {});
+  try {
+    return await Promise.race([work, timedOut]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 function storeReadFailure(read) {
   switch (read.kind) {
     case "absent":
@@ -104574,29 +104772,171 @@ function loadCodeAssistFailure(err) {
     return failureOf2("mint_failed", "load_code_assist_no_project");
   return failureOf2("network", "load_code_assist_network_error");
 }
+async function obtainAccessToken(deps, facts, secrets, preRaw) {
+  const base = deps.tokenDeps();
+  let firstRead = true;
+  let refreshCalled = false;
+  let refreshOutcome = null;
+  const laterReads = [];
+  const observed = {
+    ...base,
+    readStore: () => {
+      if (firstRead) {
+        firstRead = false;
+        return preRaw;
+      }
+      const raw = base.readStore();
+      if (raw)
+        laterReads.push(raw);
+      return raw;
+    },
+    runAgyRefresh: () => {
+      refreshCalled = true;
+      facts.tokenRefreshed = true;
+      refreshOutcome = base.runAgyRefresh();
+      return refreshOutcome;
+    }
+  };
+  let accessToken;
+  try {
+    accessToken = await getValidAntigravityAccessToken(observed);
+  } catch {
+    return { ok: false, failure: tokenFailure(refreshCalled, refreshOutcome) };
+  }
+  addSecret(secrets, accessToken);
+  for (const raw of [preRaw, ...laterReads]) {
+    addSecret(secrets, raw);
+    addSecret(secrets, readSharedAntigravityToken({ ...base, readStore: () => raw })?.refresh_token);
+  }
+  return { ok: true, accessToken };
+}
+async function establishAntigravitySession(deps, secrets, facts) {
+  if (deps.platform() !== "darwin") {
+    return { ok: false, failure: failureOf2("credential_missing", "platform_unsupported") };
+  }
+  const read = await deps.readStore(deps.keychainDeadlineMs);
+  if (read.kind !== "present")
+    return { ok: false, failure: storeReadFailure(read) };
+  addSecret(secrets, read.raw);
+  const token = await obtainAccessToken(deps, facts, secrets, read.raw);
+  if (!token.ok)
+    return token;
+  const version = resolveAntigravityClientVersion();
+  facts.clientVersion = version.version;
+  facts.clientVersionSource = version.source;
+  let projectId;
+  let tierId;
+  try {
+    const setup = await raceTimeout(setupAntigravityUser(token.accessToken), deps.httpTimeoutMs);
+    if (setup === TIMED_OUT) {
+      return { ok: false, failure: failureOf2("network", "load_code_assist_timeout") };
+    }
+    projectId = setup.projectId;
+    tierId = setup.tierId;
+  } catch (err) {
+    return { ok: false, failure: loadCodeAssistFailure(err) };
+  }
+  addSecret(secrets, projectId);
+  return { ok: true, accessToken: token.accessToken, projectId, tierId };
+}
+var SESSION_FAILURE_CODES, TIMED_OUT;
+var init_subscription_antigravity_session = __esm(() => {
+  init_antigravity_token();
+  init_antigravity_user();
+  SESSION_FAILURE_CODES = {
+    credential_missing: ["platform_unsupported", "keychain_item_absent", "token_unparseable"],
+    keychain_locked: ["keychain_locked", "keychain_read_timeout", "keychain_read_failed"],
+    mint_failed: [
+      "agy_missing",
+      "agy_refresh_failed",
+      "agy_refresh_timeout",
+      "agy_refresh_no_valid_token",
+      "load_code_assist_4xx",
+      "load_code_assist_no_project",
+      "load_code_assist_bad_body"
+    ],
+    network: [
+      "load_code_assist_network_error",
+      "load_code_assist_429",
+      "load_code_assist_5xx",
+      "load_code_assist_timeout"
+    ]
+  };
+  TIMED_OUT = Symbol("timed-out");
+});
+
+// src/subscription-models-command.ts
+var exports_subscription_models_command = {};
+__export(exports_subscription_models_command, {
+  EXIT: () => EXIT,
+  FAILURE_CODES: () => FAILURE_CODES,
+  INTERNAL_ERROR_MESSAGE: () => INTERNAL_ERROR_MESSAGE,
+  SECRET_GUARD_MESSAGE: () => SECRET_GUARD_MESSAGE,
+  SUBSCRIPTION_MODELS_USAGE: () => SUBSCRIPTION_MODELS_USAGE,
+  SUBSCRIPTION_MODEL_LIST_SCHEMA: () => SUBSCRIPTION_MODEL_LIST_SCHEMA,
+  defaultSubscriptionModelsDeps: () => defaultSubscriptionModelsDeps,
+  exitCodeFor: () => exitCodeFor,
+  parseSubscriptionModelsArgs: () => parseSubscriptionModelsArgs,
+  reportSubscriptionInternalError: () => reportSubscriptionInternalError,
+  runAntigravityRawModelList: () => runAntigravityRawModelList,
+  subscriptionModelsCommand: () => subscriptionModelsCommand
+});
+function exitCodeFor(failure) {
+  if (failure.class === "internal")
+    return failure.code === "usage" ? EXIT.usage : EXIT.internal;
+  return EXIT[failure.class];
+}
+function defaultSubscriptionModelsDeps() {
+  return {
+    platform: () => process.platform,
+    readStore: readAntigravityStoreClassified,
+    tokenDeps: defaultAntigravityTokenDeps,
+    now: () => Date.now(),
+    httpTimeoutMs: 30000,
+    keychainDeadlineMs: 1e4,
+    writeStdout: (line) => new Promise((resolve, reject) => {
+      process.stdout.write(line, (err) => err ? reject(err) : resolve());
+    }),
+    writeStderr: (line) => {
+      process.stderr.write(line);
+    }
+  };
+}
+function parseSubscriptionModelsArgs(argv) {
+  const positionals = argv.filter((a) => !a.startsWith("-"));
+  const flags = argv.filter((a) => a.startsWith("-"));
+  const positionalsOk = positionals.length === 2 && positionals[0] === "models" && positionals[1] === "antigravity";
+  const flagsOk = flags.length === 2 && flags.includes("--raw") && flags.includes("--json");
+  return positionalsOk && flagsOk ? { ok: true, provider: "antigravity" } : { ok: false };
+}
+function buildEnvelope(facts, failure, body) {
+  return {
+    schema: SUBSCRIPTION_MODEL_LIST_SCHEMA,
+    ...facts.provider !== undefined ? { provider: facts.provider } : {},
+    claudishVersion: VERSION,
+    ...facts.fetchedAt !== undefined ? { fetchedAt: facts.fetchedAt } : {},
+    ...facts.sourceUrl !== undefined ? { sourceUrl: facts.sourceUrl } : {},
+    ...facts.clientVersion !== undefined ? { clientVersion: facts.clientVersion } : {},
+    ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
+    tokenRefreshed: facts.tokenRefreshed,
+    ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
+    ...failure ? { failure } : {},
+    ...body !== undefined ? { body } : {}
+  };
+}
+function failureOf3(cls, code, httpStatus) {
+  return failureOf2(cls, code, httpStatus);
+}
 function listFailure(value, status) {
   const models = value !== null && typeof value === "object" && !Array.isArray(value) ? value.models : undefined;
   if (models === null || typeof models !== "object" || Array.isArray(models)) {
-    return failureOf2("list_incomplete", "models_absent", status);
+    return failureOf3("list_incomplete", "models_absent", status);
   }
   if (Object.keys(models).length === 0) {
-    return failureOf2("list_incomplete", "models_empty", status);
+    return failureOf3("list_incomplete", "models_empty", status);
   }
   return null;
 }
-async function raceTimeout(work, ms) {
-  let timer;
-  const timedOut = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(TIMED_OUT), ms);
-  });
-  work.catch(() => {});
-  try {
-    return await Promise.race([work, timedOut]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
 function fail(facts, failure) {
   return { envelope: buildEnvelope(facts, failure), exitCode: exitCodeFor(failure) };
 }
@@ -104604,20 +104944,13 @@ function lineOf(envelope) {
   return `${JSON.stringify(envelope)}
 `;
 }
-function containsSecret(secrets, ...texts) {
-  for (const secret of secrets.values) {
-    if (texts.some((text) => text?.includes(secret)))
-      return true;
-  }
-  return false;
-}
 function safeStderr(deps, line) {
   try {
     deps.writeStderr(line);
   } catch {}
 }
 async function writeInternalFailure(deps, facts, code, stderrLine, secrets) {
-  const failure = failureOf2("internal", code);
+  const failure = failureOf3("internal", code);
   safeStderr(deps, `${stderrLine}
 `);
   const line = lineOf(buildEnvelope(facts, failure));
@@ -104639,51 +104972,13 @@ async function reportSubscriptionInternalError(deps) {
   }
   return writeInternalFailure(resolved, { tokenRefreshed: false }, "internal_error", INTERNAL_ERROR_MESSAGE);
 }
-async function obtainAccessToken(deps, facts, secrets, preRaw) {
-  const base = deps.tokenDeps();
-  let firstRead = true;
-  let refreshCalled = false;
-  let refreshOutcome = null;
-  const laterReads = [];
-  const observed = {
-    ...base,
-    readStore: () => {
-      if (firstRead) {
-        firstRead = false;
-        return preRaw;
-      }
-      const raw = base.readStore();
-      if (raw)
-        laterReads.push(raw);
-      return raw;
-    },
-    runAgyRefresh: () => {
-      refreshCalled = true;
-      facts.tokenRefreshed = true;
-      refreshOutcome = base.runAgyRefresh();
-      return refreshOutcome;
-    }
-  };
-  let accessToken;
-  try {
-    accessToken = await getValidAntigravityAccessToken(observed);
-  } catch {
-    return { ok: false, result: fail(facts, tokenFailure(refreshCalled, refreshOutcome)) };
-  }
-  addSecret(secrets, accessToken);
-  for (const raw of [preRaw, ...laterReads]) {
-    addSecret(secrets, raw);
-    addSecret(secrets, readSharedAntigravityToken({ ...base, readStore: () => raw })?.refresh_token);
-  }
-  return { ok: true, accessToken };
-}
 function classifyAvailableModels(facts, raw, timedOut) {
   facts.sourceUrl = stripUserinfo(raw.url);
   facts.clientVersion = raw.clientVersion;
   facts.clientVersionSource = raw.clientVersionSource;
   const networkCode = timedOut ? "fetch_available_models_timeout" : "fetch_available_models_network_error";
   if (raw.kind === "unreachable")
-    return fail(facts, failureOf2("network", networkCode));
+    return fail(facts, failureOf3("network", networkCode));
   facts.fetchedAt = raw.fetchedAt;
   facts.httpStatus = raw.status;
   if (raw.status < 200 || raw.status >= 300) {
@@ -104701,39 +104996,20 @@ function classifyAvailableModels(facts, raw, timedOut) {
       };
     }
     case "not-json":
-      return fail(facts, failureOf2("list_incomplete", "body_not_json", raw.status));
+      return fail(facts, failureOf3("list_incomplete", "body_not_json", raw.status));
     default:
-      return fail(facts, failureOf2("network", networkCode, raw.status));
+      return fail(facts, failureOf3("network", networkCode, raw.status));
   }
 }
 async function determine(deps, secrets, facts) {
-  if (deps.platform() !== "darwin") {
-    return fail(facts, failureOf2("credential_missing", "platform_unsupported"));
-  }
-  const read = await deps.readStore(deps.keychainDeadlineMs);
-  if (read.kind !== "present")
-    return fail(facts, storeReadFailure(read));
-  addSecret(secrets, read.raw);
-  const token = await obtainAccessToken(deps, facts, secrets, read.raw);
-  if (!token.ok)
-    return token.result;
-  const version = resolveAntigravityClientVersion();
-  facts.clientVersion = version.version;
-  facts.clientVersionSource = version.source;
-  let projectId;
-  try {
-    const setup = await raceTimeout(setupAntigravityUser(token.accessToken), deps.httpTimeoutMs);
-    if (setup === TIMED_OUT)
-      return fail(facts, failureOf2("network", "load_code_assist_timeout"));
-    projectId = setup.projectId;
-  } catch (err) {
-    return fail(facts, loadCodeAssistFailure(err));
-  }
-  addSecret(secrets, projectId);
+  const session = await establishAntigravitySession(deps, secrets, facts);
+  if (!session.ok)
+    return fail(facts, session.failure);
+  const { accessToken, projectId } = session;
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), deps.httpTimeoutMs);
   try {
-    const raw = await fetchAntigravityAvailableModelsRaw(token.accessToken, projectId, {
+    const raw = await fetchAntigravityAvailableModelsRaw(accessToken, projectId, {
       signal: controller.signal,
       now: deps.now
     });
@@ -104743,7 +105019,7 @@ async function determine(deps, secrets, facts) {
   }
 }
 async function runAntigravityRawModelList(deps) {
-  const secrets = { values: new Set };
+  const secrets = newSecrets();
   const facts = { provider: "antigravity", tokenRefreshed: false };
   let line;
   let exitCode;
@@ -104774,27 +105050,17 @@ async function subscriptionModelsCommand(argv, deps = defaultSubscriptionModelsD
   }
   return runAntigravityRawModelList(deps);
 }
-var SUBSCRIPTION_MODEL_LIST_SCHEMA = "claudish.subscription-model-list.v1", FAILURE_CODES, EXIT, SUBSCRIPTION_MODELS_USAGE = "usage: claudish subscription models antigravity --raw --json", SECRET_GUARD_MESSAGE = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE = "[claudish subscription] internal error", TIMED_OUT;
+var SUBSCRIPTION_MODEL_LIST_SCHEMA = "claudish.subscription-model-list.v1", FAILURE_CODES, EXIT, SUBSCRIPTION_MODELS_USAGE = "usage: claudish subscription models antigravity --raw --json", SECRET_GUARD_MESSAGE = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE = "[claudish subscription] internal error";
 var init_subscription_models_command = __esm(() => {
   init_antigravity_token();
   init_antigravity_user();
+  init_subscription_antigravity_session();
   FAILURE_CODES = {
-    credential_missing: ["platform_unsupported", "keychain_item_absent", "token_unparseable"],
-    keychain_locked: ["keychain_locked", "keychain_read_timeout", "keychain_read_failed"],
-    mint_failed: [
-      "agy_missing",
-      "agy_refresh_failed",
-      "agy_refresh_timeout",
-      "agy_refresh_no_valid_token",
-      "load_code_assist_4xx",
-      "load_code_assist_no_project",
-      "load_code_assist_bad_body"
-    ],
+    credential_missing: SESSION_FAILURE_CODES.credential_missing,
+    keychain_locked: SESSION_FAILURE_CODES.keychain_locked,
+    mint_failed: SESSION_FAILURE_CODES.mint_failed,
     network: [
-      "load_code_assist_network_error",
-      "load_code_assist_429",
-      "load_code_assist_5xx",
-      "load_code_assist_timeout",
+      ...SESSION_FAILURE_CODES.network,
       "fetch_available_models_network_error",
       "fetch_available_models_timeout"
     ],
@@ -104811,7 +105077,399 @@ var init_subscription_models_command = __esm(() => {
     network: 6,
     list_incomplete: 7
   };
-  TIMED_OUT = Symbol("timed-out");
+});
+
+// src/subscription-dispatch.ts
+function isSubscriptionProbeArgv(argv) {
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--model" || token === "--request-file") {
+      if (argv[i + 1] !== undefined && !argv[i + 1].startsWith("-"))
+        i++;
+    } else if (!token.startsWith("-")) {
+      return token === "probe";
+    }
+  }
+  return false;
+}
+function probeLoadFailureLine() {
+  return `${JSON.stringify({
+    schema: SUBSCRIPTION_PROBE_SCHEMA,
+    claudishVersion: VERSION,
+    tokenRefreshed: false,
+    failure: { class: "internal", code: "internal_error" }
+  })}
+`;
+}
+var SUBSCRIPTION_PROBE_SCHEMA = "claudish.subscription-probe.v1";
+var init_subscription_dispatch = () => {};
+
+// src/subscription-probe-command.ts
+var exports_subscription_probe_command = {};
+__export(exports_subscription_probe_command, {
+  MAX_UNESCAPE_ROUNDS: () => MAX_UNESCAPE_ROUNDS,
+  PROBE_BODY_CAP_BYTES: () => PROBE_BODY_CAP_BYTES,
+  PROBE_EXIT: () => PROBE_EXIT,
+  PROBE_FAILURE_CODES: () => PROBE_FAILURE_CODES,
+  PROBE_REQUEST_FILE_CAP_BYTES: () => PROBE_REQUEST_FILE_CAP_BYTES,
+  PROBE_REQUEST_FILE_MESSAGE: () => PROBE_REQUEST_FILE_MESSAGE,
+  REDACTED: () => REDACTED2,
+  SUBSCRIPTION_PROBE_SCHEMA: () => SUBSCRIPTION_PROBE_SCHEMA,
+  SUBSCRIPTION_PROBE_USAGE: () => SUBSCRIPTION_PROBE_USAGE,
+  buildProbeEnvelopeBody: () => buildProbeEnvelopeBody,
+  defaultSubscriptionProbeDeps: () => defaultSubscriptionProbeDeps,
+  isSubscriptionProbeArgv: () => isSubscriptionProbeArgv,
+  jsonUnescapedForms: () => jsonUnescapedForms,
+  parseSubscriptionProbeArgs: () => parseSubscriptionProbeArgs,
+  probeExitCodeFor: () => probeExitCodeFor,
+  redactSecretValues: () => redactSecretValues,
+  reportProbeInternalError: () => reportProbeInternalError,
+  runAntigravityProbe: () => runAntigravityProbe,
+  subscriptionProbeCommand: () => subscriptionProbeCommand
+});
+import { randomUUID as randomUUID10 } from "crypto";
+import { readFile as readFile8, stat as stat2 } from "fs/promises";
+function probeExitCodeFor(failure) {
+  if (failure.class === "internal") {
+    return CALLER_CODES.includes(failure.code) ? PROBE_EXIT.usage : PROBE_EXIT.internal;
+  }
+  return PROBE_EXIT[failure.class];
+}
+async function defaultReadRequestFile(path) {
+  const info = await stat2(path);
+  if (!info.isFile())
+    throw new Error("not a file");
+  if (info.size > PROBE_REQUEST_FILE_CAP_BYTES)
+    return null;
+  return readFile8(path, "utf8");
+}
+function defaultSubscriptionProbeDeps() {
+  return {
+    platform: () => process.platform,
+    readStore: readAntigravityStoreClassified,
+    tokenDeps: defaultAntigravityTokenDeps,
+    now: () => Date.now(),
+    httpTimeoutMs: 30000,
+    keychainDeadlineMs: 1e4,
+    requestTimeoutMs: 300000,
+    readRequestFile: defaultReadRequestFile,
+    writeStdout: (line) => new Promise((resolve, reject) => {
+      process.stdout.write(line, (err) => err ? reject(err) : resolve());
+    }),
+    writeStderr: (line) => {
+      process.stderr.write(line);
+    }
+  };
+}
+function parseSubscriptionProbeArgs(argv) {
+  const positionals = [];
+  const values = new Map;
+  const switches = new Set;
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--model" || token === "--request-file") {
+      const value = argv[i + 1];
+      if (values.has(token) || value === undefined || value === "" || value.startsWith("-")) {
+        return { ok: false };
+      }
+      values.set(token, value);
+      i++;
+    } else if (token === "--raw" || token === "--json") {
+      if (switches.has(token))
+        return { ok: false };
+      switches.add(token);
+    } else if (token.startsWith("-")) {
+      return { ok: false };
+    } else {
+      positionals.push(token);
+    }
+  }
+  const model = values.get("--model");
+  const requestFile = values.get("--request-file");
+  if (positionals.length !== 2 || positionals[0] !== "probe" || positionals[1] !== "antigravity" || switches.size !== 2 || model === undefined || requestFile === undefined) {
+    return { ok: false };
+  }
+  return { ok: true, provider: "antigravity", model, requestFile };
+}
+function failureOf4(cls, code, httpStatus) {
+  return failureOf2(cls, code, httpStatus);
+}
+function buildEnvelope2(facts, failure, body) {
+  return {
+    schema: SUBSCRIPTION_PROBE_SCHEMA,
+    ...facts.provider !== undefined ? { provider: facts.provider } : {},
+    claudishVersion: VERSION,
+    ...facts.model !== undefined ? { model: facts.model } : {},
+    ...facts.fetchedAt !== undefined ? { fetchedAt: facts.fetchedAt } : {},
+    ...facts.sourceUrl !== undefined ? { sourceUrl: facts.sourceUrl } : {},
+    ...facts.clientVersion !== undefined ? { clientVersion: facts.clientVersion } : {},
+    ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
+    tokenRefreshed: facts.tokenRefreshed,
+    ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
+    ...failure ? { failure } : {},
+    ...body ? { bodyRedacted: body.redacted, body: body.text } : {}
+  };
+}
+function fail2(facts, failure) {
+  return { envelope: buildEnvelope2(facts, failure), exitCode: probeExitCodeFor(failure) };
+}
+function lineOf2(envelope) {
+  return `${JSON.stringify(envelope)}
+`;
+}
+function safeStderr2(deps, line) {
+  try {
+    deps.writeStderr(line);
+  } catch {}
+}
+async function writeInternalFailure2(deps, facts, code, stderrLine, secrets) {
+  const failure = failureOf4("internal", code);
+  safeStderr2(deps, `${stderrLine}
+`);
+  let line = lineOf2(buildEnvelope2(facts, failure));
+  if (secrets && containsSecret(secrets, line)) {
+    line = lineOf2(buildEnvelope2({ tokenRefreshed: facts.tokenRefreshed }, failure));
+  }
+  try {
+    await deps.writeStdout(line);
+  } catch {}
+  return probeExitCodeFor(failure);
+}
+function redactSecretValues(text, secrets) {
+  let out = text;
+  const values = [...secrets.values].sort((a, b) => b.length - a.length);
+  for (const value of values) {
+    for (const form of new Set([value, value.replaceAll("/", "\\/")])) {
+      if (out.includes(form))
+        out = out.replaceAll(form, REDACTED2);
+    }
+  }
+  return { text: out, redacted: out !== text };
+}
+function jsonUnescapedForms(text) {
+  const forms = [];
+  if (text === undefined)
+    return { forms, complete: true };
+  let current = text;
+  for (let round = 0;round < MAX_UNESCAPE_ROUNDS; round++) {
+    const next = current.replace(JSON_ESCAPE, (_match, hex, letter) => hex !== undefined ? String.fromCharCode(Number.parseInt(hex, 16)) : SIMPLE_ESCAPES[letter]);
+    if (next === current)
+      return { forms, complete: true };
+    forms.push(next);
+    current = next;
+  }
+  return { forms, complete: false };
+}
+async function readRequest(deps, path) {
+  let text;
+  try {
+    text = await deps.readRequestFile(path);
+  } catch {
+    return { ok: false, code: "request_file_unreadable" };
+  }
+  if (text === null)
+    return { ok: false, code: "request_file_invalid" };
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { ok: false, code: "request_file_invalid" };
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, code: "request_file_invalid" };
+  }
+  return { ok: true, text };
+}
+function buildProbeEnvelopeBody(model, projectId, tierId, requestText, userPromptId = randomUUID10()) {
+  const head = JSON.stringify({ model, project: projectId, user_prompt_id: userPromptId });
+  const credits = tierId && tierId !== "free-tier" ? `,"enabled_credit_types":${JSON.stringify(["GOOGLE_ONE_AI"])}` : "";
+  return `${head.slice(0, -1)},"request":${requestText}${credits}}`;
+}
+function createActivityRequestId3() {
+  return Math.random().toString(36).substring(7);
+}
+async function readCapped(res, cap) {
+  if (!res.body)
+    return "";
+  const reader = res.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    size += value.byteLength;
+    if (size > cap) {
+      await reader.cancel().catch(() => {});
+      return null;
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function determine2(deps, secrets, facts, args) {
+  const request = await readRequest(deps, args.requestFile);
+  if (!request.ok)
+    return fail2(facts, failureOf4("internal", request.code));
+  const session = await establishAntigravitySession(deps, secrets, facts);
+  if (!session.ok)
+    return fail2(facts, session.failure);
+  const url = `${antigravityHost()}/v1internal:generateContent`;
+  const version = resolveAntigravityClientVersion();
+  facts.sourceUrl = stripUserinfo(url);
+  facts.clientVersion = version.version;
+  facts.clientVersionSource = version.source;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), deps.requestTimeoutMs);
+  const networkFailure = () => failureOf4("network", controller.signal.aborted ? "generate_content_timeout" : "generate_content_network_error", facts.httpStatus);
+  try {
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${session.accessToken}`,
+          "Content-Type": "application/json",
+          "User-Agent": antigravityUserAgentFor(version.version),
+          "x-activity-request-id": createActivityRequestId3()
+        },
+        body: buildProbeEnvelopeBody(args.model, session.projectId, session.tierId, request.text),
+        signal: controller.signal,
+        redirect: "manual"
+      });
+    } catch {
+      return fail2(facts, networkFailure());
+    }
+    facts.fetchedAt = new Date(deps.now()).toISOString();
+    facts.httpStatus = res.status;
+    let text;
+    try {
+      text = await readCapped(res, PROBE_BODY_CAP_BYTES);
+    } catch {
+      return fail2(facts, networkFailure());
+    }
+    if (text === null)
+      return fail2(facts, failureOf4("list_incomplete", "body_too_large", res.status));
+    if (res.ok) {
+      try {
+        JSON.parse(text);
+      } catch {
+        return fail2(facts, failureOf4("list_incomplete", "body_not_json", res.status));
+      }
+    }
+    const body = redactSecretValues(text, secrets);
+    const unescaped = jsonUnescapedForms(body.text);
+    if (!unescaped.complete) {
+      return fail2(facts, failureOf4("list_incomplete", "body_unverifiable", res.status));
+    }
+    return {
+      envelope: buildEnvelope2(facts, undefined, body),
+      exitCode: PROBE_EXIT.ok,
+      bodyText: body.text,
+      bodyForms: unescaped.forms
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runAntigravityProbe(deps, args) {
+  const secrets = newSecrets();
+  const facts = { provider: "antigravity", model: args.model, tokenRefreshed: false };
+  let result;
+  try {
+    result = await determine2(deps, secrets, facts, args);
+  } catch {
+    return writeInternalFailure2(deps, { provider: facts.provider, model: facts.model, tokenRefreshed: facts.tokenRefreshed }, "internal_error", INTERNAL_ERROR_MESSAGE2, secrets);
+  }
+  if (result.envelope.failure?.code === "request_file_unreadable" || result.envelope.failure?.code === "request_file_invalid") {
+    safeStderr2(deps, `${PROBE_REQUEST_FILE_MESSAGE}
+`);
+  }
+  const line = lineOf2(result.envelope);
+  if (containsSecret(secrets, line, result.bodyText, ...result.bodyForms ?? [])) {
+    return writeInternalFailure2(deps, facts, "secret_guard", SECRET_GUARD_MESSAGE2, secrets);
+  }
+  try {
+    await deps.writeStdout(line);
+  } catch {
+    safeStderr2(deps, `${INTERNAL_ERROR_MESSAGE2}
+`);
+    return PROBE_EXIT.internal;
+  }
+  return result.exitCode;
+}
+async function reportProbeInternalError(deps) {
+  let resolved;
+  try {
+    resolved = deps ?? defaultSubscriptionProbeDeps();
+  } catch {
+    process.stderr.write(`${INTERNAL_ERROR_MESSAGE2}
+`);
+    return PROBE_EXIT.internal;
+  }
+  return writeInternalFailure2(resolved, { tokenRefreshed: false }, "internal_error", INTERNAL_ERROR_MESSAGE2);
+}
+async function subscriptionProbeCommand(argv, deps = defaultSubscriptionProbeDeps()) {
+  const args = parseSubscriptionProbeArgs(argv);
+  if (!args.ok) {
+    return writeInternalFailure2(deps, { tokenRefreshed: false }, "usage", SUBSCRIPTION_PROBE_USAGE);
+  }
+  return runAntigravityProbe(deps, args);
+}
+var PROBE_FAILURE_CODES, PROBE_EXIT, CALLER_CODES, PROBE_BODY_CAP_BYTES, PROBE_REQUEST_FILE_CAP_BYTES, REDACTED2 = "[REDACTED]", SUBSCRIPTION_PROBE_USAGE = "usage: claudish subscription probe antigravity --model <wire-model-id> --request-file <path> --raw --json", PROBE_REQUEST_FILE_MESSAGE = "[claudish subscription] the request file must hold one JSON object (the inner Gemini request)", SECRET_GUARD_MESSAGE2 = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE2 = "[claudish subscription] internal error", JSON_ESCAPE, SIMPLE_ESCAPES, MAX_UNESCAPE_ROUNDS = 64;
+var init_subscription_probe_command = __esm(() => {
+  init_antigravity_token();
+  init_antigravity_user();
+  init_subscription_antigravity_session();
+  init_subscription_dispatch();
+  init_subscription_dispatch();
+  PROBE_FAILURE_CODES = {
+    credential_missing: SESSION_FAILURE_CODES.credential_missing,
+    keychain_locked: SESSION_FAILURE_CODES.keychain_locked,
+    mint_failed: SESSION_FAILURE_CODES.mint_failed,
+    network: [
+      ...SESSION_FAILURE_CODES.network,
+      "generate_content_network_error",
+      "generate_content_timeout"
+    ],
+    list_incomplete: ["body_too_large", "body_not_json", "body_unverifiable"],
+    internal: [
+      "usage",
+      "request_file_unreadable",
+      "request_file_invalid",
+      "secret_guard",
+      "internal_error"
+    ]
+  };
+  PROBE_EXIT = {
+    ok: 0,
+    internal: 1,
+    usage: 2,
+    credential_missing: 3,
+    keychain_locked: 4,
+    mint_failed: 5,
+    network: 6,
+    list_incomplete: 7
+  };
+  CALLER_CODES = [
+    "usage",
+    "request_file_unreadable",
+    "request_file_invalid"
+  ];
+  PROBE_BODY_CAP_BYTES = 512 * 1024;
+  PROBE_REQUEST_FILE_CAP_BYTES = 8 * 1024 * 1024;
+  JSON_ESCAPE = /\\(?:u([0-9a-fA-F]{4})|(["\\/bfnrt]))/g;
+  SIMPLE_ESCAPES = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    b: "\b",
+    f: "\f",
+    n: `
+`,
+    r: "\r",
+    t: "\t"
+  };
 });
 
 // src/account-forecast-render.ts
@@ -115079,7 +115737,7 @@ var init_terminal_isolation = __esm(() => {
 
 // src/claude-runner.ts
 import { spawn as spawn4, spawnSync as spawnSync4 } from "child_process";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import {
   chmodSync as chmodSync5,
   closeSync as closeSync14,
@@ -115651,6 +116309,7 @@ function buildClaudishSettingsOverlay(statusLine, proxyAuthMode, paneChild = isP
   if (paneChild) {
     settings.skipDangerousModePermissionPrompt = true;
     settings.editorMode = "normal";
+    settings.wheelScrollAccelerationEnabled = false;
   }
   return settings;
 }
@@ -115675,6 +116334,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",
@@ -116013,7 +116675,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   const sessionFlags = sessionFlagsOf(config.claudeArgs);
   let driverLaunch = null;
   if (surfaces.driver) {
-    const minted = sessionFlags.sessionId || sessionFlags.resumes ? null : randomUUID10();
+    const minted = sessionFlags.sessionId || sessionFlags.resumes ? null : randomUUID11();
     const turnDir = mkdtempSync4(join63(tmpdir3(), "claudish-turns-"));
     chmodSync5(turnDir, 448);
     claudeArgs.unshift(...driverLeadingArgs({ mintedSessionId: minted, turnDir }));
@@ -119200,12 +119862,25 @@ if (isMcpMode) {
   }));
 } else if (isSubscriptionCommand) {
   const subscriptionArgIndex = args.indexOf("subscription");
+  const subscriptionArgv = args.slice(subscriptionArgIndex + 1);
   const subscriptionModule = () => Promise.resolve().then(() => (init_subscription_models_command(), exports_subscription_models_command));
-  subscriptionModule().then((m) => m.subscriptionModelsCommand(args.slice(subscriptionArgIndex + 1))).catch(() => subscriptionModule().then((m) => m.reportSubscriptionInternalError()).catch(() => {
+  const probeModule = () => Promise.resolve().then(() => (init_subscription_probe_command(), exports_subscription_probe_command));
+  const writeLine = (line, code) => new Promise((resolve) => {
+    process.stdout.write(line, () => resolve(code));
+  });
+  Promise.resolve().then(() => (init_subscription_dispatch(), {})).then((dispatch) => {
+    const probe = isSubscriptionProbeArgv(subscriptionArgv);
+    const run = probe ? probeModule().then((m) => m.subscriptionProbeCommand(subscriptionArgv)) : subscriptionModule().then((m) => m.subscriptionModelsCommand(subscriptionArgv));
+    return run.catch(() => probe ? probeModule().then((m) => m.reportProbeInternalError()).catch(() => {
+      process.stderr.write(`[claudish subscription] internal error
+`);
+      return writeLine(probeLoadFailureLine(), 1);
+    }) : subscriptionModule().then((m) => m.reportSubscriptionInternalError()));
+  }).catch(() => {
     process.stderr.write(`[claudish subscription] internal error
 `);
     return 1;
-  })).then((code) => process.exit(code));
+  }).then((code) => process.exit(code));
 } else if (isAccountCommand) {
   const accountArgIndex = args.indexOf("account");
   Promise.resolve().then(() => (init_account_command(), {})).then((m) => accountCommand(args.slice(accountArgIndex + 1)).catch((e) => {