@meistrari/remy-cli 1.8.0 → 1.9.0

package/README.md

@@ -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.

package/dist/remy.js

@@ -32991,7 +32991,8 @@ async function* streamSessionEvents({
   sessionId,
   lastRetainedEventId,
   maxReconnects = 0,
-  signal
+  signal,
+  onSynchronized
 }) {
   let retainedCursor = lastRetainedEventId;
   let reconnects = 0;
@@ -33005,7 +33006,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 +33016,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 +33061,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 +33102,7 @@ async function* parseServerSentEvents(stream) {
       if (message)
         yield message;
     }
-    const finalMessage = dispatch();
+    const finalMessage = dispatch(false);
     if (finalMessage)
       yield finalMessage;
   } finally {
@@ -33860,10 +33876,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 +33978,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 +34125,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 +34315,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 +34342,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 +34501,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 +34517,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 +34562,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 +34581,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 +34601,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 +34653,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 +37768,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.8.0";
+var remyCliVersion = "1.9.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,
@@ -38798,7 +39021,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.9.0",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {