Skip to content

Continue compared to our session event catalog ​

Part of Session Store Research. Produced by running RESEARCH_PROMPT_COMPARISON. Stage-one dossier: Continue. Compared against proto/trogonai/session/sessions/v1alpha1/ and ADR#0035 on 2026-08-04.

Store maturity: 9/12: evolution scars 2/3 (three dated format-evolution episodes over 2+ years: a Python-era session_id snake_case sniff still live since commit 7edfd3d65 (2023-12-09) that silently drops old-format entries forever rather than migrating them, a Checkpoint/file-undo feature added in commit 5a3206261 (2024-11-13) and fully deleted in commit ff8a63a9e (2025-04-30) with no replacement, and MessageModes growing from 2 to 4 values with no migration; real scars, but undisciplined ones, since no schema_version field exists anywhere on Session, BaseSessionMetadata, or the array), operational age 1/3 (the store code is over two years old by its earliest touched commit, but the dossier found no issue, test, or comment anywhere confirming any of the four index-drift failure modes it documents actually surfaced in the field; the risk is inferred from reading core/util/history.ts, not from a confirmed production incident), exposure 3/3 (three shipped, Apache-2.0 clients: VS Code extension, JetBrains extension, and a standalone CLI, all reading and writing the same on-disk format), design independence 3/3 (HistoryManager in core/util/history.ts:24-193 is Continue's own class with no evidence of being forked from another product's persistence layer).

The one structural difference everything else follows from ​

Continue keeps one conceptual session as two independently written, non-atomic, mutually unreconciled mutable documents, and has no function anywhere in its codebase that rebuilds one from the other. The per-session transcript lives at ~/.continue/sessions/{sessionId}.json and the flat metadata index lives at ~/.continue/sessions/sessions.json; both are read in full and rewritten in full on every mutation, by the same HistoryManager class (core/util/history.ts:24-193), with no lock, no atomic rename, and no fsync anywhere in the write path (core/util/history.ts:131-134, per the dossier). Because the two files are written in sequence rather than as one transaction, a crash between the writes produces one of four concrete, permanent divergences documented in the dossier's index-drift section: an orphan session file with no index entry (save writes the session file first, sessions.json second); a dangling index entry with no backing file (delete unlinks the file first, rewrites the index second); a whole-index wipeout, because delete()'s safeParseArray swallows a JSON.parse failure on a corrupted sessions.json to undefined and falls back to ?? [], then writes that empty array back over every other session's entry; and the CLI's --resume/loadSession() path (extensions/cli/src/session.ts:301-332), which bypasses sessions.json and HistoryManager.list() entirely in favor of a raw fs.readdirSync plus newest-mtime scan, so it can resume a session the picker cannot see and is immune to a dangling entry the picker cannot resume. None of these four paths self-heals; there is no reconciliation, checksum, or rebuild-index function anywhere in the codebase. This is a materially different failure shape from Cline's whole-document rewrite (a single document, atomically wrong or right per write) and from fx's turn-granular append: Continue's defining structural fact is dual-source-of-truth divergence with no reconciliation path, so once it happens it is permanent.

