@super-one/cli 0.75.1 → 0.75.2

package/MANIFEST.json

@@ -1,7 +1,7 @@
 {
   "name": "@super-one/cli",
-  "version": "0.75.1",
+  "version": "0.75.2",
   "kind": "npm",
   "minNodeMajor": 20,
-  "builtAt": "2026-10-19T10:32:17.176Z"
+  "builtAt": "2026-10-19T19:21:56.991Z"
 }

package/lib/cli.mjs

@@ -137,8 +137,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.75.1".trim()) {
-    return "0.75.1".trim();
+  if ("0.75.2".trim()) {
+    return "0.75.2".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -5325,6 +5325,20 @@ var init_session_messages = __esm({
   }
 });
 
+// ../../packages/shared/src/environment/transcript-window.ts
+function desktopShowsSession(holders) {
+  return holders.some((holder) => holder.startsWith(DESKTOP_WINDOW_HOLDER_PREFIX));
+}
+var TRANSCRIPT_WINDOW_SCHEMA, TRANSCRIPT_WINDOW_METHOD, DESKTOP_WINDOW_HOLDER_PREFIX;
+var init_transcript_window = __esm({
+  "../../packages/shared/src/environment/transcript-window.ts"() {
+    "use strict";
+    TRANSCRIPT_WINDOW_SCHEMA = 1;
+    TRANSCRIPT_WINDOW_METHOD = "session.transcriptWindow";
+    DESKTOP_WINDOW_HOLDER_PREFIX = "desktop:";
+  }
+});
+
 // ../../packages/shared/src/environment/provider-resume.ts
 function providerSessionIdFromResume(providerResume) {
   const raw = typeof providerResume === "string" ? providerResume.trim() : "";
@@ -5502,6 +5516,7 @@ var init_environment = __esm({
     init_events();
     init_session_events();
     init_session_messages();
+    init_transcript_window();
     init_provider_resume();
     init_lease();
     init_gateway();
@@ -11637,6 +11652,66 @@ var init_session_message_range = __esm({
   }
 });
 
+// ../../packages/runtime/src/stream/delivery/transcript-access.ts
+function missingRow() {
+  return Object.assign(new Error("transcript index out of range"), { code: "not_found" });
+}
+function arrayTranscript(messages) {
+  let ids;
+  return {
+    count: messages.length,
+    messageAt(index) {
+      const message = messages[index];
+      if (!message) throw missingRow();
+      return message;
+    },
+    indexOf: (messageId) => (ids ??= new Map(messages.map((message, index) => [message.id, index]))).get(messageId) ?? -1
+  };
+}
+function sqliteTranscript(db, input) {
+  const { table: table2, idColumn, columns, sessionId } = input;
+  const total = db.prepare(`SELECT COUNT(*) AS count FROM ${table2} WHERE session_id = ?`).get(sessionId).count;
+  const rowBefore = db.prepare(`SELECT ${columns} FROM ${table2} WHERE session_id = ? AND sort_order < ? ORDER BY sort_order DESC LIMIT 1`);
+  const rowAfter = db.prepare(`SELECT ${columns} FROM ${table2} WHERE session_id = ? AND sort_order > ? ORDER BY sort_order ASC LIMIT 1`);
+  const rowAtOffset = db.prepare(`SELECT ${columns} FROM ${table2} WHERE session_id = ? ORDER BY sort_order ASC LIMIT 1 OFFSET ?`);
+  const sortOfId = db.prepare(`SELECT sort_order FROM ${table2} WHERE session_id = ? AND ${idColumn} = ?`);
+  const countBefore = db.prepare(`SELECT COUNT(*) AS count FROM ${table2} WHERE session_id = ? AND sort_order < ?`);
+  const byIndex = /* @__PURE__ */ new Map();
+  const idIndex = /* @__PURE__ */ new Map();
+  return {
+    count: total,
+    parsed: () => byIndex.size,
+    messageAt(index) {
+      const cached5 = byIndex.get(index);
+      if (cached5) return cached5.message;
+      if (index < 0 || index >= total) throw missingRow();
+      const newer = byIndex.get(index + 1);
+      const older = byIndex.get(index - 1);
+      const row2 = newer ? rowBefore.get(sessionId, newer.sortOrder) : older ? rowAfter.get(sessionId, older.sortOrder) : rowAtOffset.get(sessionId, index);
+      if (!row2) throw missingRow();
+      const entry3 = { message: input.parse(row2), sortOrder: row2.sort_order };
+      byIndex.set(index, entry3);
+      idIndex.set(entry3.message.id, index);
+      return entry3.message;
+    },
+    indexOf(messageId) {
+      const cached5 = idIndex.get(messageId);
+      if (cached5 !== void 0) return cached5;
+      const row2 = sortOfId.get(sessionId, messageId);
+      if (!row2) return -1;
+      const index = countBefore.get(sessionId, row2.sort_order).count;
+      if (index >= total) return -1;
+      idIndex.set(messageId, index);
+      return index;
+    }
+  };
+}
+var init_transcript_access = __esm({
+  "../../packages/runtime/src/stream/delivery/transcript-access.ts"() {
+    "use strict";
+  }
+});
+
 // ../../packages/shared/src/launch-options.ts
 var HARNESS_LAUNCH_OPTIONS;
 var init_launch_options = __esm({
@@ -17301,6 +17376,25 @@ var init_session_runtime = __esm({
         const snapshot = this.requireReadModel().snapshot(sessionId, input);
         return snapshot.after == null ? { ...snapshot, messages: this.withProviderResume(sessionId, snapshot.messages) } : snapshot;
       }
+      /**
+       * Bounded `session.transcriptWindow` read. `read` runs in this turn.
+       * A cold checkpoint stays out of the read-model cache.
+       */
+      readTranscriptWindow(input) {
+        const sessionId = this.requireSessionId(input.sessionId);
+        const opened = this.requireReadModel().openWindow(sessionId, input.includeState);
+        const resume = this.live.get(sessionId)?.providerResume;
+        const last = opened.transcript.count - 1;
+        const transcript = !resume ? opened.transcript : {
+          ...opened.transcript,
+          messageAt: (index) => {
+            const message = opened.transcript.messageAt(index);
+            if (index !== last || message.role !== "assistant" || message.resumePointId) return message;
+            return { ...message, resumePointId: resume };
+          }
+        };
+        return Promise.resolve(input.read({ transcript, state: opened.state, cursor: opened.cursor }));
+      }
       /** The session's reduced transcript now; a host without a read model keeps none. */
       messages(sessionId) {
         sessionId = this.requireSessionId(sessionId);
@@ -22121,6 +22215,10 @@ var init_node_session_messages = __esm({
 
 // ../../packages/runtime/src/session/read-model.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
+function coreState(core) {
+  const { messages: _messages, ...state } = core;
+  return state;
+}
 function sessionReadModel(db, log2) {
   return (records2) => {
     const readModel = new SessionReadModel(db, log2, records2);
@@ -22138,6 +22236,7 @@ var init_read_model = __esm({
     init_node_session_event_map();
     init_node_message_catalog();
     init_node_session_messages();
+    init_transcript_access();
     init_message_catalog();
     MAX_IDLE_SESSIONS = 64;
     SessionReadModel = class {
@@ -22202,6 +22301,37 @@ var init_read_model = __esm({
         }
         session.applied = envelope.sessionVersion ?? session.applied;
       }
+      /**
+       * A transcript window. A cold session whose checkpoint is current is read by
+       * index: nothing is reduced, so its rows equal a full load's, and they are
+       * neither cached nor checkpointed. A session in memory, one with no
+       * checkpoint, or one with events after its checkpoint (a turn that did not
+       * finish) uses the complete session.
+       */
+      openWindow(sessionId, includeState) {
+        const checkpoint = this.sessions.has(sessionId) ? void 0 : this.db.prepare(`SELECT applied_version, state_json FROM session_read_models WHERE session_id = ?`).get(sessionId);
+        const current = checkpoint && !this.log.listForSession(sessionId, Number.MAX_SAFE_INTEGER, checkpoint.applied_version).length;
+        if (!checkpoint || !current) {
+          const session = this.load(sessionId);
+          return {
+            transcript: arrayTranscript(session.core.messages),
+            state: includeState ? coreState(session.core) : {},
+            cursor: { sequence: this.log.headSequence(), epoch: this.log.epoch, version: session.applied }
+          };
+        }
+        const core = { ...createDefaultChatCoreSession(), ...JSON.parse(checkpoint.state_json), messages: [] };
+        return {
+          transcript: sqliteTranscript(this.db, {
+            table: "session_messages",
+            idColumn: "message_id",
+            columns: "message_json, sort_order",
+            sessionId,
+            parse: (row2) => JSON.parse(row2.message_json)
+          }),
+          state: includeState ? coreState(core) : {},
+          cursor: { sequence: this.log.headSequence(), epoch: this.log.epoch, version: checkpoint.applied_version }
+        };
+      }
       load(sessionId) {
         const loaded2 = this.sessions.get(sessionId);
         if (loaded2) {
@@ -102006,6 +102136,7 @@ function lightLiveMetadata(metadata) {
 }
 
 // ../../packages/runtime/src/stream/delivery/window-views.ts
+init_transcript_access();
 var LIVE_MESSAGE_BUDGET = { maxBytes: 64 * 1024, maxFragments: 24, targetChars: Number.MAX_SAFE_INTEGER };
 var LIVE_PATCH_BYTES = 256 * 1024;
 var MAX_HELD = 64;
@@ -102020,12 +102151,11 @@ var SessionFragments = class {
     }
     return fragments;
   }
-  source(messages) {
-    let ids;
+  source(transcript) {
     return {
-      count: messages.length,
-      at: (index) => this.of(messages[index]),
-      indexOf: (messageId) => (ids ??= new Map(messages.map((message, index) => [message.id, index]))).get(messageId) ?? -1
+      count: transcript.count,
+      at: (index) => this.of(transcript.messageAt(index)),
+      indexOf: (messageId) => transcript.indexOf(messageId)
     };
   }
   retain(messages) {
@@ -102034,24 +102164,37 @@ var SessionFragments = class {
 };
 var WindowViews = class {
   sessions = /* @__PURE__ */ new Map();
+  /** Holders the 64-window cap dropped since the last drain. Switching a holder off a session is not an eviction. */
+  evicted = [];
   has(sessionId) {
     return (this.sessions.get(sessionId)?.holders.size ?? 0) > 0;
   }
+  /** Holder ids following `sessionId`, oldest serve first. */
+  holderIds(sessionId) {
+    return [...this.sessions.get(sessionId)?.holders.keys() ?? []];
+  }
+  /** Holders dropped by the cap. Each call takes them, so a frame reports an eviction once. */
+  drainEvicted() {
+    return this.evicted.splice(0);
+  }
   serve(input) {
+    const transcript = input.transcript ?? (input.messages ? arrayTranscript(input.messages) : null);
+    if (!transcript) throw new Error("transcript window needs messages");
     const session = this.session(input.sessionId);
-    const selected = selectTranscriptWindow(session.fragments.source(input.messages), input.request, input.budget);
+    const selected = selectTranscriptWindow(session.fragments.source(transcript), input.request, input.budget);
     const extend2 = input.request.anchor && input.request.direction !== "around" ? input.request.direction ?? "before" : null;
     const previous = session.holders.get(input.holder);
     const held = extend2 && previous ? previous : { messages: /* @__PURE__ */ new Map(), order: [], atTail: false, total: 0, seen: /* @__PURE__ */ new Map() };
     for (const message of selected.messages) {
-      const fragments = session.fragments.of(input.messages[message.index]);
-      if (!held.messages.has(message.id)) held.seen.set(message.id, input.messages[message.index]);
+      const source = transcript.messageAt(message.index);
+      const fragments = session.fragments.of(source);
+      if (!held.messages.has(message.id)) held.seen.set(message.id, source);
       recordMessage(held, message, fragments, extend2 === "before" ? "before" : extend2 === "after" ? "after" : null);
     }
     const ids = selected.messages.map((message) => message.id);
     held.order = extend2 === "before" ? [...ids, ...held.order.filter((id) => !ids.includes(id))] : extend2 === "after" ? [...held.order.filter((id) => !ids.includes(id)), ...ids] : ids;
     if (!extend2 || extend2 === "after") held.atTail = selected.newer === null;
-    held.total = input.messages.length;
+    held.total = transcript.count;
     session.holders.delete(input.holder);
     session.holders.set(input.holder, held);
     for (const [id, other] of this.sessions) {
@@ -102062,7 +102205,7 @@ var WindowViews = class {
     this.touch(input.sessionId);
     this.evict();
     session.fragments.retain(this.heldIds(input.sessionId));
-    return { ...selected, total: input.messages.length };
+    return { ...selected, total: transcript.count };
   }
   /** Patches for every holder of a session whose window `messages` changed. */
   patches(sessionId, messages) {
@@ -102116,6 +102259,7 @@ var WindowViews = class {
       for (const holder of session.holders.keys()) {
         if (count <= MAX_HELD) break;
         session.holders.delete(holder);
+        this.evicted.push({ sessionId, holder });
         count--;
       }
       if (!session.holders.size) this.sessions.delete(sessionId);
@@ -106616,6 +106760,7 @@ function coalesceAgentEventBatch(events) {
 }
 
 // ../../packages/runtime/src/server/session-delivery.ts
+init_transcript_window();
 var detailMessages = (sessions, sessionId) => sessions.detailMessages?.(sessionId) ?? sessions.messages(sessionId);
 function deliverLoad(result3, delivery) {
   if (!delivery) return result3;
@@ -106646,7 +106791,6 @@ function deliverLoad(result3, delivery) {
 function deliverFrame(frame, delivery, sessions) {
   const changed = /* @__PURE__ */ new Set();
   const windowed = /* @__PURE__ */ new Map();
-  const withholds = delivery.policy.surface === "phone";
   const events = frame.events.flatMap((envelope) => {
     const event = agentEventOf(envelope, sessions);
     if (!event) return [envelope];
@@ -106656,7 +106800,7 @@ function deliverFrame(frame, delivery, sessions) {
     const holdsWindow = delivery.windows.has(sessionId);
     if (holdsWindow) windowed.set(sessionId, envelope);
     const shaped = delivery.event(event, sessionId, summarized ? sessions.messages(sessionId) : []);
-    const live = holdsWindow && withholds ? shaped.flatMap((next) => windowLiveEvent(next) ?? []) : shaped;
+    const live = holdsWindow && !desktopShowsSession(delivery.windows.holderIds(sessionId)) ? shaped.flatMap((next) => windowLiveEvent(next) ?? []) : shaped;
     return live.map((next) => ({
       ...envelope,
       eventType: SESSION_DURABLE_EVENT.agentEvent,
@@ -106670,7 +106814,9 @@ function deliverFrame(frame, delivery, sessions) {
     }
   }
   const details = [...changed].flatMap((sessionId) => delivery.views.hasDetails(sessionId) ? delivery.details(sessionId, detailMessages(sessions, sessionId)).flatMap((event) => event.type === "remote_detail" ? [{ sessionId, update: { subscriptionId: event.subscriptionId, revision: event.revision, offset: event.offset, text: event.text } }] : []) : []);
-  return { frame: { ...frame, events: foldDeltas(events) }, details };
+  const dropped = delivery.windows.drainEvicted().map((item) => item.sessionId);
+  const resnapshot = dropped.length ? [.../* @__PURE__ */ new Set([...frame.resnapshot ?? [], ...dropped])] : frame.resnapshot;
+  return { frame: { ...frame, events: foldDeltas(events), ...resnapshot?.length ? { resnapshot } : {} }, details };
 }
 function foldDeltas(envelopes) {
   const out = [];
@@ -106697,7 +106843,7 @@ function subscribeDetail(delivery, sessions, input) {
   } catch (err) {
     throw Object.assign(err, { code: "invalid_argument" });
   }
-  const message = detailMessages(sessions, input.sessionId).find((candidate) => candidate.id === messageId);
+  const message = sessions.detailMessage ? sessions.detailMessage(input.sessionId, messageId) : detailMessages(sessions, input.sessionId).find((candidate) => candidate.id === messageId);
   if (!message) throw Object.assign(new Error("Detail not found"), { code: "not_found" });
   try {
     return delivery.views.subscribe(input.sessionId, input.subscriptionId, input.detailRef, message);
@@ -107132,12 +107278,8 @@ function handleSessionUnsubscribeDetail(payload, ctx) {
 
 // ../../packages/runtime/src/server/rpc-session-window.ts
 init_environment();
-
-// ../../packages/shared/src/environment/transcript-window.ts
-var TRANSCRIPT_WINDOW_SCHEMA = 1;
-var TRANSCRIPT_WINDOW_METHOD = "session.transcriptWindow";
-
-// ../../packages/runtime/src/server/rpc-session-window.ts
+init_transcript_window();
+init_transcript_access();
 var MAX_HOLDER_LENGTH = 128;
 var invalid5 = (message) => ({ error: { code: "invalid_argument", message } });
 async function handleSessionTranscriptWindow(payload, ctx) {
@@ -107152,33 +107294,57 @@ async function handleSessionTranscriptWindow(payload, ctx) {
   if ("error" in parsed) return parsed;
   const { anchor, direction, viewport, budget, have, holder } = parsed;
   const includeState = parsed.includeState ?? !anchor;
+  const request = { anchor, direction, have };
+  const limits = windowBudget({ budget, viewport });
   try {
+    if (sessions.readTranscriptWindow) {
+      return await sessions.readTranscriptWindow({
+        sessionId: target2.sessionId,
+        includeState,
+        read: (view) => windowResult(ctx, target2.sessionId, holder, request, limits, view, includeState)
+      });
+    }
     const loaded2 = await sessions.load({ sessionId: target2.sessionId, includeState, full: true });
-    const delivery = ctx.streams?.delivery;
-    const selected = (delivery?.windows ?? new WindowViews()).serve({
-      sessionId: target2.sessionId,
-      holder,
-      messages: loaded2.messages,
-      request: { anchor, direction, have },
-      budget: windowBudget({ budget, viewport })
-    });
-    const shaped = deliverLoad({ ...loaded2, messages: [], activeTurn: void 0 }, delivery);
-    const result3 = {
-      sessionId: target2.sessionId,
-      schema: TRANSCRIPT_WINDOW_SCHEMA,
-      messages: selected.messages,
-      older: selected.older,
-      newer: selected.newer,
-      total: selected.total,
-      ...includeState ? { state: shaped.state, ...shaped.restore ? { restore: shaped.restore } : {} } : {},
-      cursor: loaded2.cursor,
-      ...shaped.summarized ? { summarized: true } : {}
-    };
-    return { result: result3 };
+    return windowResult(ctx, target2.sessionId, holder, request, limits, {
+      transcript: arrayTranscript(loaded2.messages),
+      state: loaded2.state,
+      restore: loaded2.restore,
+      cursor: loaded2.cursor
+    }, includeState);
   } catch (err) {
     return mapThrown(err);
   }
 }
+function windowResult(ctx, sessionId, holder, request, budget, view, includeState) {
+  const delivery = ctx.streams?.delivery;
+  const selected = (delivery?.windows ?? new WindowViews()).serve({
+    sessionId,
+    holder,
+    transcript: view.transcript,
+    request,
+    budget
+  });
+  const shaped = deliverLoad({
+    sessionId,
+    state: view.state,
+    messages: [],
+    ...view.restore ? { restore: view.restore } : {},
+    cursor: view.cursor,
+    before: null
+  }, delivery);
+  const result3 = {
+    sessionId,
+    schema: TRANSCRIPT_WINDOW_SCHEMA,
+    messages: selected.messages,
+    older: selected.older,
+    newer: selected.newer,
+    total: selected.total,
+    ...includeState ? { state: shaped.state, ...shaped.restore ? { restore: shaped.restore } : {} } : {},
+    cursor: view.cursor,
+    ...shaped.summarized ? { summarized: true } : {}
+  };
+  return { result: result3 };
+}
 function parseWindowRequest(p3) {
   let anchor;
   if (p3.anchor !== void 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-one/cli",
-  "version": "0.75.1",
+  "version": "0.75.2",
   "description": "SuperOne headless node CLI — remote execution environment (RPC, workspaces, sessions).",
   "type": "module",
   "license": "BUSL-1.1",