very-happy-cli 0.2.163 → 0.2.164

package/dist/{runClaudeDeps-lb6LlVPa.cjs → runClaudeDeps-dxv910DR.cjs}

@@ -1,48 +1,48 @@
 'use strict';
 
-var logger = require('./logger-Ca5eRZ2j.cjs');
-var controlClient = require('./controlClient-HPMsyxLb.cjs');
+var logger = require('./logger-B1k7eZnq.cjs');
+var controlClient = require('./controlClient-DI-Er-Ww.cjs');
 var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
 var node_crypto = require('node:crypto');
 var messageBuffer = require('./messageBuffer-fJMH6uY8.cjs');
 var index = require('./index-D3kI0hDR.cjs');
 var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
 var permissionMode = require('./permissionMode-CrV-XuMs.cjs');
-var systemPrompt = require('./systemPrompt-9PWg4OU6.cjs');
+var systemPrompt = require('./systemPrompt-C1tRiZ-u.cjs');
 var path$1 = require('node:path');
 var specialCommands = require('./specialCommands-DSsTeRej.cjs');
 require('axios');
 require('node:events');
 require('socket.io-client');
-var attachmentLimits = require('./attachmentLimits-DzlBPyJP.cjs');
+var attachmentLimits = require('./attachmentLimits-eJZ4ZBjF.cjs');
 require('tweetnacl');
-var configuration = require('./configuration-CepfrPZ_.cjs');
-require('./index-DJ-oV52i.cjs');
-require('./registerCommonHandlers-DPOHFlxp.cjs');
+var configuration = require('./configuration-PXAE4-FP.cjs');
+require('./index-DqlyNgt4.cjs');
+require('./registerCommonHandlers-Dausbdsb.cjs');
 require('os');
 require('child_process');
 require('@paralleldrive/cuid2');
-require('./persistence-Ceb-BPk6.cjs');
+require('./persistence-d3ZyER6o.cjs');
 var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 var types = require('./types-CRS-srZK.cjs');
 var path = require('./path-B7zW-WwE.cjs');
 var fs = require('fs/promises');
-var time = require('./time-xNkWLTSj.cjs');
+var time = require('./time-C7BplxuS.cjs');
 var node_fs = require('node:fs');
-var deterministicJson = require('./deterministicJson-BFzPcsCh.cjs');
-var sessionScanner = require('./sessionScanner-D6WqRtJQ.cjs');
+var deterministicJson = require('./deterministicJson-BM8e8QwP.cjs');
+var sessionScanner = require('./sessionScanner-BWU6KvZw.cjs');
 var node_child_process = require('node:child_process');
-var streamRelay = require('./streamRelay-DnObXZZj.cjs');
-var attachmentContent = require('./attachmentContent-CUKdzh4v.cjs');
+var streamRelay = require('./streamRelay-C0AffuX6.cjs');
+var attachmentContent = require('./attachmentContent-Bakb0XV3.cjs');
 var promises = require('node:fs/promises');
-var claudeSessionFork = require('./claudeSessionFork-DdJFvxwf.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-DGDubZLv.cjs');
-var doctor = require('./doctor-BHNVY9DE.cjs');
+var claudeSessionFork = require('./claudeSessionFork-BWdhyy9B.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-CgKyzwqw.cjs');
+var doctor = require('./doctor-Cl6cqvok.cjs');
 var node_http = require('node:http');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
-var titleGenerator = require('./titleGenerator-C8arvXNG.cjs');
+var titleGenerator = require('./titleGenerator-Kw3sTnNQ.cjs');
 var oneShotPrompts = require('./oneShotPrompts-CL0dip9C.cjs');
 require('node:util');
 require('./smallFastModel-D_uxGMo3.cjs');
@@ -50,33 +50,33 @@ require('./trimIdent-4gvk9Wk6.cjs');
 require('node:os');
 require('./agentGuidance-B5NATuFa.cjs');
 require('zod');
