@meistrari/remy-cli 1.8.0 → 1.10.0

package/README.md

@@ -36,7 +36,7 @@ The dashboard is the starting point for all interactive work. It refreshes the v
 
 ### Start work
 
-Press `n` in the dashboard. The new-session flow asks what you want done, selects a GitHub installation when needed, suggests repositories based on your request, and lets you review those suggestions. Before creating the session, choose the agent model and reasoning effort. Reasoning starts at `high` by default. Remy then opens the session and streams its activity.
+Press `n` in the dashboard. The new-session flow asks what you want done, selects a GitHub installation when needed, suggests repositories based on your request, and lets you review those suggestions. Before creating the session, choose the agent model and reasoning effort. The wizard starts with `gpt-6-astra` and `medium` reasoning by default. Remy then opens the session and streams its activity.
 
 Use `Tab` while writing the request to complete a local file path. Remy attaches selected paths when you confirm the request. On macOS, `Ctrl+V` adds a PNG from the system clipboard to the request; Remy attaches it on confirmation. Remy uploads files before creating the session.
 
@@ -44,6 +44,8 @@ Use `Tab` while writing the request to complete a local file path. Remy attaches
 
 Use Up/Down to select a session in the dashboard, Left/Right to load the adjacent page, and `Enter` to open it. After the dashboard list or repository-review list has focus, Vim keys work too: `j`/`k` move, `h`/`l` go to the previous/next dashboard page (or clear/mark a repository), `G` goes to the last row, and `gg` goes to the first row. Press `Shift+L` in the dashboard to start a logout confirmation. In a session, type a follow-up and press `Enter` to send it.
 
+The **Live reasoning preview** shows the newest main-agent summary as it arrives. It is a short, best-effort preview—not private chain-of-thought. Long previews show **Preview shortened.** Opening or reconnecting partway through a summary may show no preview; the final summary still appears in activity history. Disconnecting or finishing the item clears the live preview.
+
 Published files and Tela Pages appear in the timeline. A Tela Page row includes its title and canonical URL so you can open it directly from the terminal.
 
 When Remy creates a plan, the session shows its checklist in the timeline and keeps `Plan <done>/<total>` with the current item pinned above the composer. Updates change the same checklist instead of producing repeated rows, and an unfinished plan remains visible after reconnecting or between turns. The collapsed timeline shows up to five plan items; press `Ctrl+O` for the complete checklist and activity detail.
