very-happy-cli 0.2.162 → 0.2.164

package/dist/{runClaudeDeps-QaEx8y5r.mjs → runClaudeDeps-JG7EUH7B.mjs}

@@ -1,50 +1,50 @@
-import { l as logger } from './logger-CGE4C8ho.mjs';
-import { k as notifyDaemonSessionEvent, m as notifyDaemonClaudeAuthFailed } from './controlClient-CYzHrh3e.mjs';
-export { g as reportSessionEditToDaemon } from './controlClient-CYzHrh3e.mjs';
+import { l as logger } from './logger-8dtZPn3n.mjs';
+import { k as notifyDaemonSessionEvent, m as notifyDaemonClaudeAuthFailed } from './controlClient-DzmCQrY_.mjs';
+export { g as reportSessionEditToDaemon } from './controlClient-DzmCQrY_.mjs';
 import { s as sameBackgroundTasks, c as createBackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
 import { randomInt, randomUUID, createHash } from 'node:crypto';
 import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
 import { query } from './index-B6UGRQ7h.mjs';
 import { AbortError } from '@anthropic-ai/claude-agent-sdk';
 import { m as mapToClaudeMode, p as parseClaudePermissionMode, c as resolveRemoteClaudePermissionMode } from './permissionMode-CH4FoZfU.mjs';
-import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-DsQoUgQw.mjs';
+import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-D0KMySrK.mjs';
 import { join, resolve, dirname } from 'node:path';
 import { p as parseSpecialCommand } from './specialCommands-BSqhYg5X.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
-import { A as AsyncLock } from './attachmentLimits-D5pgmASK.mjs';
+import { A as AsyncLock } from './attachmentLimits-B8nzhw-i.mjs';
 import 'tweetnacl';
-import { c as configuration, e as ensurePrivateDirectory } from './configuration-A5gW_0GE.mjs';
-import './index-BBg9j0XK.mjs';
-import './registerCommonHandlers-Ckv5boQI.mjs';
+import { c as configuration, e as ensurePrivateDirectory } from './configuration-CiBUH72C.mjs';
+import './index-vVWpCoTr.mjs';
+import './registerCommonHandlers-bSskMveZ.mjs';
 import 'os';
 import 'child_process';
 import '@paralleldrive/cuid2';
-import './persistence-Cw8aLoyL.mjs';
+import './persistence-C_xFQLsD.mjs';
 import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { access } from 'fs/promises';
-import { d as delay } from './time-CVvxdEDh.mjs';
+import { d as delay } from './time-CRvAaC5H.mjs';
 import { mkdirSync, writeFileSync, readFileSync, unlinkSync, renameSync, statSync, existsSync } from 'node:fs';
-import { h as hashObject, i as isSelfReportFresh } from './deterministicJson-DiR7EOMO.mjs';
-export { c as createSelfReportState, s as startHappyServer } from './deterministicJson-DiR7EOMO.mjs';
-import { F as Future } from './sessionScanner-Cdukzo70.mjs';
-export { c as createSessionScanner } from './sessionScanner-Cdukzo70.mjs';
+import { h as hashObject, i as isSelfReportFresh } from './deterministicJson-CKqT3awl.mjs';
+export { c as createSelfReportState, s as startHappyServer } from './deterministicJson-CKqT3awl.mjs';
+import { F as Future } from './sessionScanner-Ct-JoNHP.mjs';
+export { c as createSessionScanner } from './sessionScanner-Ct-JoNHP.mjs';
 import { execSync } from 'node:child_process';
-import { S as StreamRelay } from './streamRelay-BLgU9X3R.mjs';
-import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-s1xPha4Q.mjs';
-import { readFile, writeFile, rename, unlink } from 'node:fs/promises';
-import { F as ForkSourceMissingError } from './claudeSessionFork-_DUrXaqd.mjs';
-export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-Cll4-o8Y.mjs';
-export { g as getEnvironmentInfo } from './doctor-FuCvKdRa.mjs';
+import { S as StreamRelay } from './streamRelay-BzMEEvJU.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, c as chatAttachmentDirectory, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-BLyyo1al.mjs';
+import { writeFile, rename, unlink, readFile } from 'node:fs/promises';
+import { F as ForkSourceMissingError } from './claudeSessionFork-BfPW9D2S.mjs';
+export { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-Ben5lAsN.mjs';
+export { g as getEnvironmentInfo } from './doctor-CSgzbG5L.mjs';
 import { createServer } from 'node:http';
 export { E as EditReportThrottle, b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
-import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-B4AW3dLr.mjs';
-export { T as TitleGenerator } from './titleGenerator-B4AW3dLr.mjs';
+import { r as resolveClaudeBinary, a as runClaudeOneShot } from './titleGenerator-CUG-n2r3.mjs';
+export { T as TitleGenerator } from './titleGenerator-CUG-n2r3.mjs';
 import { B as BOARD_ANALYZER_PROMPT_PREFIX } from './oneShotPrompts-DT4p6RNd.mjs';
 import 'node:util';
 import './smallFastModel-BLNgMrwR.mjs';
@@ -52,33 +52,33 @@ import './trimIdent-BAjmv_TG.mjs';
 import 'node:os';
 import './agentGuidance-CQuNlNx8.mjs';
 import 'zod';
-import './package-DQsvY1XN.mjs';
+import './package-tVYgFJoK.mjs';
 import 'util';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
 import './authRelay-DSAvg1uv.mjs';
-import './client-Dk7x-s-O.mjs';
-import './context-BXnxalWW.mjs';
-import './sessionOps-CdwVPSZz.mjs';
+import './client-Do5CHQnZ.mjs';
+import './context-BpEYcuLv.mjs';
+import './sessionOps-BlMg1uAa.mjs';
 import './resources-BdFBQi8r.mjs';
-import './tools-_kFe4m_l.mjs';
-import './tools-BA1qkiV1.mjs';
-import './client-DwqHDsLb.mjs';
-import './peerTools-D19hhSQF.mjs';
+import './tools-RvMKw7yx.mjs';
+import './tools-gUjkPpCw.mjs';
+import './client-DkoV3VWl.mjs';
+import './peerTools-C1cduHh1.mjs';
 import './ids-DU6sLx4C.mjs';
-import './remoteSessionClient-BMjsbuBh.mjs';
+import './remoteSessionClient-DnCIuZpQ.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import './limits-DIo7rEBR.mjs';
-import './assistantTools-mEz6uNqL.mjs';
+import './assistantTools-BWfAV349.mjs';
 import './terminals-Dlg0x3nY.mjs';
 import './terminalTitleSuggest-CeKsX_V6.mjs';
 import './tmuxSocket-B8Yx20sT.mjs';
-import './bootstrap-BKmsYSwh.mjs';
+import './bootstrap-CTNjn_aj.mjs';
 import './previewPath-CXN4Vag0.mjs';
-import './sync-BpLasLu2.mjs';
-import './startFileWatcher-COD5UKNs.mjs';
+import './sync-SCvDzRy6.mjs';
+import './startFileWatcher-Csql7gdv.mjs';
 import 'node:readline';
 import './doctor-BPkYWSuq.mjs';
 import 'ps-list';
@@ -2893,16 +2893,55 @@ function rewindTranscriptLines(lines, action, target) {
   });
   return [...before.map((entry) => entry.line), ...relinked];
 }
-async function rewindClaudeTranscript(projectDir, claudeSessionId, action, target) {
-  const source = 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 = join(projectDir, `${claudeSessionId}.jsonl`);
   try {
-    raw = await readFile(source, "utf-8");
+    return (await readFile(path, "utf-8")).split("\n");
   } catch (error) {
-    if (error.code === "ENOENT") throw new ForkSourceMissingError(source);
+    if (error.code === "ENOENT") throw new 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 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 ForkSourceMissingError) return null;
+      throw error;
+    });
+  }, claudeSessionId, action, target);
   if (kept === null) return null;
   const newId = randomUUID();
   const destination = join(projectDir, `${newId}.jsonl`);
@@ -2917,6 +2956,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;
@@ -2926,6 +2966,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" };
     }
@@ -2942,7 +2983,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 };
@@ -2954,7 +2997,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.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -3056,8 +3418,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 readFile(join(getProjectPath(session.path), `${claudeSessionId}.jsonl`), "utf-8")).split("\n");
+      } catch (error) {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+    },
+    switchConversation,
+    log: (message, data) => 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: () => getProjectPath(session.path),
     isThinking: () => session.thinking,
     stopTurn: doAbort,
@@ -3066,12 +3455,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;
@@ -3229,6 +3614,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.debug("[rewind] startup reconcile failed", error)),
+      new Promise((resolve) => setTimeout(resolve, REWIND_STARTUP_BUDGET_MS).unref?.())
+    ]);
     while (!exitReason) {
       logger.debug("[remote]: launch");
       messageBuffer.addMessage("\u2550".repeat(40), "status");
@@ -3285,6 +3674,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)) {
@@ -3477,6 +3867,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
       }
     }
   } finally {
+    session.client.off("message", observeSessionRecord);
+    rewindReconciler.dispose();
     permissionHandler.reset();
     const t0 = Date.now();
     logger.debug(`[remote]: cleanup begin exitReason=${exitReason} hasInk=${!!inkInstance} rawMode=${process.stdin.isRaw}`);
@@ -3526,7 +3918,7 @@ async function loop(opts) {
     logger.debug(`[loop] Iteration with mode: ${mode}`);
     switch (mode) {
       case "local": {
-        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-BFfGT4eY.mjs');
+        const { claudeLocalLauncher } = await import('./claudeLocalLauncher-CKazNnl0.mjs');
         const result = await claudeLocalLauncher(session);
         switch (result.type) {
           case "switch":