Our design has no analog to this failure mode by construction: the typed event log (proto/trogonai/session/sessions/v1alpha1/events.proto, the 41-arm SessionEvent oneof) is the sole authoritative record, and every other artifact, the aggregate snapshot, the SessionProjection a Projector::catch_up builds, and the read-side checkpoint, is explicitly rebuildable from it (ADR#0035 facet 8). The comparison in the rest of this document is therefore less "what field maps to what" and more "what does a product look like when it never adopted the append-only-log-plus-rebuildable-projection discipline at all."

Mapping ​

Continue constructOur equivalentNotes
~/.continue/sessions/{sessionId}.json (full mutable transcript, whole-file rewrite)Typed event log, one append per fact, SessionEvent oneof (proto/trogonai/session/sessions/v1alpha1/events.proto:58-115)Continue has no append primitive at all; every save is JSON.stringify of the entire array.
~/.continue/sessions/sessions.json (flat metadata index, independently rewritten)SessionProjection, rebuilt by Projector::catch_up from the log (ADR#0035 facet 8)Ours is declared rebuildable and never authoritative; Continue's is a second mutable document with no rebuild path.
sessionId: string (uuidv4(), minted client-side in the GUI reducer or the CLI)SessionStarted.session_id (session_started.proto:17)Both are opaque client-visible ids; ours is the creation fact of a logical stream (WRITE_PRECONDITION = NoStream), not a filename.
BaseSessionMetadata.workspaceDirectory (core/index.d.ts:292-298, denormalized, not part of the key, and the workspace filter is dead code on every production list path)CheckoutRef on SessionStarted.checkout_ref (session_started.proto:23, checkout.proto:13-22), immutable for the life of the sessionOurs carries checkout_id, uri, and revision, and is the projection surface used to filter listings; Continue's equivalent field exists but nothing enforces it is actually used to scope anything.
ChatHistoryItem (core/index.d.ts:534-545): no id, no parent pointer, no timestamp of its own; identity is entirely session-levelUserMessageRecorded.message / CanonicalMessage plus turn_id (user_message_recorded.proto:9-21); AssistantMessageStarted/Completed/FailedEvery one of our conversation events carries its own event id, its session's SessionOrdinal, and a stamped turn_id; Continue's entries have none of the three.
HistoryManager.save/load/list/delete/clearAll (core/util/history.ts:25-192)Command surface implied by the Decider aggregate: CreateSession, append, Projector::catch_up for listing, SessionHidden for deleteContinue's five methods each have distinct, undocumented error-handling behavior (dossier); ours routes every mutation through one typed command path with one precondition discipline per event.
In-memory lastSessionId (Redux, gui/src/redux/slices/sessionSlice.ts:687, gui/src/redux/thunks/session.ts:140-170) as the only "last session" recordNo durable "last active session" pointer found in the catalog; listing is a SessionProjection queryContinue's "resume last" is not durable across a full client restart of the GUI process; ours has no equivalent construct at all today (see Open questions).
CLI's raw fs.readdirSync + mtime scan (extensions/cli/src/session.ts:301-332), a second, disagreeing notion of "what sessions exist"N/A: only one authoritative read path, the event log itselfThis is the sharpest divergence in the mapping: Continue's own product has two mutually inconsistent answers to "what sessions exist," and ours has exactly one by construction.
core/util/conversationCompaction.ts:19-112: non-destructive, writes conversationSummary into the existing ChatHistoryItem, keeps the full arrayCompacted (compacted.proto:19-38): summary_id, summary_content, covers_from/covers_through (SessionOrdinal), trigger, covered events retained on the keep-forever logSame non-destructive intent, but ours is one typed event with an explicit covered range and an explicit CompactionTrigger, not an in-place field mutation on a mutable array entry.
extensions/cli/src/compaction.ts:53-167: compactChatHistory(), destructive, returns a truncated array (system message + one summary), persisted as a full replacementNo equivalent; Compacted never removes or rewrites prior events (ADR#0035 facet 4)This CLI path is the one place Continue actually loses transcript data on compaction; our design structurally cannot do this, since Compacted is additive and the covered events remain on-stream.
Rewind: submitEditorAndInitAtIndex/truncateHistoryToMessage (GUI, gui/src/redux/slices/sessionSlice.ts:357-434) and handleEditMessage() (CLI, extensions/cli/src/ui/hooks/useChat.ts:753-787): destructive in-place array truncation, no marker, no un-rewindSessionRewound (session_rewound.proto:16-22): keep_through (SessionOrdinal), reason; a new appended event, never an editContinue's rewind is a physical delete; ours is a fact recorded on an append-only log, so the rewound range is still inspectable and a fork can still reference it.
Subagents: CLI-only, brand-new in-memory-only ChatHistoryItem[], deliberately monkey-patches services.chatHistory.isReady = () => false for the call's duration (extensions/cli/src/subagent/executor.ts:109-112, restored at :190-193); only durable trace is the finished text folded into the parent's toolCallStatesDelegationDispatched (parent, delegation_dispatched.proto:20-25) + atomic [SessionStarted, ParentLinked] (child, parent_linked.proto:19-27), a full first-class sibling Session with its own logContinue's CLI does not merely lack cascade semantics, it declines to create a durable child session at all; see "Subagent cascade" below.
parentSessionId plumbed into SubAgentExecutionOptions but never read inside executeSubAgent's body (destructuring at executor.ts:61 omits it)ParentLinked.parent_session_id (parent_linked.proto:21), the child-side fact naming its parentContinue has the field name in an options type and no code path that consumes it; ours is a required, folded field on the child's own creation event.
No retention policy of any kind (grepped ttl/retention/cleanup/prune/gc, zero hits per dossier); clearAll() is a single fs.rmSync, still not atomic at the filesystem levelSessionHidden (session_hidden.proto:13-16, visibility tombstone, no byte deletion), RedactionApplied (redaction_applied.proto:13-19, read-time masking of named event ids), ArtifactErased (artifact_erased.proto:12-17, out-of-band artifact-byte destruction)Continue has no positive retention story at all, deliberate or accidental; ours has three distinct typed mechanisms, none of which physically truncates the log (ADR#0035 facet 7).
No fork of any kind found (grepped, zero hits per dossier)SessionForked (session_forked.proto:17-27): source_session_id, context_prefix_boundary (SessionOrdinal), ForkReason, atomic with SessionStarted under NoStreamA capability Continue's own dossier confirms does not exist in the product at all.
Artifacts: none, tool output and context items are inlined directly in ChatHistoryItem.contextItems/toolCallStatesArtifactRef/ArtifactMetadata claim-check by sha256 Digest (artifact.proto:14-34, proto/trogonai/session/sessions/v1alpha1/digest.proto:9-14), ArtifactRecorded (artifact_recorded.proto:9-12)Continue inlines everything into the same mutable JSON document it writes wholesale on every turn; we never inline artifact bytes into the event stream.
Reads/tool observations: not modeled as a distinct concept; whatever a tool call returns lives in ToolCallStateResourceObservation on ToolCallCompleted.observed (tool_call_completed.proto:32-35, resource_observation.proto:26-58): a content_digest or absent outcome, a range, a complete flagWe deliberately do not give reads their own event type (reads outnumber writes by more than an order of magnitude per resource_observation.proto:15-16); Continue has no comparable concept of "what a call observed" at all, only "what a call returned."

Reverse direction, what we record that Continue does not, and whether the omission looks deliberate. turn_id stamping across conversation and tool events, SessionOrdinal as a fold-derived logical position distinct from any physical offset, the operation-ledger pair (OperationReserved/OperationOutcomeRecorded), CascadePolicy as an explicit recorded fact, and TodoUpdated/SystemNoticeRecorded all have no counterpart anywhere in the dossier. None of these omissions look deliberate; Continue's store was not designed as an event log, so there was never a decision point at which "should we stamp a turn boundary" or "should cascade be an explicit enum" would have come up. They are absent because the underlying data model (a flat array of message-shaped objects) has no place to put them, not because Continue considered and rejected them.

What we should consider changing ​

1. Add an operational reconciliation job that diffs the live SessionProjection against a full replay, not just a lazy catch_up ​

The change. ADR#0035 facet 8 defines Projector::catch_up as folding the stream into a SessionProjection and states projections are "rebuildable, never source of truth." That is a schema-level guarantee, not an operational one: nothing in the ADR or the catalog currently commits to routinely exercising the rebuild path before a consumer notices a stale or diverged projection. Add an explicit, scheduled reconciliation job (or CI-style property test running against production topology) that recomputes a SessionProjection from scratch and diffs it against the cached/live one, alerting on divergence.

Evidence anchor. Continue (store maturity 9/12): across an 804-line dossier and a direct grep, there is no reconciliation, checksum, or rebuild-index function anywhere in the codebase (see the four index-drift failure modes above, drawn from the dossier's Write and append path section; core/util/history.ts is 197 lines and contains no flock, fsync, or atomic-rename call at all). None of the four has ever been observed to self-heal; each is permanent once it occurs, and none has a confirmed field report either, which is itself telling: a divergence with no repair path and no detection mechanism can persist indefinitely without anyone learning it happened.

Blast radius. Additive. This is an operational job and a projection-consistency test, not a schema or event-type change; it adds no new proto field.

Why. Our architecture is immune to Continue's specific failure (two independently-written mutable files) because the log is append-only and the projection is declared rebuildable. But "rebuildable in principle" and "actually verified to match the log in practice" are different claims, and Continue's dossier is direct evidence of what it costs to have neither: not a bug report, an absence of one, because nothing was ever positioned to catch the class of bug at all. The cheapest way to keep the gap we already closed by design from reopening operationally is to routinely exercise the rebuild path against the thing it's supposed to match.

Cost. A scheduled job (or a synthetic-load property test) plus alerting; no write-path cost, no new failure mode beyond "the reconciliation job itself needs to be monitored."

2. Decide, explicitly, whether a durable "last active session" pointer belongs in the catalog ​

The change. Continue's only notion of "the session to resume" is Redux's in-memory lastSessionId (gui/src/redux/slices/sessionSlice.ts:687), which does not survive a GUI process restart, and the CLI's separate raw-directory-mtime scan, which answers a related but different question ("newest file on disk") without consulting any durable pointer at all. Our catalog has no analog to either: there is no event or projection field for "the session this actor was last working in." Decide whether that is a deliberate omission (resume-target selection is a client/UI concern layered entirely on top of SessionProjection listing, never a store concept) or a gap the ADR should close with a lightweight, additive fact.

Evidence anchor. Continue (9/12): two competing, disagreeing implementations of "what to resume" in the same shipped product (gui/src/redux/thunks/session.ts:140-170 vs extensions/cli/src/session.ts:301-332), neither durable in the way the rest of the store is.

Blast radius. Additive, if adopted at all: a new commuting happened-fact (WRITE_PRECONDITION = Any, following the pattern of SessionRenamed) recording "actor X's most-recently-touched session," scoped outside any individual session's own stream. Doing nothing is also a valid outcome of this open question; it is listed as a recommendation because the ADR does not currently take a position either way, not because the answer is obviously yes.

Why. Continue shows what happens when this is left to accumulate as ad hoc, inconsistent client state instead of being decided once: two different answers to the same question, one of them not durable. We do not have that problem today because nothing yet claims to answer the question at all; better to decide now, while it is still a green-field choice, than after multiple clients have each grown their own incompatible notion of "resume".

Cost. If adopted: a new event type or field, a new projection, and a decision about whether it is per-actor, per-workspace, or global; if rejected, only the cost of writing the decision down so it does not get re-litigated.

What our design already does better ​

  • A single authoritative record instead of two independently mutable ones. The entire "one structural difference" section above is, from our side, a description of a failure mode ADR#0035 facet 8 already forecloses: the log is authoritative, every other artifact is declared rebuildable, and nothing is ever the second copy of a fact with its own independent write path.
  • Non-destructive compaction is a single typed event, not two incompatible implementations. Compacted (compacted.proto:19-38) is one shape with an explicit covered range; Continue ships two, a non-destructive core/GUI path (core/util/conversationCompaction.ts:19-112) and a destructive CLI path (extensions/cli/src/compaction.ts:53-167) that actually discards the pre-compaction transcript, an inconsistency the dossier calls "an unresolved internal inconsistency in the product, not a documented design choice."
  • Rewind is a fact, not a deletion. SessionRewound (session_rewound.proto:16-22) appends keep_through; nothing is removed. Continue's rewind, in both clients, is an in-place array truncation with no marker and no way back (gui/src/redux/slices/sessionSlice.ts:357-434, extensions/cli/src/ui/hooks/useChat.ts:753-787).
  • Turn identity is stamped, not inferred. turn_id (user_message_recorded.proto:12-20) is stamped at write time precisely because a fold cannot reliably reconstruct a turn boundary from commuting, Any-precondition appends. Continue's ChatHistoryItem has no turn concept at all; a turn's boundary is implicit in array adjacency, which is exactly the kind of positional fact that a whole-array rewrite risks disturbing.
  • Artifacts are claim-checked, never inlined. ArtifactRef/ArtifactMetadata (artifact.proto:14-72) keep the event log free of large byte payloads; Continue inlines tool output and context items directly into the same mutable document it rewrites wholesale on every save, so a large artifact makes every subsequent write more expensive, not just the one that produced it.
  • Fork exists at all, and mints a new identity that cannot be confused with its source. SessionForked (session_forked.proto:17-27) is unanimous with the rest of the industry corpus (synthesis convergence 5); Continue's dossier found zero evidence of fork anywhere in the product.

Trade-offs, not gaps ​

  • Whole-document simplicity vs. append-only discipline. Continue's "read the whole file, mutate the whole array in memory, write the whole file back" model is genuinely simpler to reason about locally, no ordinal, no precondition classification, no oneof to extend, and for a single-user, single-writer, JSON-file-sized session it mostly works. We pay for durability, replay, and multi-consumer correctness with a heavier write path (typed events, SessionOrdinal, per-event precondition classification). Continue's failure modes are the cost of the simplicity, not proof the simplicity was a mistake for a product at its scale.
  • In-memory "last session" vs. a durable pointer. Continue's lastSessionId living only in Redux state is a legitimate choice for a GUI extension whose process lifetime is tied to the editor window; a durable pointer would be over-engineering for that specific product. It becomes a defect only in the CLI, which has a genuinely durable process boundary (terminal sessions start and end) and still doesn't have one. This cuts both ways: it argues we should decide the "last session" question (recommendation 2) for our own multi-surface product, without implying Continue was wrong to skip it for its GUI surface specifically.

What not to copy ​

  • Two independently written mutable documents for one conceptual session, with no atomic write and no reconciliation. The transcript file and sessions.json can and do disagree, permanently, once they diverge (see the four failure modes above). Nothing in our design should ever introduce a second mutable "index" file that isn't rebuildable from the log.
  • Two mutually inconsistent implementations of the same operation (compaction) in one codebase. One destructive, one not, with no shared contract between them. A single typed event with an explicit, unambiguous covered range (as Compacted already is) is the right shape precisely because it cannot fork into two behaviors by accident.
  • A privileged, undocumented second read path that disagrees with the primary index. The CLI's raw fs.readdirSync + mtime scan for --resume answers a related but different question than sessions.json-backed listing, silently. If we ever need a "fast path" read for performance, it must be provably consistent with (or explicitly labelled as an approximation of) the authoritative projection, never a quietly independent source of truth.
  • Monkey-patching your own persistence layer to keep it from observing a running operation. The CLI subagent path explicitly sets services.chatHistory.isReady = () => false for the duration of a subagent call specifically to stop its own store from writing (extensions/cli/src/subagent/executor.ts:109-112). Treating "don't let the store see this" as a feature, rather than modeling the operation as a first-class thing the store legitimately should see, is the opposite of the sibling-session design in decision 6.
  • Silent, undocumented format-compat sniffing with a data-dropping fallback. The Python-era session_id snake_case sniff (since commit 7edfd3d65) silently drops old-format entries with no migration and no warning. Any format evolution in our catalog should either fail loudly or carry data forward; it must never resolve an unrecognized shape by quietly discarding it.
  • Destructive, in-place, unmarked rewind. Both of Continue's clients truncate the message array on edit-and-resend with nothing recorded and no way to recover the discarded tail. SessionRewound exists precisely so this never has to be true for us.

The two gaps the industry has not closed ​

Subagent cascade ​

ADR#0035 decision 6 already takes a position: a delegated child is a first-class Session with its own log, created via an atomic [SessionStarted, ParentLinked] batch under NoStream after the parent's DelegationDispatched acks (parent-first dispatch, delegation_dispatched.proto:20-25, parent_linked.proto:19-27), acyclic by construction because a fresh child_session_id is always minted, with an explicit, recorded CascadePolicy (cascade_policy.proto:8-16) governing what happens to the child when the parent reaches a terminal state, and a distinct, separately-named fact for rewind-triggered invalidation (ParentHistoryInvalidated, parent_history_invalidated.proto:17-27) versus terminal-cascade (ParentTerminated, parent_terminated.proto:11-19). The question is whether Continue's evidence validates, refines, or challenges that position.

Continue's CLI is the only place in the product with any subagent concept at all (extensions/cli/src/tools/subagent.ts:15-115 → executor.ts:58-213), and its answer is the degenerate opposite end of the spectrum from decision 6: a subagent is not a session, durable or otherwise. It is a brand-new, in-memory-only ChatHistoryItem[] that is deliberately kept away from the persistence layer for its entire lifetime, executor.ts:109-112 monkey-patches services.chatHistory.isReady to false specifically "to prevent it from interfering with child session" (per the code comment cited in the dossier) and restores it in a finally block at :190-193. The only durable trace a subagent run leaves is its final text output, folded into the parent's ChatHistoryItem.toolCallStates via addToolResult(). The parentSessionId field is plumbed as far as SubAgentExecutionOptions's type signature and then never read inside executeSubAgent's body (the destructuring at executor.ts:61 omits it), so even the naming convention of "this belongs to a parent" is vestigial. There is consequently no cascade question to ask of Continue at all, no crash-recovery question, no orphan question, because there is no durable child to orphan, crash-recover, or cascade against; a crash mid-subagent-call loses the entire in-progress child transcript with nothing left to inspect, resume, or steer, and this could not be otherwise resumed even in principle since the state never touches disk.

This validates decision 6 rather than challenging it: Continue is direct evidence of what a product looks like when it declines to build the thing decision 6 builds. Every other product in the synthesis corpus that has subagents at all converges on "sibling stream/session linked by a parent pointer" (synthesis convergence 6); Continue's CLI is the one data point that shows what happens when even that minimal convergence is skipped, total loss of durability, inspectability, and resumability for the delegated work, in exchange for a marginally simpler implementation (no persistence-layer coordination needed during the call). Decision 6's CascadePolicy enum and explicit ParentTerminated/ParentHistoryInvalidated distinction are a strictly more capable design than "no durable child exists," not a solution to a problem Continue's approach avoided; Continue simply moved the cost from "undefined cascade behavior" (the industry-wide unresolved gap named in the synthesis) to "no behavior to define," which is worse, not better, for anyone who wants to see, resume, or audit what a subagent actually did.

Retention on an unbounded log ​

ADR#0035 decision 7 already takes a position: the log is keep-forever and never truncated; SessionHidden is a visibility tombstone with no byte deletion, replacing the older SessionDeleted naming precisely so it stops promising erasure the log does not perform; RedactionApplied masks named event ids at read time while leaving the original bytes on the log; ArtifactErased separates out-of-line artifact-byte destruction from log retention entirely; and true erasure-grade/crypto-shredding is explicitly deferred to a follow-up ADR, with an optional reversible cold-tiering path to JetStream Object Store. The question is whether Continue's evidence validates, refines, or challenges that position.

Continue has no retention story of any kind: the dossier grepped ttl/retention/cleanup/prune/gc across the codebase and found zero hits, no scheduled cleanup, no size-based eviction, no age-based expiry. clearAll() is the single crash-safer deletion path (one fs.rmSync), and it is still not atomic at the filesystem level. Delete is local, in-place, and order-dependent rather than transactional, which is precisely how the whole-index-wipeout failure mode above happens: delete()'s safeParseArray swallows a JSON.parse failure on a corrupted sessions.json to undefined, falls back to ?? [], and then writes that empty array back over every other session's index entry, so a single corrupted read during an unrelated delete can silently discard the entire session index. This is a stronger, more concrete failure than "the log grows forever": it is "an ordinary delete operation can destroy unrelated data because there was never an append-only discipline to make deletion safe in the first place."

This is weaker evidence than the subagent case, and should be weighted accordingly: unlike some other products in the corpus, Continue's dossier documents no confirmed, field-reported growth or corruption issue tied to this, only architectural risk read directly out of the code (full-file read/write with no pagination, "untested beyond the 100-session unit test" per the dossier). Marked as inference, not a confirmed incident: whether any Continue user has actually hit the whole-index-wipeout path in production is one of the dossier's own Open Questions, unresolved. With that caveat, Continue still refines decision 7 rather than challenging it, and in a specific direction: decision 7's SessionHidden/RedactionApplied/ArtifactErased split exists because a plain, un-typed "delete" operation is dangerous once more than one record could be affected by it, and Continue's whole-index-wipeout is a demonstration of exactly that danger materializing in a product that treats delete as a single untyped, order-dependent filesystem operation rather than a set of distinct, explicitly named facts. It does not argue for anything decision 7 doesn't already have; it argues decision 7's insistence on splitting "hide," "redact," and "erase" into separate typed events, none of which is allowed to be a blind array/file rewrite, is doing real, load-bearing work that a less disciplined store visibly lacks.

Open questions for the ADR ​

  • Should ADR#0035 (or a companion operational runbook) commit to a scheduled reconciliation job that diffs a full-replay SessionProjection against the live one, given that Continue is evidence that "rebuildable in principle" and "actually verified to match" are different guarantees, and that a divergence with no detection mechanism can persist indefinitely unnoticed? (See recommendation 1.)
  • Does the catalog need a durable "most recently active session" fact at all, or is resume-target selection entirely a client-side concern layered on SessionProjection listing? Continue's two disagreeing implementations (in-memory Redux state vs. raw directory scan) are evidence the question needs an explicit owner, not evidence for either answer. (See recommendation 2.)
  • Continue's CLI subagent path shows a real product declining to give delegated work any durable session at all, specifically to keep it out of its own persistence layer's way during the call. Does decision 6's parent-first [SessionStarted, ParentLinked] dispatch impose any latency or coordination cost during a delegation call that a caller might be tempted to work around the way Continue's CLI worked around its own store, and if so, should the ADR say more about why that workaround is the wrong trade-off?
  • Continue's dossier could not confirm whether its documented whole-index-wipeout or orphan-file failure modes have ever actually occurred in the field, only that the code permits them. Should the ADR's Consequences section note that a similar unknown, "does our reconciliation/rebuild path actually get exercised before a real divergence would be user-visible", remains open for our own design until recommendation 1 is acted on or explicitly rejected?

Released under the Apache License 2.0.