-require('./package-BfnmIH4b.cjs');
+require('./package-CC_txQ31.cjs');
 require('util');
 require('crypto');
 require('path');
 require('cross-spawn');
 require('./authRelay-BdYkC1Po.cjs');
-require('./client-CXvsRLAz.cjs');
-require('./context-BhZMRQho.cjs');
-require('./sessionOps-DWsGWwfZ.cjs');
+require('./client-C1GAIJ04.cjs');
+require('./context-DhvXl1oC.cjs');
+require('./sessionOps-HuoMXcIZ.cjs');
 require('./resources-JDPugcDq.cjs');
-require('./tools-xQ38ufgo.cjs');
-require('./tools-GnqHEZHb.cjs');
-require('./client-CQzHoynf.cjs');
-require('./peerTools-CADjnFDx.cjs');
+require('./tools-D7UeLMZ7.cjs');
+require('./tools-BTBgpiRc.cjs');
+require('./client-BZtKFCJr.cjs');
+require('./peerTools-CqIcCEIg.cjs');
 require('./ids-B6ZC0HGt.cjs');
-require('./remoteSessionClient-DbnVs1Tv.cjs');
+require('./remoteSessionClient-BkJt8SHa.cjs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 require('./limits-C-a7gr04.cjs');
-require('./assistantTools-NC7DMNvV.cjs');
+require('./assistantTools-D3cZvgUX.cjs');
 require('./terminals-B_bfC9c2.cjs');
 require('./terminalTitleSuggest-DhvRFX3H.cjs');
 require('./tmuxSocket-D-Xt6Vn-.cjs');
-require('./bootstrap-CccIDvh4.cjs');
+require('./bootstrap-D9SUykG_.cjs');
 require('./previewPath-B0rBdhy1.cjs');
-require('./sync-fDRF_nO1.cjs');
-require('./startFileWatcher-Ce17H9pG.cjs');
+require('./sync--uxtLWbo.cjs');
+require('./startFileWatcher-BfMu444W.cjs');
 require('node:readline');
 require('./doctor-u46qYYKX.cjs');
 require('ps-list');
@@ -2891,16 +2891,55 @@ function rewindTranscriptLines(lines, action, target) {
   });
   return [...before.map((entry) => entry.line), ...relinked];
 }
-async function rewindClaudeTranscript(projectDir, claudeSessionId, action, target) {
-  const source = path$1.join(projectDir, `${claudeSessionId}.jsonl`);
-  let raw;
+function transcriptSourceId(lines, claudeSessionId) {
+  let source = null;
+  for (const line of lines) {
+    if (!line || !line.includes('"sessionId"')) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof parsed?.sessionId === "string" && parsed.sessionId && parsed.sessionId !== claudeSessionId) source = parsed.sessionId;
+  }
+  return source;
+}
+const MAX_LINEAGE_DEPTH = 4;
+async function readTranscriptLines(projectDir, claudeSessionId) {
+  const path = path$1.join(projectDir, `${claudeSessionId}.jsonl`);
   try {
-    raw = await promises.readFile(source, "utf-8");
+    return (await promises.readFile(path, "utf-8")).split("\n");
   } catch (error) {
-    if (error.code === "ENOENT") throw new claudeSessionFork.ForkSourceMissingError(source);
+    if (error.code === "ENOENT") throw new claudeSessionFork.ForkSourceMissingError(path);
     throw error;
   }
-  const kept = rewindTranscriptLines(raw.split("\n"), action, target);
+}
+async function rewindAcrossLineage(load, claudeSessionId, action, target) {
+  let id = claudeSessionId;
+  let lines = await load(id);
+  if (!lines) throw new claudeSessionFork.ForkSourceMissingError(id);
+  for (let depth = 0; ; depth++) {
+    try {
+      return { kept: rewindTranscriptLines(lines, action, target), from: id };
+    } catch (error) {
+      if (!(error instanceof ConversationRewindError) || error.code !== "not-found" || depth >= MAX_LINEAGE_DEPTH) throw error;
+      const source = transcriptSourceId(lines, id);
+      const sourceLines = source ? await load(source) : null;
+      if (!source || !sourceLines) throw error;
+      id = source;
+      lines = sourceLines;
+    }
+  }
+}
+async function rewindClaudeTranscript(projectDir, claudeSessionId, action, target) {
+  const { kept } = await rewindAcrossLineage(async (id) => {
+    if (id === claudeSessionId) return readTranscriptLines(projectDir, id);
+    return readTranscriptLines(projectDir, id).catch((error) => {
+      if (error instanceof claudeSessionFork.ForkSourceMissingError) return null;
+      throw error;
+    });
+  }, claudeSessionId, action, target);
   if (kept === null) return null;
   const newId = node_crypto.randomUUID();
   const destination = path$1.join(projectDir, `${newId}.jsonl`);
@@ -2915,6 +2954,7 @@ async function rewindClaudeTranscript(projectDir, claudeSessionId, action, targe
   return newId;
 }
 
+const REQUEST_ID = /^[A-Za-z0-9_-]{1,100}$/;
 const STOP_WAIT_MS = 8e3;
 function createConversationRewind(deps) {
   let inFlight = false;
@@ -2924,6 +2964,7 @@ function createConversationRewind(deps) {
     const action = request.action;
     const sourceId = typeof request.sourceId === "string" && request.sourceId.length > 0 && request.sourceId.length <= 200 ? request.sourceId : void 0;
     const text = typeof request.text === "string" && request.text.length <= 2e5 ? request.text : void 0;
+    const requestId = typeof request.requestId === "string" && REQUEST_ID.test(request.requestId) ? request.requestId : void 0;
     if (action !== "edit" && action !== "delete" || !sourceId && !text?.trim()) {
       return { ok: false, code: "invalid", error: "Invalid rewind request" };
     }
@@ -2940,7 +2981,9 @@ function createConversationRewind(deps) {
       if (!current) return { ok: false, code: "no-conversation", error: "The agent has no conversation to change yet" };
       const uuids = sourceId ? [sourceId, ...deps.aliases(sourceId)] : [];
       const next = await rewrite(deps.projectDir(), current, action, { uuids, text });
+      const recorded = requestId && deps.beginPending ? deps.beginPending({ requestId, action, sourceClaudeSessionId: current, claudeSessionId: next, at: (deps.now ?? Date.now)() }) : null;
       await deps.switchConversation(next);
+      if (recorded) await recorded;
       return { ok: true, action, freshConversation: next === null };
     } catch (error) {
       if (error instanceof ConversationRewindError) return { ok: false, code: error.code, error: error.message };
@@ -2952,7 +2995,326 @@ function createConversationRewind(deps) {
   };
 }
 
+const REWIND_CONFIRM_MS = 12e4;
+function parseRewindRecord(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.requestId !== "string" || !r.requestId) return null;
+  if (r.action !== "edit" && r.action !== "delete") return null;
+  if (typeof r.sourceClaudeSessionId !== "string" || !r.sourceClaudeSessionId) return null;
+  if (r.claudeSessionId !== null && typeof r.claudeSessionId !== "string") return null;
+  if (typeof r.at !== "number" || !Number.isFinite(r.at)) return null;
+  if (typeof r.state !== "string") return null;
+  return {
+    requestId: r.requestId,
+    action: r.action,
+    sourceClaudeSessionId: r.sourceClaudeSessionId,
+    claudeSessionId: r.claudeSessionId,
+    at: r.at,
+    state: r.state
+  };
+}
+function pendingResumeId(claudeArgs) {
+  if (!claudeArgs) return null;
+  const index = claudeArgs.indexOf("--resume");
+  const next = index >= 0 ? claudeArgs[index + 1] : void 0;
+  return next && !next.startsWith("-") && next.includes("-") ? next : null;
+}
+function decideRewind(record, confirmedRequestIds, now, currentClaudeSessionId) {
+  if (!record || record.state !== "pending") return { kind: "none" };
+  if (confirmedRequestIds.has(record.requestId)) return { kind: "confirm" };
+  const deadline = record.at + REWIND_CONFIRM_MS;
+  if (now < deadline) return { kind: "wait", ms: deadline - now };
+  if (currentClaudeSessionId !== record.claudeSessionId) return { kind: "supersede" };
+  return { kind: "revert", to: record.sourceClaudeSessionId };
+}
+function chainRewindRecord(next, pending) {
+  if (!pending || pending.state !== "pending") return next;
+  return { ...next, sourceClaudeSessionId: pending.sourceClaudeSessionId };
+}
+function transcriptDropOf(body) {
+  const b = body;
+  if (b?.role !== "session" || b.content?.type !== "session") return null;
+  const ev = b.content.data?.ev;
+  if (ev?.t !== "transcript-drop" || typeof ev.fromSeq !== "number") return null;
+  return {
+    fromSeq: ev.fromSeq,
+    ...typeof ev.toSeq === "number" ? { toSeq: ev.toSeq } : {},
+    ...typeof ev.requestId === "string" && ev.requestId ? { requestId: ev.requestId } : {}
+  };
+}
+function tombstoneRequestIds(records) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const drop = transcriptDropOf(record.body);
+    if (drop?.requestId) ids.add(drop.requestId);
+  }
+  return ids;
+}
+function visibleUserLocalIds(records) {
+  const drops = [];
+  for (const record of records) {
+    const drop = transcriptDropOf(record.body);
+    if (drop) drops.push({ seq: record.seq, ...drop });
+  }
+  const hidden = (seq) => drops.some((drop) => seq >= drop.fromSeq && seq < (drop.toSeq ?? drop.seq));
+  return records.filter((record) => record.body?.role === "user" && typeof record.localId === "string" && record.localId).filter((record) => !hidden(record.seq)).map((record) => record.localId);
+}
+function transcriptLineage(lines, claudeSessionId) {
+  const promptUuids = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (!line) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof parsed?.uuid === "string" && transcriptPromptText(parsed) !== null) promptUuids.add(parsed.uuid);
+  }
+  return { promptUuids, sourceClaudeSessionId: transcriptSourceId(lines, claudeSessionId) };
+}
+function decideLineageRepair(input) {
+  if (!input.source) return { kind: "none" };
+  const missing = input.visibleLocalIds.filter((id) => !input.current.promptUuids.has(id) && input.source.promptUuids.has(id));
+  if (missing.length === 0) return { kind: "none" };
+  const onlyInCurrent = input.visibleLocalIds.filter((id) => input.current.promptUuids.has(id) && !input.source.promptUuids.has(id));
+  return { kind: "revert", to: input.source.claudeSessionId, missing, onlyInCurrent };
+}
+
+const REWIND_POLL_MS = 15e3;
+class RewindReconciler {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  pending = null;
+  /** The last rewind this process rolled back — a late tombstone re-applies it. */
+  lastReverted = null;
+  confirmedIds = /* @__PURE__ */ new Set();
+  waiters = [];
+  timer = null;
+  checking = null;
+  disposed = false;
+  get pendingRecord() {
+    return this.pending;
+  }
+  /** Synchronously marks the rewind pending; the returned promise is the metadata write. */
+  begin(record) {
+    const next = chainRewindRecord({ ...record, state: "pending" }, this.pending);
+    this.pending = next;
+    this.arm(next);
+    this.deps.log(`[rewind] pending ${next.requestId}: ${next.sourceClaudeSessionId} -> ${next.claudeSessionId ?? "(fresh)"}`);
+    const written = this.deps.writeRecord(next);
+    if (this.confirmedIds.has(next.requestId)) void this.apply(next, { kind: "confirm" });
+    return written;
+  }
+  /** Every inbound session record. */
+  observe(body) {
+    const requestId = transcriptDropOf(body)?.requestId;
+    if (!requestId) return;
+    this.confirmedIds.add(requestId);
+    const record = this.pending;
+    if (record && record.requestId === requestId) {
+      void this.apply(record, { kind: "confirm" });
+      return;
+    }
+    void this.reapplyIfReverted(requestId);
+  }
+  /**
+   * The web hides the turns only AFTER it saw our record, but its tombstone
+   * may still land after the deadline (slow outbox). The log then says
+   * "rewound": follow it, or screen and agent disagree again. Synchronous up
+   * to the abort, so the edited prompt that follows the tombstone is not
+   * dequeued by the old query.
+   */
+  reapplyIfReverted(requestId) {
+    const reverted = this.lastReverted;
+    if (this.pending || reverted?.requestId !== requestId || this.deps.currentClaudeSessionId() !== reverted.sourceClaudeSessionId) {
+      return Promise.resolve();
+    }
+    this.lastReverted = null;
+    this.deps.log(`[rewind] late tombstone for reverted ${requestId}; re-applying the rewind`);
+    return this.deps.switchConversation(reverted.claudeSessionId).then(() => this.deps.writeRecord({ ...reverted, state: "confirmed" })).catch((error) => this.deps.log("[rewind] re-applying failed", error));
+  }
+  /** Resolves when no rewind is pending (or `signal` aborts). */
+  settled(signal) {
+    if (!this.pending || signal?.aborted) return Promise.resolve();
+    return new Promise((resolve) => {
+      const done = () => {
+        signal?.removeEventListener("abort", done);
+        resolve();
+      };
+      this.waiters.push(done);
+      signal?.addEventListener("abort", done, { once: true });
+    });
+  }
+  check() {
+    if (!this.checking) {
+      this.checking = this.runCheck().finally(() => {
+        this.checking = null;
+      });
+    }
+    return this.checking;
+  }
+  /** Wrapper start / resume: decide a leftover pending record, else repair a legacy split. */
+  async startup() {
+    const record = parseRewindRecord(this.deps.readRecord());
+    if (record?.state === "pending") {
+      this.pending = chainRewindRecord(record, this.pending);
+      this.deps.log(`[rewind] startup: pending record ${record.requestId} from ${new Date(record.at).toISOString()}`);
+      await this.check();
+      return;
+    }
+    if (record?.state === "reverted") {
+      this.lastReverted = record;
+      if (tombstoneRequestIds(await this.deps.readLog()).has(record.requestId)) {
+        await this.reapplyIfReverted(record.requestId);
+        return;
+      }
+    }
+    await this.repairLineage();
+  }
+  dispose() {
+    this.disposed = true;
+    this.clearTimer();
+    this.release();
+  }
+  arm(record, ms) {
+    if (this.disposed) return;
+    if (this.timer) clearTimeout(this.timer);
+    const wait = ms ?? Math.min(REWIND_POLL_MS, Math.max(0, decideWaitMs(record, this.deps.now())));
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.check().catch((error) => this.deps.log("[rewind] check failed", error));
+    }, wait);
+    this.timer.unref?.();
+  }
+  async runCheck() {
+    const record = this.pending;
+    if (!record) return;
+    let decision = this.decide(record);
+    if (decision.kind !== "confirm" && decision.kind !== "none") {
+      try {
+        for (const id of tombstoneRequestIds(await this.deps.readLog())) this.confirmedIds.add(id);
+      } catch (error) {
+        this.deps.log("[rewind] reading the session log failed; retrying", error);
+        if (this.pending === record) this.arm(record, REWIND_POLL_MS);
+        return;
+      }
+      if (this.pending !== record) return;
+      decision = this.decide(record);
+    }
+    await this.apply(record, decision);
+  }
+  decide(record) {
+    return decideRewind(record, this.confirmedIds, this.deps.now(), this.deps.currentClaudeSessionId());
+  }
+  async apply(record, decision) {
+    if (this.pending !== record) return;
+    switch (decision.kind) {
+      case "none":
+        this.pending = null;
+        this.release();
+        return;
+      case "wait":
+        this.arm(record);
+        return;
+      case "confirm":
+        this.finish(record, "confirmed");
+        return;
+      case "supersede":
+        this.deps.log(`[rewind] ${record.requestId} unconfirmed but the agent already moved on; closing it`);
+        this.finish(record, "superseded");
+        return;
+      case "revert": {
+        this.deps.log(`[rewind] ${record.requestId} never confirmed by the log; switching back to ${decision.to}`);
+        this.pending = null;
+        this.clearTimer();
+        this.lastReverted = record;
+        try {
+          await this.deps.switchConversation(decision.to);
+        } catch (error) {
+          this.deps.log("[rewind] switching back failed; retrying", error);
+          if (!this.pending && this.lastReverted === record) {
+            this.lastReverted = null;
+            this.pending = record;
+            this.arm(record, REWIND_POLL_MS);
+          }
+          return;
+        }
+        if (this.lastReverted === record) this.record(record, "reverted");
+        if (!this.pending) this.release();
+        return;
+      }
+    }
+  }
+  finish(record, state) {
+    if (this.pending !== record) return;
+    this.pending = null;
+    this.clearTimer();
+    this.lastReverted = null;
+    this.record(record, state);
+    this.release();
+  }
+  record(record, state) {
+    this.deps.log(`[rewind] ${record.requestId} ${state}`);
+    void this.deps.writeRecord({ ...record, state }).catch((error) => this.deps.log("[rewind] recording state failed", error));
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  release() {
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const resolve of waiters) resolve();
+  }
+  async repairLineage() {
+    const current = this.deps.currentClaudeSessionId();
+    if (!current) return;
+    const lines = await this.deps.readTranscript(current);
+    if (!lines) return;
+    const lineage = transcriptLineage(lines, current);
+    if (!lineage.sourceClaudeSessionId) return;
+    const sourceLines = await this.deps.readTranscript(lineage.sourceClaudeSessionId);
+    if (!sourceLines) return;
+    const source = transcriptLineage(sourceLines, lineage.sourceClaudeSessionId);
+    const repair = decideLineageRepair({
+      visibleLocalIds: visibleUserLocalIds(await this.deps.readLog()),
+      current: lineage,
+      source: { claudeSessionId: lineage.sourceClaudeSessionId, promptUuids: source.promptUuids }
+    });
+    if (repair.kind === "none") return;
+    if (this.pending || this.deps.currentClaudeSessionId() !== current) return;
+    this.deps.log(`[rewind] startup: ${current} is an unconfirmed rewound copy (${repair.missing.length} visible prompt(s) only in ${repair.to}); switching back`, {
+      missing: repair.missing,
+      forgottenAfterSplit: repair.onlyInCurrent
+    });
+    await this.deps.switchConversation(repair.to);
+  }
+}
+function decideWaitMs(record, now) {
+  const decision = decideRewind(record, /* @__PURE__ */ new Set(), now, record.claudeSessionId);
+  return decision.kind === "wait" ? decision.ms : 0;
+}
+async function persistRewindRecord(client, record, opts = {}) {
+  const owns = (raw) => {
+    const existing = parseRewindRecord(raw);
+    return record.state === "pending" || !existing || existing.requestId === record.requestId;
+  };
+  if (!owns(client.getMetadata()?.rewind)) return;
+  client.updateMetadata((metadata) => owns(metadata?.rewind) ? { ...metadata, rewind: record } : metadata);
+  const deadline = Date.now() + (opts.timeoutMs ?? 8e3);
+  while (Date.now() < deadline) {
+    const current = parseRewindRecord(client.getMetadata()?.rewind);
+    if (current?.requestId === record.requestId && current.state === record.state) return;
+    await new Promise((resolve) => setTimeout(resolve, opts.pollMs ?? 100));
+  }
+}
+
 const ABORT_INTERRUPT_GRACE_MS = 4e3;
+const REWIND_LOG_WINDOW = 500;
+const REWIND_STARTUP_BUDGET_MS = 15e3;
 async function claudeRemoteLauncher(session, onPermissionModeChange, onEffectivePermissionMode, onPromptFinalized) {
   logger.logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -3054,8 +3416,35 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
     return first;
   };
   let silentRelaunch = false;
+  const agentConversationId = () => session.sessionId ?? pendingResumeId(session.claudeArgs);
+  const switchConversation = async (claudeSessionId) => {
+    if (claudeSessionId) session.onSessionFound(claudeSessionId);
+    else session.clearSessionId();
+    if (!abortController || abortController.signal.aborted) return;
+    silentRelaunch = true;
+    await abort();
+  };
+  const rewindReconciler = new RewindReconciler({
+    now: Date.now,
+    readRecord: () => session.client.getMetadata()?.rewind,
+    writeRecord: (record) => persistRewindRecord(session.client, record),
+    readLog: () => session.client.readLogTail(REWIND_LOG_WINDOW),
+    currentClaudeSessionId: () => agentConversationId(),
+    readTranscript: async (claudeSessionId) => {
+      try {
+        return (await promises.readFile(path$1.join(path.getProjectPath(session.path), `${claudeSessionId}.jsonl`), "utf-8")).split("\n");
+      } catch (error) {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+    },
+    switchConversation,
+    log: (message, data) => logger.logger.debug(message, data)
+  });
+  const observeSessionRecord = (body) => rewindReconciler.observe(body);
+  session.client.on("message", observeSessionRecord);
   session.client.rpcHandlerManager.registerHandler("conversation-rewind", createConversationRewind({
-    claudeSessionId: () => session.sessionId,
+    claudeSessionId: () => agentConversationId(),
     projectDir: () => path.getProjectPath(session.path),
     isThinking: () => session.thinking,
     stopTurn: doAbort,
@@ -3064,12 +3453,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
       const alias = promptAliases.get(sourceId);
       return alias ? [alias] : [];
     },
-    switchConversation: async (claudeSessionId) => {
-      if (claudeSessionId) session.onSessionFound(claudeSessionId);
-      else session.clearSessionId();
-      silentRelaunch = true;
-      await abort();
-    }
+    switchConversation,
+    beginPending: (record) => rewindReconciler.begin(record)
   }));
   let livePermissionModeHandler = null;
   let idlePermissionModeHandler = null;
@@ -3227,6 +3612,10 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   try {
     const modeGate = new LaunchModeGate(session.queue.modeHasher);
     let previousSessionId = null;
+    await Promise.race([
+      rewindReconciler.startup().catch((error) => logger.logger.debug("[rewind] startup reconcile failed", error)),
+      new Promise((resolve) => setTimeout(resolve, REWIND_STARTUP_BUDGET_MS).unref?.())
+    ]);
     while (!exitReason) {
       logger.logger.debug("[remote]: launch");
       messageBuffer$1.addMessage("\u2550".repeat(40), "status");
@@ -3283,6 +3672,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
               if (typeof parked.message === "string") onPromptFinalized?.(parked.message);
               return parked;
             }
+            await rewindReconciler.settled(controller.signal);
             let msg = await session.queue.waitForMessagesAndGetAsString(controller.signal);
             if (msg) {
               if (modeGate.requiresRelaunch(msg.hash, msg.isolate)) {
@@ -3475,6 +3865,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
       }
     }
   } finally {
+    session.client.off("message", observeSessionRecord);
+    rewindReconciler.dispose();
     permissionHandler.reset();
     const t0 = Date.now();
     logger.logger.debug(`[remote]: cleanup begin exitReason=${exitReason} hasInk=${!!inkInstance} rawMode=${process.stdin.isRaw}`);
@@ -3524,7 +3916,7 @@ async function loop(opts) {
     logger.logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await Promise.resolve().then(function () { return require('./claudeLocalLauncher-aQyL3g7I.cjs'); });
+        const { claudeLocalLauncher } = await Promise.resolve().then(function () { return require('./claudeLocalLauncher-DRc-tET5.cjs'); });
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":