@@ -74,7 +76,7 @@ The interactive dashboard is the recommended path. Use these commands when a scr
 remy new --repository owner/repository "Add a health check endpoint"
 ```
 
-Repeat `--repository` to select more repositories from the same GitHub installation. If you do not select a repository, supply `--installation <github-installation-id>`. Repeat `--attach <path>` to upload files. Direct creation uses `high` reasoning unless `--reasoning-effort` overrides it. `remy new` creates the session from the prompt and flags, then opens it when the terminal is interactive.
+Repeat `--repository` to select more repositories from the same GitHub installation. If you do not select a repository, supply `--installation <github-installation-id>`. Repeat `--attach <path>` to upload files. Direct creation uses `medium` reasoning unless `--reasoning-effort` overrides it; omit `--model` to use the server's `gpt-6-astra` default. `remy new` creates the session from the prompt and flags, then opens it when the terminal is interactive.
 
 ### Open a known session
 

package/dist/remy.js

@@ -32083,11 +32083,13 @@ var agentCommandSchema = zod_default2.union([
 ]);
 // ../../packages/agents-protocol/src/agent-model.ts
 var codexModelIds = [
+  "gpt-6-astra",
   "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
   "gpt-5.5",
   "gpt-5.4",
   "gpt-5.4-mini",
-  "gpt-5.3-codex",
   "gpt-5.2"
 ];
 var claudeModelIds = [
@@ -32553,41 +32555,55 @@ var agentEventSchema = zod_default2.discriminatedUnion("type", [
 // ../../packages/agents-protocol/src/agent-presentation.ts
 var CODEX_CONTEXT_WINDOW = 272000;
 var codexModelPresentation = {
+  "gpt-6-astra": {
+    label: "GPT 6.0 Astra",
+    description: "Our most capable model for complex, demanding work.",
+    relativeCost: 5,
+    maxInputTokens: CODEX_CONTEXT_WINDOW,
+    isMultiModal: true
+  },
   "gpt-5.6-sol": {
-    label: "GPT-5.6-Sol",
-    description: "Latest frontier agentic coding model.",
+    label: "GPT 5.6 Sol",
+    description: "Reliable agentic workhorse for everyday tasks.",
     relativeCost: 5,
     maxInputTokens: CODEX_CONTEXT_WINDOW,
     isMultiModal: true
   },
+  "gpt-5.6-terra": {
+    label: "GPT 5.6 Terra",
+    description: "Balanced agentic coding model for everyday work.",
+    relativeCost: 3,
+    maxInputTokens: CODEX_CONTEXT_WINDOW,
+    isMultiModal: true
+  },
+  "gpt-5.6-luna": {
+    label: "GPT 5.6 Luna",
+    description: "Fast and affordable agentic coding model.",
+    relativeCost: 2,
+    maxInputTokens: CODEX_CONTEXT_WINDOW,
+    isMultiModal: true
+  },
   "gpt-5.5": {
-    label: "GPT-5.5",
-    description: "Frontier model for complex coding, research, and real-world work.",
+    label: "GPT 5.5",
+    description: "Proven previous-generation model for coding and general work.",
     relativeCost: 4,
     maxInputTokens: CODEX_CONTEXT_WINDOW,
     isMultiModal: true
   },
   "gpt-5.4": {
-    label: "GPT-5.4",
+    label: "GPT 5.4",
     description: "Strong model for everyday coding.",
     relativeCost: 3,
     maxInputTokens: CODEX_CONTEXT_WINDOW,
     isMultiModal: true
   },
   "gpt-5.4-mini": {
-    label: "GPT-5.4-Mini",
+    label: "GPT 5.4 Mini",
     description: "Small, fast, and cost-efficient model for simpler coding tasks.",
     relativeCost: 2,
     maxInputTokens: CODEX_CONTEXT_WINDOW,
     isMultiModal: true
   },
-  "gpt-5.3-codex": {
-    label: "GPT-5.3-Codex",
-    description: "Code-tuned model for focused engineering tasks.",
-    relativeCost: 3,
-    maxInputTokens: CODEX_CONTEXT_WINDOW,
-    isMultiModal: true
-  },
   "gpt-5.2": {
     label: "GPT-5.2",
     description: "Optimized for professional work and long-running agents.",
@@ -32991,7 +33007,8 @@ async function* streamSessionEvents({
   sessionId,
   lastRetainedEventId,
   maxReconnects = 0,
-  signal
+  signal,
+  onSynchronized
 }) {
   let retainedCursor = lastRetainedEventId;
   let reconnects = 0;
@@ -33005,7 +33022,7 @@ async function* streamSessionEvents({
     });
     if (!response.body)
       throw new CodingAgentProtocolError("Session event stream response did not include a readable body.");
-    for await (const frame of parseSessionEventStream(response.body)) {
+    for await (const frame of parseSessionEventStream(response.body, { onSynchronized })) {
       if (frame.kind === "retained")
         retainedCursor = frame.id;
       yield frame;
@@ -33015,21 +33032,33 @@ async function* streamSessionEvents({
     reconnects += 1;
   }
 }
-async function* parseSessionEventStream(stream) {
-  for await (const message of parseServerSentEvents(stream)) {
+async function* parseSessionEventStream(stream, { onSynchronized } = {}) {
+  for await (const message of parseServerSentEvents(stream, { onSynchronized })) {
     if (message.event !== undefined && message.event !== "session-event")
       continue;
     yield parseSessionEventMessage(message);
   }
 }
-async function* parseServerSentEvents(stream) {
+async function* parseServerSentEvents(stream, { onSynchronized }) {
   const decoder2 = new TextDecoder;
   const reader = stream.getReader();
   let buffer = "";
   let messageId;
   let eventName;
   let dataLines = [];
-  function dispatch() {
+  let frameLineCount = 0;
+  let hasSynchronizationComment = false;
+  let synchronized = false;
+  function dispatch(completeFrame) {
+    const isSynchronizationFrame = completeFrame && frameLineCount === 1 && hasSynchronizationComment;
+    frameLineCount = 0;
+    hasSynchronizationComment = false;
+    if (isSynchronizationFrame) {
+      if (synchronized)
+        throw new CodingAgentProtocolError("Session event stream contained more than one synchronization marker.");
+      synchronized = true;
+      onSynchronized?.();
+    }
     if (dataLines.length === 0) {
       messageId = undefined;
       eventName = undefined;
@@ -33048,7 +33077,10 @@ async function* parseServerSentEvents(stream) {
   }
   function applyLine(line) {
     if (line === "")
-      return dispatch();
+      return dispatch(true);
+    frameLineCount += 1;
+    if (line === ": synchronized")
+      hasSynchronizationComment = true;
     if (line.startsWith(":"))
       return null;
     const separatorIndex = line.indexOf(":");
@@ -33086,7 +33118,7 @@ async function* parseServerSentEvents(stream) {
       if (message)
         yield message;
     }
-    const finalMessage = dispatch();
+    const finalMessage = dispatch(false);
     if (finalMessage)
       yield finalMessage;
   } finally {
@@ -33696,8 +33728,8 @@ function newSessionReasoningEffortLabel(effort) {
 var newSessionModels = codexModelIds;
 var newSessionReasoningEfforts = selectableAgentReasoningEfforts;
 var defaultNewSessionAgent = {
-  model: codexModelIds[0],
-  reasoningEffort: "high"
+  model: "gpt-6-astra",
+  reasoningEffort: "medium"
 };
 
 // src/sessions/session-controller.ts
@@ -33860,10 +33892,6 @@ var agentMessageDeltaEventSchema = exports_external2.object({
   type: exports_external2.literal("agent.message.delta"),
   payload: exports_external2.object({ role: exports_external2.string(), delta: exports_external2.string() }).passthrough()
 }).passthrough();
-var agentReasoningSummaryDeltaEventSchema = exports_external2.object({
-  type: exports_external2.literal("agent.reasoning.summary.delta"),
-  payload: exports_external2.object({ text: exports_external2.string() }).passthrough()
-}).passthrough();
 var publicMessageContentSegmentSchema = exports_external2.discriminatedUnion("type", [
   exports_external2.strictObject({ type: exports_external2.literal("text"), text: exports_external2.string() }),
   exports_external2.strictObject({
@@ -33966,13 +33994,6 @@ function projectEphemeralEvent({ state, event }) {
       previews: { ...state.previews, assistantText: state.previews.assistantText + messageDelta.data.payload.delta }
     };
   }
-  const reasoningDelta = agentReasoningSummaryDeltaEventSchema.safeParse(event);
-  if (reasoningDelta.success) {
-    return {
-      ...state,
-      previews: { ...state.previews, reasoningText: state.previews.reasoningText + reasoningDelta.data.payload.text }
-    };
-  }
   return state;
 }
 function projectRetainedEvent({
@@ -34120,8 +34141,7 @@ function projectDurableAgentEvent({ state, event, occurredAt, retainedEventId })
     retainedTurnStarts: { ...state.retainedTurnStarts, [agentEvent.turnId]: { actorType: agentEvent.actor.type, startedAt: occurredAt } },
     messageTurns: Object.fromEntries(Object.entries(state.messageTurns).map(([messageId, turn]) => [messageId, turn.turnId === agentEvent.turnId ? { ...turn, startedAt: occurredAt } : turn]))
   } : state;
-  const stateWithCompletedReasoning = agentEvent.type === "agent.reasoning.ended" ? { ...stateWithTurnStart, previews: { ...stateWithTurnStart.previews, reasoningText: "" } } : stateWithTurnStart;
-  return appendActivity({ state: stateWithCompletedReasoning, retainedEventId, occurredAt, card: toAgentActivityCard(agentEvent) });
+  return appendActivity({ state: stateWithTurnStart, retainedEventId, occurredAt, card: toAgentActivityCard(agentEvent) });
 }
 function projectAgentWorkObserved({
   state,
@@ -34311,6 +34331,16 @@ var terminalControlPattern = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
 function stripAnsi(value) {
   return value.replace(ansiEscapePattern, "").replace(terminalControlPattern, "");
 }
+function formatReasoningPreview(item) {
+  if (item.status === "absent")
+    return "";
+  const preview = stripAnsi(item.text).trim();
+  if (!item.truncated)
+    return preview;
+  return preview.length > 0 ? `${preview}
+
+Preview shortened.` : "Preview shortened.";
+}
 function providerText(raw, fallback) {
   const cleaned = stripAnsi(raw ?? "").trim();
   return cleaned.length > 0 ? cleaned : fallback;
@@ -34328,6 +34358,127 @@ function toSessionPullRequest(detail) {
   return pullRequest ? { number: pullRequest.number, status: pullRequest.status, draft: pullRequest.draft } : null;
 }
 
+// src/sessions/reasoning-preview.ts
+var maximumPrefixLength = 2000;
+var absentItem = { status: "absent" };
+function initialReasoningPreviewState() {
+  return {
+    synchronized: false,
+    sequenceFloor: -1,
+    runtime: "active",
+    lastSessionStartedEventId: null,
+    item: absentItem
+  };
+}
+function reduceReasoningPreview(state, input) {
+  if (input.type === "synchronized")
+    return state.synchronized ? state : { ...state, synchronized: true };
+  const event = input.event;
+  if (event.type === "agent.session.started") {
+    if (event.eventId === state.lastSessionStartedEventId)
+      return state;
+    return {
+      ...state,
+      sequenceFloor: event.sequence,
+      runtime: "active",
+      lastSessionStartedEventId: event.eventId,
+      item: absentItem
+    };
+  }
+  if (event.type === "agent.session.ended") {
+    return {
+      ...state,
+      sequenceFloor: Math.max(state.sequenceFloor, event.sequence),
+      runtime: "ended",
+      item: absentItem
+    };
+  }
+  if (!isMainReasoningOrTurnEvent(event) || state.runtime === "ended")
+    return state;
+  const matchingRetainedEnd = state.item.status === "active" && state.item.turnId === event.turnId && (event.type === "agent.turn.ended" || event.type === "agent.reasoning.ended" && state.item.reasoningId === event.payload.reasoningId);
+  if (event.sequence <= state.sequenceFloor && !matchingRetainedEnd)
+    return state;
+  const advancedState = { ...state, sequenceFloor: Math.max(state.sequenceFloor, event.sequence) };
+  switch (event.type) {
+    case "agent.reasoning.started": {
+      if (!state.synchronized)
+        return advancedState;
+      if (state.item.status === "active" && sameReasoningItem({ item: state.item, turnId: event.turnId, reasoningId: event.payload.reasoningId })) {
+        return advancedState;
+      }
+      return {
+        ...advancedState,
+        item: {
+          status: "active",
+          turnId: event.turnId,
+          reasoningId: event.payload.reasoningId,
+          text: "",
+          truncated: false
+        }
+      };
+    }
+    case "agent.reasoning.summary.delta": {
+      if (state.item.status !== "active" || !sameReasoningItem({ item: state.item, turnId: event.turnId, reasoningId: event.payload.reasoningId })) {
+        return advancedState;
+      }
+      return {
+        ...advancedState,
+        item: appendBoundedPrefix(state.item, event.payload.text)
+      };
+    }
+    case "agent.reasoning.ended": {
+      if (state.item.status !== "active" || !sameReasoningItem({ item: state.item, turnId: event.turnId, reasoningId: event.payload.reasoningId })) {
+        return advancedState;
+      }
+      return { ...advancedState, item: absentItem };
+    }
+    case "agent.turn.started": {
+      if (state.item.status === "active" && state.item.turnId !== event.turnId)
+        return { ...advancedState, item: absentItem };
+      return advancedState;
+    }
+    case "agent.turn.ended": {
+      if (state.item.status === "active" && state.item.turnId === event.turnId)
+        return { ...advancedState, item: absentItem };
+      return advancedState;
+    }
+  }
+}
+function isMainReasoningOrTurnEvent(event) {
+  if (event.type !== "agent.reasoning.started" && event.type !== "agent.reasoning.summary.delta" && event.type !== "agent.reasoning.ended" && event.type !== "agent.turn.started" && event.type !== "agent.turn.ended") {
+    return false;
+  }
+  return event.actor.type === "main";
+}
+function sameReasoningItem({
+  item,
+  turnId,
+  reasoningId
+}) {
+  return item.turnId === turnId && item.reasoningId === reasoningId;
+}
+function appendBoundedPrefix(item, text) {
+  if (item.truncated)
+    return item;
+  const availableLength = maximumPrefixLength - item.text.length;
+  let retainedLength = Math.min(availableLength, text.length);
+  const reachesSizeBound = item.text.length + retainedLength === maximumPrefixLength;
+  if (reachesSizeBound && retainedLength > 0 && isHighSurrogate(text.charCodeAt(retainedLength - 1)))
+    retainedLength -= 1;
+  const discardedInput = retainedLength < text.length;
+  if (retainedLength === 0) {
+    return discardedInput && !item.truncated ? { ...item, truncated: true } : item;
+  }
+  return {
+    ...item,
+    text: item.text + text.slice(0, retainedLength),
+    truncated: item.truncated || discardedInput
+  };
+}
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 55296 && codeUnit <= 56319;
+}
+
 // src/sessions/session-controller.ts
 var remoteSessionReconnectPolicy = {
   initialBackoffMs: 1000,
@@ -34366,6 +34517,9 @@ function createRemoteSessionController(dependencies) {
   let stopped = false;
   let state;
   let cachedLastRetainedEventId;
+  let reasoningPreviewState = initialReasoningPreviewState();
+  let reasoningConnectionGeneration = 0;
+  let reasoningHistorySequenceFloor = -1;
   async function start(input) {
     stopped = false;
     ready = new Promise((resolve) => {
@@ -34379,14 +34533,17 @@ function createRemoteSessionController(dependencies) {
     });
     resolveReady();
     publishState();
-    if (input.mode === "cold-resume")
-      await hydrateRetainedHistoryFromBeginning();
+    if (input.mode === "cold-resume") {
+      const hydrationGeneration = beginReasoningAttempt();
+      await hydrateRetainedHistoryFromBeginning(hydrationGeneration);
+    }
     await streamWithControllerReconnects();
   }
   function stop() {
     if (stopped)
       return;
     stopped = true;
+    invalidateReasoningAttempt({ publish: true });
     abortController.abort(new Error("Remote session controller stopped."));
   }
   function subscribe(listener) {
@@ -34421,10 +34578,14 @@ function createRemoteSessionController(dependencies) {
     publishState();
   }
   function updateDetail(detail) {
+    if (detail.status !== "open")
+      invalidateReasoningAttempt({ publish: false });
     state = updateSessionDetail({ state: getState(), detail });
+    if (detail.status !== "open")
+      state = withoutReasoningPreview(state);
     publishState();
   }
-  async function hydrateRetainedHistoryFromBeginning() {
+  async function hydrateRetainedHistoryFromBeginning(generation) {
     let after;
     while (true) {
       if (stopped)
@@ -34436,10 +34597,13 @@ function createRemoteSessionController(dependencies) {
       });
       for (const item of page.data) {
         await reduceFrameAndPersist({
-          kind: "retained",
-          id: String(item.history_sequence),
-          event: "session-event",
-          data: item
+          frame: {
+            kind: "retained",
+            id: String(item.history_sequence),
+            event: "session-event",
+            data: item
+          },
+          generation
         });
       }
       if (!page.has_more || !page.next_cursor)
@@ -34453,27 +34617,33 @@ function createRemoteSessionController(dependencies) {
     while (true) {
       if (stopped)
         return;
+      const generation = beginReasoningAttempt();
       state = markSessionConnected(getState());
       publishState();
       try {
         const stream = await dependencies.openEventStream({
           sessionId: dependencies.sessionId,
           lastRetainedEventId: cachedLastRetainedEventId,
-          signal: abortController.signal
+          signal: abortController.signal,
+          onSynchronized: () => synchronizeReasoningAttempt(generation)
         });
         for await (const frame of stream) {
           if (stopped)
             return;
-          await reduceFrameAndPersist(frame);
+          await reduceFrameAndPersist({ frame, generation });
         }
+        endReasoningAttempt(generation);
       } catch (error93) {
+        endReasoningAttempt(generation);
         if (stopped)
           return;
         if (error93 instanceof Error && error93.name === "SessionProjectionProtocolError")
           throw error93;
+        const refreshGeneration = reasoningConnectionGeneration;
         const detail = await dependencies.getSession({ sessionId: dependencies.sessionId });
-        state = updateSessionDetail({ state: getState(), detail });
-        publishState();
+        if (stopped || refreshGeneration !== reasoningConnectionGeneration)
+          return;
+        updateDetail(detail);
       }
       if (stopped)
         return;
@@ -34499,17 +34669,86 @@ function createRemoteSessionController(dependencies) {
       backoffMs = Math.min(backoffMs * 2, reconnectPolicy.maxBackoffMs);
     }
   }
-  async function reduceFrameAndPersist(frame) {
-    const nextState = projectRemoteSessionEvent({ state: getState(), frame });
+  async function reduceFrameAndPersist({ frame, generation }) {
+    const previousState = getState();
+    const projectedState = projectRemoteSessionEvent({ state: previousState, frame });
+    state = projectReasoningPreview({ previousState, projectedState, frame, generation });
     if (frame.kind === "retained") {
-      state = nextState;
       await writeCache();
-      cachedLastRetainedEventId = nextState.lastRetainedEventId;
+      cachedLastRetainedEventId = projectedState.lastRetainedEventId;
     }
-    state = nextState;
     resolveCompletedWaiters();
+    if (stopped)
+      return;
     publishState(frame);
   }
+  function projectReasoningPreview({
+    previousState,
+    projectedState,
+    frame,
+    generation
+  }) {
+    if (generation !== reasoningConnectionGeneration || projectedState.aggregateStatus !== "open")
+      return withoutReasoningPreview(projectedState);
+    if (frame.kind === "retained") {
+      if (previousState.seenRetainedEventIds[frame.id])
+        return projectedState;
+      if (frame.data.history_sequence <= reasoningHistorySequenceFloor)
+        return projectedState;
+      reasoningHistorySequenceFloor = frame.data.history_sequence;
+    } else if (frame.data.event.type !== "agent.reasoning.summary.delta") {
+      return projectedState;
+    }
+    if (frame.data.event.type === "agent.message.ended")
+      return projectedState;
+    const parsed = wrappedAgentEventSchema.safeParse(frame.data.event);
+    if (!parsed.success)
+      return projectedState;
+    reasoningPreviewState = reduceReasoningPreview(reasoningPreviewState, { type: "event", event: parsed.data });
+    return {
+      ...projectedState,
+      previews: {
+        ...projectedState.previews,
+        reasoningText: formatReasoningPreview(reasoningPreviewState.item)
+      }
+    };
+  }
+  function beginReasoningAttempt() {
+    reasoningConnectionGeneration += 1;
+    reasoningPreviewState = initialReasoningPreviewState();
+    reasoningHistorySequenceFloor = -1;
+    if (state)
+      state = withoutReasoningPreview(state);
+    return reasoningConnectionGeneration;
+  }
+  function synchronizeReasoningAttempt(generation) {
+    if (stopped || generation !== reasoningConnectionGeneration || getState().aggregateStatus !== "open")
+      return;
+    reasoningPreviewState = reduceReasoningPreview(reasoningPreviewState, { type: "synchronized" });
+  }
+  function endReasoningAttempt(generation) {
+    if (generation !== reasoningConnectionGeneration)
+      return;
+    invalidateReasoningAttempt({ publish: true });
+  }
+  function invalidateReasoningAttempt({ publish }) {
+    reasoningConnectionGeneration += 1;
+    reasoningPreviewState = initialReasoningPreviewState();
+    reasoningHistorySequenceFloor = -1;
+    if (!state || state.previews.reasoningText.length === 0)
+      return;
+    state = withoutReasoningPreview(state);
+    if (publish)
+      publishState();
+  }
+  function withoutReasoningPreview(currentState) {
+    if (currentState.previews.reasoningText.length === 0)
+      return currentState;
+    return {
+      ...currentState,
+      previews: { ...currentState.previews, reasoningText: "" }
+    };
+  }
   async function writeCache() {
     const currentState = getState();
     const cache = {
@@ -37545,7 +37784,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.8.0";
+var remyCliVersion = "1.10.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,
@@ -38798,7 +39037,7 @@ async function runAttachedSession({
     environment: dependencies.environment,
     getSession: async ({ sessionId: id }) => await operations.getSession({ client: operations.client, sessionId: id }),
     listSessionEvents: async ({ sessionId: id, limit, after }) => await operations.listSessionEvents({ client: operations.client, sessionId: id, limit, after }),
-    openEventStream: ({ sessionId: id, lastRetainedEventId, signal }) => operations.streamSessionEvents({ client: operations.client, sessionId: id, lastRetainedEventId, signal })
+    openEventStream: ({ sessionId: id, lastRetainedEventId, signal, onSynchronized }) => operations.streamSessionEvents({ client: operations.client, sessionId: id, lastRetainedEventId, signal, onSynchronized })
   });
   const interactive = !noTui && !json3 && isInteractiveTerminal(dependencies);
   const shouldPrintJson = !interactive || json3;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meistrari/remy-cli",
-    "version": "1.8.0",
+    "version": "1.10.0",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {