feat: read long conversations by window with shared history writes

[zxch3n]

Related issue

Same-repository maintainer work; no separate tracking issue.

Problem / pressure

Opening a long conversation should prepare the visible messages, not materialize every history body before the UI can use them. On main, DOM virtualization happens after createSessionMirror has already read the full history. This PR moves that boundary down to history reads.

Summary

One production ConversationView reads a shallow directory and hydrates requested windows. The existing shared HistoryWriter remains the only history writer. The renderer uses the history reader; CLI operations use synchronous in-process reads and the same write rules. This is a windowed-read change, not a new CRDT or a complete replacement-storage implementation.

Local 1000-round comparisons: on the 140 MB high-entropy sanitized workload, cold data preparation falls from 157.3 seconds to 317.7 ms (median, 3 fresh processes per revision, including import, initial bodies, message rows and outline). A smaller synthetic workload measures 121.4 ms → 33.2 ms for import + reader preparation. These are different workloads and endpoints, not browser first-paint measurements; see the details below.

Visual explanation

Before: virtualize the DOM after reading all bodies

flowchart LR
  S["Snapshot bytes"] --> D["LoroDoc import"]
  D --> M["createSessionMirror<br/>materialize ALL history bodies"]
  M --> H["Full JS history array"]
  H --> R["Build conversation rows"]
  R --> V["Virtua displays a window"]
  UI["UI / CLI writes"] --> W["Shared HistoryWriter"]
  W --> D

Loading

Now: separate session metadata, directory and requested bodies

flowchart LR
  S["Snapshot bytes"] --> D["LoroDoc import<br/>still whole-document"]
  D --> C["Control-plane Mirror<br/>history excluded"]
  D --> A["Loro history reader"]
  A --> I["Shallow directory<br/>IDs, status, input config, counts"]
  A --> B["Requested turn bodies"]
  I --> V["ConversationView<br/>directory + body cache"]
  B --> V
  C --> UI["React / Virtua"]
  V --> UI
  UI -->|"visible window / outline hover"| V
  UI --> P["History commands / planners"]
  CLI["CLI business operations"] --> P
  P --> W["One shared HistoryWriter"]
  W --> D

Loading

The directory remains O(total entries). Complete bodies are loaded for the visible/retained range, with an LRU target of 200 and a retained tail of 20; pinned windows can exceed the target. Outline counts do not require all summaries: opening a hover card reads that question and its replies, then releases the lease. There is no full-history outline-summary sweep.

Streaming: invalidate by identity, refresh the affected bodies

sequenceDiagram
  participant D as LoroDoc
  participant R as History reader
  participant V as ConversationView
  participant F as Shared fact table
  participant U as UI
  D->>R: Commit content edit
  R->>V: changed(turn IDs)
  V->>V: Invalidate pending reads for these IDs
  V->>R: Read affected cached / leased bodies
  R-->>V: Current bodies
  V->>F: Invalidate affected facts, even if body was evicted
  V->>U: Publish affected entries
  Note over R,V: Inserts/deletes use structure(from,to).<br/>Leases own IDs, not shifting positions.<br/>Late async results must pass membership/content epochs.

Loading

Repeated readTurn calls also reuse the identity index while a pending transaction is unchanged. A pending transaction alone no longer forces a full ID scan on every body read; new operations, identity/structure edits and checkout still invalidate it. Reads never commit the document.

Ownership and compatibility

Responsibility	Current owner
Compose metadata Mirror, reader, view and writer	create-conversation-session.ts
Shallow reads, target lookup and storage events	session-data/loro.ts
Window leases, LRU, stale-read protection	create-conversation-view-from-reader.ts
Shared goal/permission/diff facts	derivation.ts + deriveSessionTurnFacts; consumers share one table per view
Validation and minimal writes	Existing HistoryWriter + business planners; unchanged opaque/legacy data survives
Explicit export/replay/sharing	Authoritative readAll, never stitched display windows

The old raw-doc view, test-only memory backend, storage capability registry and runtime window-mode fallback are gone. The array adapter remains for static shared pages, not as an app fallback. Detached fork snapshots reuse the writer's provenance and survive source unload. Stored data is not migrated. Import and editable-tail replacement retain commit-time checks and conditional compensation.

Before / after

Before	After
Full history bodies allocated before the window is usable	Shallow directory, then requested bodies
Pending transaction can cause an ID scan for each target read	Reuse the index until a new operation or relevant invalidation
Outline summaries derived across offscreen history	Question/reply preview acquired when the hover card opens
Display array and storage access intertwined	Reader-backed display cache; writes retain one owner
A view cache can miss an evicted turn's changed fact	Explicit changed IDs invalidate facts independently of hydration

Local benchmark

Compared main f3c399fe with PR 75ffc7bf, on macOS arm64 / Node 22.23.1, with each checkout's frozen lockfile. Five fresh processes per revision, alternating main/PR order; no simultaneous benchmark jobs.

Input: deterministic synthetic 1000 user rounds = 2000 entries, seed 376, generated by the committed replay worker through HistoryWriter. Each round includes a user message, thought, 4096-character tool output and assistant answer with high-entropy text. Both revisions import the same 12,687,300-byte snapshot, SHA-256 19794e069e956201613460c1844bcae4e298f5b2f6a159f974cffb6001292d98.

Measurement (median)	Main	PR	Interpretation
Snapshot import	10.15 ms	10.29 ms	No claimed decoding gain
Reader initialization through last-30 bodies available	110.73 ms	22.98 ms	4.82×, 79.2% less time
Import + reader/window preparation	121.37 ms	33.17 ms	3.66×
Complete entry objects materialized at that point	2000	30	Storage still contains all 2000

Reader/window raw samples (ms): main 110.50, 109.94, 120.69, 110.73, 112.58; PR 22.95, 23.73, 22.86, 22.98, 23.43.

Boundary: file reading, TS/module loading and fixture generation are outside timing. The main endpoint is createSessionMirror(...).getState().history.slice(-30); the PR endpoint is directory readiness plus acquireRange(last30).ready. Both verify the returned IDs and item payloads against the stored tail. Idle callbacks are not drained and React/business derivation consumers are not mounted. This does not measure paint, Markdown, Virtua layout, scrolling, IPC, network, persistence, or device frame time.

Larger high-entropy workload: complete cold data preparation

The earlier 120-second timeout was followed up with a longer per-process deadline. All three main and three PR runs completed. Same revisions as above (f3c399fe / 75ffc7bf), macOS arm64, Node 22.23.1, --expose-gc --max-old-space-size=8192; both checkouts use loro-crdt 1.15.1 / loro-mirror 2.3.2. Fresh processes run sequentially in alternating order.

Input is the local high-entropy sanitized Storybook workload: 140,206,036 bytes, 1000 user rounds, 2671 history entries, reused unchanged on both revisions. The fixture and raw evidence remain local and are not committed or uploaded. These results describe this workload, not all 1000-round conversations.

Phase (median of 3 runs)	Main	PR
Snapshot import	86.5 ms	78.4 ms
Full Mirror / shallow directory initialization	157,161 ms	220.5 ms
Initial window hydration	Included in full materialization	16.1 ms
Message-row construction	19.1 ms	1.0 ms
Left-outline construction	24.1 ms	0.9 ms
Total cold data preparation	157.3 s	317.7 ms
Complete bodies materialized	2671	42
Process RSS sampled after outline construction	2879 MiB	884 MiB

Total samples: main 142.0 / 157.3 / 167.6 seconds; PR 317.7 / 392.2 / 305.4 ms. Totals include the common session-ID setup (~2 ms); medians of phases need not sum to the median total.

The main path calls the actual full createSessionMirror, then the actual message-row and outline builders. The PR path calls createConversationSession, waits for the directory and the product's initial window (last 40 entries, extended to the preceding user question: 42 bodies for this fixture), then the same row/outline entrypoints. Both produce 1000 outline entries. Main has 2663 message rows and PR 2671 because offscreen placeholders differ from full empty-assistant filtering.

The measured main delay is inside full Mirror initialization, not the later outline builder. Outline construction consumes already-materialized JS data; it is not another independent CRDT toJSON() pass. No internal CPU profile was taken to attribute the Mirror delay to a narrower algorithm.

Measurement boundary: file I/O, module loading, fixture generation, React/Markdown mounting, browser layout/paint, network/IPC and background business-fact scans are excluded. Idle callbacks are disabled. RSS is an after-outline process sample, not peak memory, retained heap after GC or browser memory. This is a complete A/B of the stated data-preparation path, not end-to-end UI acceptance.

Reproduce the input and opening comparison

Generate the synthetic input once on this PR using the committed benchmarks/replay worker; reuse the resulting snapshot for both checkouts. The full replay also covers window jumps, append, streaming and hover preview, and can emit CPU profiles.

node packages/components/benchmarks/replay/run.mjs --rounds 1000 --runs 1 --mode committed --out /tmp/replay-1000
# Input for both revisions: /tmp/replay-1000/synthetic.snapshot

For the opening comparison, save the following as packages/components/open-compare-worker.ts in both checkouts. Run in a fresh Node 22.23.1 process with --expose-gc --max-old-space-size=8192 --import <the checkout's tsx loader>; arguments are main|pr and the snapshot path. Alternate the modes across five repetitions. The benchmark uses a committed session-id initialization in both modes.

import assert from 'node:assert/strict';
import fs from 'node:fs';
import { performance } from 'node:perf_hooks';
import { LoroDoc } from 'loro-crdt';
import { createSessionMirror } from '@lody/shared';
const mode = process.argv[2];
const bytes = new Uint8Array(fs.readFileSync(process.argv[3]));
const sessionId = 'benchmark-open';
const makeWindowed = mode === 'pr' ? (await import('./src/lib/conversation-view/create-conversation-session')).createConversationSession : undefined;
global.gc?.();
const startMemory = process.memoryUsage();
const doc = new LoroDoc();
let t = performance.now();
doc.import(bytes);
const importMs = performance.now() - t;
doc.getMap('session').set('id', sessionId); doc.commit();
const expected = doc.getList('history').length;
const from = Math.max(0, expected - 30);
let rows: unknown[];
let count: number;
let dispose: () => void;
let release = () => {};
t = performance.now();
let directoryMs = 0;
if (makeWindowed) {
  const session = makeWindowed(doc, {sessionId: sessionId as never, scheduleIdle: () => () => {}, yieldToEventLoop: () => new Promise<void>(resolve => setImmediate(resolve))});
  for(let pass = 0; session.history.turnCount !== expected; pass++) {
    assert(pass < 1000, 'directory did not become ready');
    await new Promise<void>(resolve => setImmediate(resolve));
  }
  directoryMs = performance.now() - t;
  const lease = session.history.acquireRange(from, expected);
  await lease.ready;
  rows = Array.from({length: expected - from}, (_, i) => session.history.turn(from + i));
  const openMs = performance.now() - t;
  count = Array.from({length: expected}, (_, i) => session.history.isHydrated(i)).filter(Boolean).length;
  dispose = session.dispose; release = lease.release;
  finish(openMs);
} else {
  const mirror = createSessionMirror({doc, initialState:{session:{id:sessionId as never},history:[]}});
  directoryMs = performance.now() - t;
  const history = mirror.getState().history;
  rows = history.slice(from);
  const openMs = performance.now() - t;
  count = history.length; dispose = mirror.dispose;
  finish(openMs);
}
function finish(openMs:number) {
  const memory = process.memoryUsage();
  assert.equal(rows.length, Math.min(expected,30));
  for(let i=0;i<rows.length;i++) {
    const raw=doc.getList('history').get(from+i);
    const stored=raw && typeof raw === 'object' && 'toJSON' in raw ? raw.toJSON() : raw;
    assert.equal((rows[i] as {id:string}).id,(stored as {id:string}).id);
    assert.deepEqual(JSON.parse(JSON.stringify((rows[i] as {items:unknown}).items)),(stored as {items:unknown}).items);
  }
  console.log(JSON.stringify({mode,node:process.version,entries:expected,bytes:bytes.length,importMs,directoryMs,openMs,totalMs:importMs+openMs,materialized:count,heapDeltaMB:(memory.heapUsed-startMemory.heapUsed)/1048576,rssMB:memory.rss/1048576}));
  release(); dispose(); doc.free();
}

Test plan

• On the merged head: component typecheck passed; 71 sharing tests and 32 focused opening/preview/share-reader tests passed; scoped lint/format and public-boundary validation passed locally. Isolated dependency/submodule setup was required; the live Storybooks were not modified.
• Before merging main, the optimization tree passed 1150 shared tests and 3558 component tests. These are prior package results, not a claim that those exact counts were rerun on the merged head.
• CI at 75ffc7bf: Tests and Desktop E2E (smoke) passed. Static checks failed on three unawaited promises in packages/acp-extension-core/test/usage.test.mjs (lines 12, 18, 30). Main and this head pin the same core submodule 80205d81; do not read this as an all-green CI claim. Current run.
• This turn's A/B run checks exact tail IDs/payloads and measures both real opening entrypoints. The committed replay asserts window membership, append and every streamed value; errors/timeouts fail the run.

Remaining costs: Loro import, the initial directory and explicit full reads are still O(total). Goal/permission/diff derivations still read history in the background when consumers mount; lazy outline previews do not remove that business work. One enormous turn can still be expensive. Pinned ranges can exceed the body-cache target. No 3000-round desktop/mobile memory or frame-time acceptance is claimed.

Context handoff

Instructions for reviewing agents

• Review focus: Reader epochs and identity-owned leases; changed IDs reaching evicted facts; changed-only writes and import/tail commit guards.
• Decisions to challenge: Shallow O(total) indexing and one shared writer remain; static shares adapt arrays while app history has one windowed implementation.
• Plausible failures / evidence gaps: Mixed structural/content races, large-turn latency, background business scans and unmeasured device memory/frame time; Static checks currently fail as detailed above.

Authoring context

• User goal / directives: Open long conversations by window and explain the current architecture with reproducible main/head measurements.
• Constraints / non-goals: Preserve legacy/unknown stored data and one writer; no second CRDT, payload externalization or data migration.
• Risk-bearing decisions: Stable-ID leases and epoch fencing protect delayed reads; explicit changed IDs invalidate evicted facts; export uses authoritative data.
• Destructive or irreversible behavior: Opening does not rewrite history. Existing import/edit operations retain guarded writes and awaited conditional compensation.
• Deliberately not done or tested: A replacement backend and full device-scale performance acceptance; device rendering and background business-fact scans are excluded from the benchmarks.
• Unknowns / confidence: Small synthetic gains repeat across five fresh processes and the larger high-entropy comparison across three; UI frame time and other workloads still need separate verification.

Original user prompt

请清理一下这个 pr 中的意外复杂度。产品目标只有一个：打开长会话时按窗口读、不物化全量历史。

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 0c2c41c384

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Invalidate facts when a non-hydrated turn changes

After the background pass has derived an older turn, a later update to that non-hydrated turn emits an index change, but this branch only re-derives the last 64 turns and retains the existing fact for every older ID. For example, late file-diff evidence written to a finalized turn after more than 64 newer turns leaves useSessionDiffSummary permanently stale until the view is recreated; older permission, scheduling, and goal facts have the same problem. Invalidate the affected fact and schedule hydration/re-derivation rather than assuming every index event is an append.

AGENTS.md reference: packages/components/src/lib/conversation-view/AGENTS.md:L29-L32

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: ffa2915a82

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Collect the hydrated suffix of the tail

When the last 20 turns exceed the item budget, createConversationViewFromDoc hydrates them newest-first and can leave the slot at from unhydrated; this forward collector then stops at that first gap and returns an empty or stale prefix even though the newest turns are already available. session-chat-interface.tsx uses this result for active-turn, configuration, activity, and app-review logic, so a fast sync can baseline the review hook without the historical completion and later treat that completion as new, potentially showing StoreKit merely from reopening a completed session. Collect the contiguous hydrated suffix ending at to, or withhold readiness until the entire requested tail is hydrated.

AGENTS.md reference: packages/components/src/hooks/AGENTS.md:L74-L79

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 701a3ad916

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Restart the fact pass after bulk appends

The added range invalidation fixes edits to existing turns, but structural batches still take this index branch: when an open session receives more than 64 turns at once—such as the single bulk append in apps/cli/src/lib/local-project-history-sync-service.ts:828-829—only the final 64 positions are considered, and this path neither calls requestPass() nor clears complete. Any earlier newly appended turns therefore never receive facts, so whole-history consumers such as fallback diff summaries, goals, and scheduled tasks permanently omit them until the view is recreated. Restart the background pass whenever the turn set changes.

AGENTS.md reference: packages/components/src/lib/conversation-view/AGENTS.md:L29-L32

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 7bec90e22a

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Hydrate newly inserted turns while search remains open

When history grows after the one-time hydration loop has finished, this subscription only rebuilds from turns that are already hydrated. A bulk append such as apps/cli/src/lib/local-project-history-sync-service.ts:828-829 can add more turns than the view's hydrated tail retains, so the earlier inserted turns remain absent from search results until the user closes and reopens search. Handle structural view changes by pinning and hydrating the newly added range before rebuilding the index.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 8c43b62a29

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Recompute cached search indices after structural edits

When a turn is inserted or deleted before an already indexed turn while search remains open, the surviving hydrated turn keeps the same object identity, so this cache reuses blocks whose embedded messageIndex still points to the old position. Search navigation passes that stale index to scrollToIndex, causing results after the structural edit to jump to and highlight the wrong turn; cache entries need to include or refresh the current index.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: dfe826410a

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Handle inline rows when selecting the plan target

When a resumed/upgraded session's newest assistant turn uses the supported legacy plain-JSON representation, this separate assistant lookup skips it and either selects an older container-backed turn or returns no id. handleACPUpdateMessage sends every latest ACP plan snapshot through doc.setPlan, so recovery of an inline assistant can durably attach the live plan to the wrong turn or silently omit it; inspect plain record rows for role and id here as the reader and writer already do.

AGENTS.md reference: packages/shared/src/session-data/AGENTS.md:L90-L92

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 1ae04afdf4

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Avoid materializing assistant bodies in the auto-read scan

With auto-read attached, every streaming history commit invokes this scan, and readAt() materializes each trailing turn with LoroMap.toJSON() before the loop reaches the latest user row. During a long assistant response, token batches therefore repeatedly parse the ever-growing assistant body even when that user is already seen, creating quadratic work and potentially stalling ordinary sessions independently of session output --wait; locate and status-check the latest user through readDirectory() and materialize only that user when necessary.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Expose the rollback constant to the renderer build

In the checked OSS Electron build, apps/electron/electron.vite.config.ts sets envPrefix to __LodyPublicBuildOnlyPrefix__ and its explicit define helper admits only VITE_* keys, so setting LODY_CONVERSATION_VIEW=0 leaves this property undefined and the expression always selects the windowed reader. The documented two-release rollback therefore cannot be activated for the shipped desktop build; explicitly inject this constant into the renderer build or use an admitted build-only prefix.

AGENTS.md reference: packages/components/src/lib/conversation-view/AGENTS.md:L22-L24

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: ede159a182

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Notify subscribers when release evicts hydrated turns

When a whole-history lease is released—for example, when search closes after hydrating a 3,000-turn conversation—evict() removes the unpinned bodies without bumping the view version or emitting a change. useConversationStreamItems therefore remains memoized on its fully hydrated items, and its BuildChatStreamItemsCache continues retaining each turn through rawEntry; a completed session can remain fully materialized indefinitely despite the view reporting those turns as evicted. Publish a cache change whenever release-triggered eviction removes bodies so consumers rebuild with placeholders.

AGENTS.md reference: packages/components/src/lib/conversation-view/AGENTS.md:L5-L10

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 75ffc7bf0b

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Avoid rematerializing history for every watched update

While a session has pending or processing work, the active-watch subscription enqueues a session check for every streaming history commit, and this line now makes each check call readAll() → LoroList.toJSON() over the entire transcript. Thus normal assistant output—not only session output --wait—does O(history size × update count) parsing and allocation; long conversations can stall the CLI and delay output persistence or dispatch. Use directory/targeted reads for reconciliation or ignore body-only events.

AGENTS.md reference: apps/cli/src/session/AGENTS.md:L42-L43

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: c37ad98f14

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Avoid full-history reads for each usage event

For providers that emit usage updates during a turn, this fallback materializes and clones the complete transcript for every event via readAll(). Normal assistant entries created by createAssistantTurn do not contain userId, so this is the usual path rather than an exceptional fallback; long conversations can repeatedly stall the CLI and delay the pending-usage drain during finalization. Resolve the linked user through latestAssistant.userTurnId and a targeted readTurn instead.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Keep GC probes from materializing every candidate history

When the periodic or memory-pressure GC evaluates idle sessions, session-gc-manager.ts calls hasActiveGoal for every candidate and again immediately before cleanup. This full readAll() projection materializes and clones every turn body, so a sweep over several long cached sessions creates a large allocation spike precisely while the process is trying to recover from memory pressure, potentially preventing eviction or causing an OOM. Use an incremental goal index or a bounded one-row-at-a-time scan instead.

AGENTS.md reference: apps/cli/src/lib/AGENTS.md:L58-L64

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 8c75e76eb0

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Treat turn-ID edits as structural changes

When a synchronized older/raw peer renames or removes a turn's id in place, this branch emits only the post-change ID (or an empty list). The ConversationView is still indexed by the old ID, so it cannot resolve that notification to a position and never refreshes the directory row or cached body, leaving the transcript permanently stale until the view is recreated. Classify identity edits as structural changes so the position is re-keyed.

AGENTS.md reference: packages/shared/src/session-data/AGENTS.md:L13-L17

Useful? React with 👍 / 👎.