Calm chat plane: one scroll owner + native @tanstack/ai stack - #597
Open
omridevk wants to merge 261 commits into
Open
Calm chat plane: one scroll owner + native @tanstack/ai stack#597omridevk wants to merge 261 commits into
omridevk wants to merge 261 commits into
Conversation
The exec card flattened its logs and its typed result into one ansi string, so an object result arrived as an escaped one-line JSON blob and the structured renderers were never reached. Logs and result are now separate: the logs keep the ansi block, and the result goes through a shared shape helper that opens objects and arrays as a JsonTree, leaves strings as strings, and puts scalars on one compact line. There is no parse-twice heuristic on string values. The meta-driven card takes the same path for an object output schema instead of degrading to raw text. Page script steps no longer label themselves with the literal word "script": the step target is the clipped first line of the script, and the duplicate value pill is dropped for them. A long value on any other step type still starved the target column, so the value chip carries its own max-width variant and the rail's value track is minmax(0, max-content). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
subscribe.ts keeps both mechanisms: offset-attach catch-up from replay-history and lifecycle replay from run-lifecycle, with the lifecycle yielded after the replayed RUN_STARTED chunks so a stopping phase is not clobbered. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
permission-block keeps rail's two-list-item restructure and gate-policy's Allow-for-session button, which now sits inside the restructured actions row. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
thread.tsx keeps rail's streamingPart/runningPart split and narration's reasoned gate plus compact now-line. status-bar keeps the lifecycle stopping reason tooltip and the narration running dot. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
chat-connection keeps the refresh reopen promise and the attempt restructure, with the run-lifecycle tap folded into the attempt loop instead of a separate wrapper generator. ChatSession keeps the async refresh and the stop state. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
result-rendering split runOutputText into runLogText plus a separately rendered shaped result; card-polish's hasEmbeddedBody probe still called the old name. It now asks both halves so the probe covers the same cases as before. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
eval-steering declares approval: 'ask' on page.eval, so the parent-id tests written against the ungated tool hung on the gate. They now answer the ask through the testkit auto-approval helper; the parent-id assertions are unchanged. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
run-lifecycle dropped the client-side chat.stop that every send used to issue, so the reconnect wire helper no longer waits for a stop frame. card-polish leaves a tool row inert when its card declares no embedded body, so the exec row is asserted by its content instead of an expand button it no longer has. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
) The switcher was a hand-rolled toolbar of aria-pressed buttons whose active state was a static inset box-shadow, so switching views had no motion and the markup carried none of the tab semantics. - Drive the switcher with Ark Tabs (tablist/tab, controlled by value/onValueChange over the existing activeView signal) and render the active marker with Tabs.Indicator, so the 2px accent line slides between tabs on the zag --left/--width variables instead of jumping. - Indicator motion uses the existing --chat-ease-expo token and is reduced-motion-guarded through --transition-duration, so the marker still lands instantly under reduce rather than vanishing. - ui-kit-system gains TabsPrimitive, matching the *Primitive convention, so a surface with its own cell language can use Ark Tabs without importing @ark-ui directly; its styled Indicator gains the same reduced-motion guard. - Keep the count hints, the leave-guard disabled state, and the narrow container-query behaviour; move the active fill onto data-[selected]. Views stay where the router renders them, so no Tabs.Content is wired. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…nt the install prerequisite `intent list` reported every declared source as "declared in intent.skills but was not discovered" in agent worktrees. Root cause was a missing `pnpm install` in the worktree, not the config: intent discovers skills by resolving each workspace package's dependencies, so with no local `node_modules` Node resolution escapes upward into the main checkout and finds only what is hoisted there. `@tanstack/query` was separately dead — no such package exists, and no installed query package ships skills — so it produced a permanent false negative even on a healthy install. Removing it makes the notice list empty when discovery is sound, which is what lets the real failure stand out. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
git branch sat in the read-only subcommand set, so `git branch <name>` created and `git branch -D <name>` deleted without asking. It now auto-allows only list-shaped forms: bare, or every token a list flag (-a/-l/-r/-v/-vv/--list/--show-current/--merged/--no-merged/--contains /--sort=*). Any non-flag argument or write flag falls through to ask. git diff --output=<file> writes a file yet matched `git diff *`. Any --output token in a git segment now vetoes the auto-allow, the same way find's write actions and env's wrapped command already do. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The Ark tabs shipped with aria-controls resolving to nothing: the views
render through the router outlet rather than Tabs.Content, so the id zag
generated named a panel that was never in the document.
- Pin the trigger and content ids with Tabs.Root ids={{trigger, content}}
so both sides can name the same element without guessing zag's
generated id.
- Put role="tabpanel", that id, and aria-labelledby on the slide
container each view already renders: ChatPane's pane body for the chat
view, the mounted-view wrapper for an extension view. Both are real
boxes in the panel flex column, so the layout is untouched and no
display:contents wrapper drops the role out of the a11y tree.
- The role is opt-in through ChatPane's viewTab prop, because PiP and
Quick mount the same pane with no tablist around it.
Exactly one tabpanel is rendered at a time, which is what the router
already guarantees.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ny run The mascot read a global OR of every mounted pane plus every cached session row, so one run anywhere lit it and a row cached mid-run kept it lit long after that run finished. It now answers for the active session alone: a mounted pane for that session owns the answer, and only when no pane is mounted does the cached row for that one session speak. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ersist run records The CLI transcript is sliced at the native record id of the last folded message instead of by matching prompt text. Claude JSONL records carry a per-record uuid, pi entries carry an id, and opencode message rows carry their primary key; those three now mint UIMessage ids from that identity. Codex envelopes carry no per-message id, so codex keeps positional ids and every harness keeps the prompt-boundary match as the fallback. Run status, timestamps and terminal error persist in a runId-keyed runs table, written at the single publishRunLifecycle seam and served to a subscriber when the in-memory store is empty after a restart. Runs left mid-flight by a dead server are marked aborted when the database reopens. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…tarted Activity.Now was the second, parallel narration surface: it read the activity store's activeCall while the shipped pin above the composer reads NowLine fed from the thread grouping store. Nothing outside its own story used it, so it goes along with its NowLine import. NowLine, Activity.Root and Activity.Timeline stay: other renderers depend on them. The narration gate also missed a turn this client did not start. sessionGenerating was the only source for that and it suspends, which the composer must never do, so useChatSession derives a non-suspending sessionRunning from the run lifecycle chunks it already taps: a lifecycle received whose phase is not terminal. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Sweeping every head in READ_ONLY_COMMANDS and every git read subcommand against its real flag surface turned up three more ways an auto-allowed command runs or writes something: rg --pre=COMMAND runs COMMAND per searched file and --hostname-bin=COMMAND runs COMMAND outright, so both forms now ask. grep resolves to ugrep in our environments, which adds --filter=COMMANDS (runs a filter utility), --pager/--view (run a command), --save-config (writes a config file to any path) and --config/---FILE (loads options from a file, reintroducing the others indirectly). None exist in BSD or GNU grep, so vetoing them costs nothing and closes the hole. date sets the system clock from a bare operand on BSD and from -s/--set on GNU, so date now allows only +format and non-clock flag tokens. The per-head rules move into one READ_ONLY_ESCAPES table behind escapesReadOnlyIntent, replacing the two ad-hoc predicates gate.ts was chaining, so the swept set is auditable in one place. Flag matching now compares the name before '=', which keeps --output-indicator-new and --filter-magic-label from being vetoed by the --output and --filter rules. Verified clean, no veto needed: cd ls cat pwd echo head tail wc which true, find (its write-action list was already complete), env (already vetoed whenever it carries an argument), and git status/log/show. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
… gate A code-mode approval could not be answered after a refresh. The synthetic conciv:tool_call chunks travelled isolate -> chat stream -> stream fold -> run controller, while the gate appended its approval-requested chunk to the same durable log directly, so the log held an approval for a tool call it had not announced yet. The server-side replay that rebuilds a resubscribing client's snapshot dropped it and the part came back as input-complete. The run now hands code-mode tools an emitter that folds each conciv:tool_* event into chunks and appends them at emit time, which is before the gate is consulted, so true order holds by construction. The stream fold no longer expands those events, so nothing is written twice. The approval keeps the inner tool call's id. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The delivery transports dial lazily: @tanstack/ai-client's webSocket() subscribe only registers a sink and opens the socket inside send(), and our subscribeOver() wrapper does the same for the SSE adapter. ChatClient only flips connectionStatus 'connecting' -> 'connected' inside processIncomingChunk, so no chunk ever arrived before the first run and the status never moved. The composer's send gate asked for exactly that status, so every send was refused with "Not connected yet" and no turn could ever open the socket that would have answered the question. Send readiness is now engine reachability alone, which is what the fetch retry votes already measure. Transcript readiness is the hydrate call landing, which is the fact the pane's skeleton actually waits on, published by the connection that owns hydrate. The fetch fallback then failed its CORS preflight: the adapter names the run in an X-Run-Id header and resumes with Last-Event-ID, and the engine allowed neither, so a cross-origin host page could POST nothing to /chat-sse. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Every tab held a permanent page.queries fetch stream, so six widget tabs exhausted Chrome's six-connection budget for the origin and the sixth tab's rpc never got a socket to travel on. Server push now rides one websocket per tab at /push-ws: the page-query bus and the session event stream both frame onto it, and every request/response call stays on oRPC over fetch. The out-of-band approval ask comes back with it. A gated tool call from outside a chat run publishes onto the session stream, the push socket carries it, and chatConnection merges those chunks into the same subscribe stream the delivery adapter feeds, which is where the retired chat.subscribe iterator used to land. A socket that replaces a dropped one is handed the asks still pending on its session, so a reconnect mid-ask does not strand the caller. The scoped asks.open dropped its approval record on the floor, so a gated registry call never registered a PendingApproval and neither hydrate nor the replay could see it. It carries the record through now. The client side reconnects with partysocket rather than a hand-rolled loop, and the page plane takes a query source instead of an rpc client, so the socket owner decides the transport. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…tream Three files still asked the session event stream for a run's content. That stream carries lifecycle records and out-of-band asks now; a run's snapshot, deltas and RUN_FINISHED ride the turn stream the delivery transport opens, and a late reader joins the run log rather than the bus. wire's send-acceptance assertion named the retired chat.send envelope, so it now reads the run id off the run's own RUN_FINISHED. The two late-attach claims join the run by id. The draft claims read the settled thread through chat.hydrate. createTestkit awaits the turn it started. peakLiveRuns was retargeted onto run-lifecycle records two commits ago but its unit test still fed it raw RUN_STARTED/RUN_FINISHED chunks, which the helper no longer counts; it speaks lifecycle records now, and gains the overlap case. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
A run opened by appending the whole thread to its own stream, so every turn paid for a full transcript over the wire and a client that already held the thread got it again. chat.hydrate is the one place a client asks for the thread now; a run streams only what it produces. The claims that read the run-opening snapshot read hydrate instead: the between-runs poisoning pair (snapshot-resubscribe, rich-transcript T5), the mid-flight joiner catch-up (T7/T8), the two message-id stability tests, the memory-stress fresh turn, and wire's turn, join and no-resume history cases. thread-identity states its claim on the stored thread directly, which is what it was reading the log for. firstSnapshot/lastSnapshot lose their last callers and go with them. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ves the app launchRun was the only caller of RunController, and its one caller was the compactor. Everything else already runs through makeTurn, whose stream the delivery transport drives and whose terminal status recordRunSettled writes. The compactor now claims its run record, drives runStream into the same run log a chat turn writes, and publishes the settled record itself, so the chat path holds one way to run a turn instead of two. That empties the dispose drain: RunController only ever tracked compact runs, and a compact is awaited by the call that asked for it, so drainWithDeadline was racing an always-empty set. stop-cancel-reason asked a scripted harness to 'hang around' and it answered at once, so the run finished normally before the stop reached it and the status assertion had been softened away to fit. It hangs the harness for real now and pins status 'aborted' - verified load-bearing: forcing settledStatusOf to always return 'completed' turns it red. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…red procedure chat.send left oRPC with the transport swap, so the three fault tests pointed their route at a path nothing calls any more: the send succeeded and the composer had nothing to report. The fault now lands where a turn actually travels - a POST to the chat delivery endpoint - so a refused turn is a 500 the adapter raises and a dropped one is a connection the browser refuses. The pane harness takes a transport preference and these three pin the fetch transport, because vitest browser mode cannot install a websocket route: that has to be in place before the page navigates, and the page is already loaded when a test runs. The websocket half of the same claim needs a pre-navigation route, which is the embed e2e suite's shape. The dropped-turn message is the adapter's own 'Stream response body read failed', so the assertion names that instead of a fetch rejection that no longer reaches the user. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
… its own id The push socket hands a fresh connection every ask still pending on its session, so a reconnect mid-ask re-delivers the approval chunk. The claim that matters is that the replay carries the id the first delivery carried: a client keyed on the approval id then updates the ask it already knows instead of opening a second one, and hydrate still reports exactly one pending approval. The push wire watch now collects the approval ids it sees, and the core control can restart the served core, which is what drops the socket the widget holds. Verified load-bearing: minting a fresh id for the replay turns it red. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The two transports still fold to the same transcript, but the user turn is no longer on the wire for either of them, so the equivalence reads the assistant reply off the stream and the whole thread off hydrate. Same for the finished-run replay. Three browser suites shared a pane-disposal afterEach verbatim, which fallow flagged the moment the approval-replay suite made it a third instance; keptPane owns it, next to the bootedCore they already shared. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
A gated MCP, registry or page call with no chat run behind it asked over the push socket and nothing rendered: the pane built approval cards only from a transcript tool call, and an out-of-band ask has none. Pending approvals now reach the pane as records. chat.hydrate carries them on open and the push socket carries them live, the client keeps them in one store keyed by approvalId, and the pane renders the same ui-kit-chat "Permission request" card for every waiting ask whose tool call is not already in the transcript. Decisions still ride rpc.chat.permissionDecision. The card leaves when the ask settles: the gate publishes an approval-settled chunk once a decision, a timeout, or a session stop resolves the wait, so a card also disappears when another tab answers it. The pane test harness now sends the session header the real widget sends, so a decision made through the card reaches the core. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The recording test waited on the session bus for a MESSAGES_SNAPSHOT that no longer rides it: the thread snapshot belongs to hydrate now, so the wait always stalled at its hang guard. The claim is unchanged and is read where the evidence lives: the persisted user message from chat.hydrate carries the expanded recording text as a model-only part. pane-open-perf named the same retired chunk in prose only; its matcher already keys off the chat websocket handler, which is what the wording now says. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ort claims move to the planes that carry them
The launcher read the pane's own stream status, so a run started outside the
widget lit the transcript ("Responding…") while the mascot stayed asleep: with
chat on its own transport a foreign run reaches the pane as a run lifecycle, not
as a local stream. The pane now registers the session's activity - its own turn
or any live run on the session - so the mascot follows the targeted session from
the start of a run to its settle, and a run in a session it does not target still
leaves it asleep.
Three claims pointed at planes that no longer exist. settings.transport steers
the chat connection now and oRPC always rides fetch, so the standalone pinning
tests read the chat wire (a websocket frame or an event-stream POST) and keep the
rpc-rides-fetch half in both halves of the pair. The extension rpc call the page
observer watches rides fetch too, so the claim names that transport instead of
counting a socket nothing opens. The 500-from-a-healthy-engine claim faulted the
retired chat.send procedure, so it faults the chat turn and pins the fetch
transport, which vitest browser mode can route.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ides
The core stopped mounting /rpc-ws when oRPC moved to fetch only, so the five
probe-suite claims that dialled ${kit.wsBase}/rpc-ws died with it: the socket
never opened and every call raised "Cannot send message, WebSocket is not
open." No browser in this repo opens an rpc websocket any more, so those
claims had no subject to observe.
The playwright probe stack goes with the transport: the ws probe bundle, its
vite config, the probe host and probe server, the package's playwright
project, and the frame decoder that only outbound socket frames needed. The
observer keeps counting rpc sockets, which is what the embed connection-pool
and transport-selection claims read to prove the widget opens none, and the
fault injector loses a websocket branch nothing routed.
The claims that fetch can still carry are retargeted onto the ping extension:
a call is matched by its decoded input, an extension path is never matched by
a shorter path sharing its name, and a gated call stays started and
uncompleted until the gate releases it.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…t drops its chat socket, and three suites follow the run onto its own plane The push-socket testkit helper only ever watched for the NEXT websocket, so the first waitForWidget in a file passed and every later one timed out: eleven tanstack ITs died on a socket that had already been open for minutes. The watch is now page-scoped and attached when the page opens, so a caller that arrives after the socket is up settles on the ready frame it already received. The chat websocket had no owner. oRPC's close used to take the tab's socket down with it; with chat on its own socket nothing closed it, so every unmount and every session switch left a live socket behind. chatConnection hands the adapter a tracking WebSocket implementation and closes what it opened, and useChatSession closes the connection when its owner disposes. The widget suite now releases a held harness turn before it tears the kit down. Playwright runs afterEach hooks in declaration order, so the per-file release ran after the kit had disposed: the run settled into a closed database and the unhandled rejection failed five fab tests. The two perf suites waited for run completion on the session bus, which no longer carries a run's chunks, and pane-open-perf looked for its ingestion load in a websocket handler now that the transcript restore rides fetch. Both follow the plane that carries the work. CONCIV_FAKE_HANG no longer hangs forever: the fixture waits two minutes, far beyond any test that stops it, then replies and exits, so an aborted run cannot leave a fixture propping its parent open for a day. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…rtion A DOM re-insert of any ancestor of the thread viewport resets scrollTop to 0, and the reset reached the scroll listener a frame later looking exactly like a reader dragging to the top: the landing memory was cleared and the thread stranded. A Solid Suspense above the pane re-suspending on a session switch produces precisely that, twice per switch. The owner now keeps a resting anchor with two modes, recorded from real reader events only: preserve-reader-anchor writes the recorded offset back, clamped by the DOM to the new maximum; resume-following re-enters landOnEnd against the end the DOM has now, so turns appended while the pane was detached are followed rather than stranded above. A MutationObserver watching childList on each ancestor's direct parent detects the re-insertion inside the mutation microtask, before the browser's delayed scroll event, and the correction goes through the one existing landing call site. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The pane read harness meta with a tracked render-time read of a per-pane useQuery result. Every session switch remounted the pane, the fresh solid-query resource started unresolved, and the read registered on the router match's Suspense: the pane root was detached and re-inserted as the same node, which resets scrollTop and flashes the router pending pane. The harness meta query is now created once above every Suspense boundary in the router Wrap and handed to the pane as a plain derived accessor. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Run journals lived at the host-global /tmp/tanstack-runs, keyed by run id alone, and the journaled command appends. A run that ends by detach returns without cleaning up, so the file survives and the next server that uses the same run id reads it from byte 0 and replays a previous server's output -- including a previous exit sentinel, which settles the fresh run as completed before its own harness has emitted a byte. Under full-suite load that is what made the detach durability test flake: the run record read back "completed" about 1.5s before the fake harness process had even booted. Journals now live under <stateRoot>/.conciv/runs, so two conciv servers on one machine never share them. The detach test also now asserts its precondition -- harness process alive and the run still running -- before the viewer leaves, so a run that settled early fails where it broke instead of as a missing detach marker. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The refresh progress tests gated chat.subscribe, a procedure the websocket lane deleted, so the gate captured nothing and the "Refreshing the conversation" state was a transient the assertion caught only by luck. Gate chat.hydrate and wait for the capture. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The session stream announced a run's start but never its end: the terminal RUN_FINISHED/RUN_ERROR only ever reached the run's own stream. A client that stopped reading that stream - exactly what pressing Stop does - kept the run in its active set, so sessionGenerating stayed true and the composer never came back from Stop to Send. The scripted test harness compounded it by ignoring the request abort signal, so a held turn parked forever and the run record never left 'stopping'. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The reload-draft composer IT waited on a draft fragment that the pre-chip draft already satisfied, so a reload could restore a draft missing the chip's trailing space; the wait now names the settled text. calm-contract shared one scripted-turn queue across the whole file, so a turn left queued by one test was consumed by the next test's seeded thread and rendered a second trace card. The harness script can now be cleared and the suite drains it after every test. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
makeTurn mirrored the delivery request's abort signal into the run's own AbortController. A widget session switch disposes the chat connection, which closes the socket, which makes toWebSocketStream tear down every active turn - so a mere UI switch reached the run as a cancel: the harness stopped, the record settled 'aborted', and the session list lost the run it was supposed to take the busy state over from. Cancellation is already record-driven (chat.stop marks cancelRequested and the run's own poll aborts with the cancel reason), so the transport signal has no business aborting anything. It now means what it says - this viewer is gone - and records detachedSince while the run keeps producing to completion. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
|
Important Review skippedToo many files! This PR contains 812 files, which is 712 over the limit of 100. To get a review, reduce the PR to 100 files or fewer by splitting it into smaller PRs or changing its base branch. Upgrade to a paid plan to raise the limit. Usage-priced reviews support at most 300 files. ⚙️ Run configurationConfiguration used: Organization UI Review profile: CHILL Plan: Pro Plus Run ID: ⛔ Files ignored due to path filters (1)
📒 Files selected for processing (812)
You can disable this status message by setting the Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
… chat sources sandbox.ts and subscribe.ts were deleted on this branch: the sandbox is now withSandbox from @tanstack/ai-sandbox wired in run.ts, and subscribe was replaced by chat.hydrate plus delivery.ts and push.ts. Rewrite the prose that described the old shape and repoint every citation, including the harness-types.ts range that ran past the end of the file. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The tools were renamed canvas.read -> canvas_read (and comment.* -> comment_*), but both cards still stripped a dotted prefix, so opOf returned the whole name, every summary and field lookup missed, and the cards rendered an empty body. Strip the underscored prefix instead, and finish the rename in the test's role selectors, which still asked for a literal dot. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
expectSmooth guarded its percentiles with a raw frame count, which encodes the host's refresh rate: the same virtualization-boundary window yields 55 frames on a 120Hz dev display and 26-30 on CI. Sum the sampled gaps and require a minimum sampled window instead, so the guard asks what it means - did we watch enough of the stream for a percentile to be worth reading. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The branch moved @tanstack/ai 0.43.1 -> 0.51.0 and its family with it, and added ai-persistence and ai-skills, so the packed Next fixture resolved a different registry set than the committed lockfile and the drift guard stopped the suite before its first assertion. Regenerated with update-packed-lockfile. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…kout cacheDir "../.turbo-cache" is a local convenience for sibling worktrees, but it resolves relative to each checkout, so on a CI runner it asks turbo to write above the workspace. Drop it from the committed config and document the env var that gets the shared local cache back. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The 1.3 line adds an opt-in editor entry point, partial-diff hydration and CodeView header/footer regions. None of our surface changes: File, FileDiff, getSingularPatch, registerCustomTheme, getOrCreateWorkerPoolSingleton and the FileContents / FileOptions / FileDiffOptions / CustomThemeLoader types are all unchanged, so no call sites move. This does NOT fix the streaming code-block shrink from CI shard-4: the stale render-cache write it was expected to close is still unguarded in 1.3.6, and the shrink still reproduces under CPU load. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Backports upstream's own applyHighlightResult guard into the @pierre/diffs 1.3.6 dist: the FileRenderer now remembers the file it was last asked to render and ignores highlight results that arrive for anything else, instead of letting the last async highlight overwrite the render cache. Under load a slow highlight for an earlier streaming snapshot could land after a newer one and roll the rendered code body back a step. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ture lock
Two CI failures on run 33379928075, both with a cause that is not where
the shard names pointed.
shard-7 was reported as a whiteboard failure; whiteboard passed all 27
files and its INVALID_SVG / COMMENT_NOT_FOUND stacks are the declared
error paths printing to stderr. The real failure was @conciv/ui-kit-tap:
placeCaret clicked the editable and then sent {Home} with no barrier
proving focus had landed. userEvent.keyboard is untargeted - it goes to
whatever holds focus - so a key dispatched into the gap between the
click resolving and ProseMirror taking focus is lost with nothing to
re-press, and the caret stayed at the offset openingSelectionCommand set
at mount. That is the 11-11 in the failure DOM. Assert focus before every
untargeted key run, the same causal barrier 23995b2 gave the embed
caret-restore test.
The nextjs packed fixture lock was refreshed for the tanstack ai bump in
a38337d, and 1c6420c then moved @pierre/diffs to 1.3.6 without
refreshing it, so the seeded install re-resolved the @pierre subtree and
the drift guard fired. Regenerate it.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Calm chat plane
Spec:
docs/superpowers/specs/2026-08-26-calm-chat-plane.md. 251 commits, phases 0/1/3/2 (2.b cut). One sentence: the chat plane now streams calmly and runs on @tanstack/ai's native stack end to end - their transport, their run store, their sandbox durability - with our parallel implementations deleted.Phase 0+1 - harness & upgrade
Calm characterization harness (12 blocking gates), @tanstack/ai family 0.43→0.51, one-tree thread.
Phase 3 - calm surfaces
One scroll owner: the TanStack virtualizer owns every scroll write (stick-to-bottom package deleted, five competing writers removed); one-shot landing, cause-driven follow; reload lands at the end, a released reader is never yanked. Trace perf: grouper O(n), diff pacing, Firefox p90 9.3ms. Fold-on-send, settle chip, stable message ids.
Phase 2 - deletion ladder onto @tanstack/ai
Audited every parallel we had against upstream, then deleted in order:
chat_threadsis the single record of a session (write-time CLI transcript import, msgid dedupe, compaction re-anchor).withSandboxwith runs+durability; run journals scoped to the server state root; local-process provider patched so destroy actually kills the process tree (Stop kills the CLI)./chat-ws(their WebSocket stream) with/chat-ssefallback; oRPC rides fetch only;/rpc-ws, the probe stack, partysocket,chat.send,chat.subscribe, and the per-run MESSAGES_SNAPSHOT are gone.chat.hydrate(+ pending approvals, last run) is the reload story; a per-tab/push-wscarries page queries and out-of-band asks (fixes 6-tab HTTP pool starvation).Bugs found & fixed on the way (each with failing-first tests)
useQuery().dataread under the router's Match Suspense → pane detach/re-insert → scroll stranded at top. Query hoisted above the boundary; the scroll owner now also survives ANY viewport re-insert (preserve-reader-anchor vs resume-following).Testing
~90 tests rewritten to the real one-step turn surface (no fake attach+send); five subscribe ITs re-homed claim-for-claim onto hydrate+joinRun; embed e2e rewritten around one chat socket per tab; every fix carries failing-first evidence and a revert-check. Full gate green: 109/109 turbo tasks + typecheck/lint/format/fallow/changesets.
Follow-ups (tracked, deliberately out)
panel-view-tabs hollow gate repoint; PendingPane micro-flash (needs a repo-wide non-suspending read pattern decision); journal sweep on dispose;
rpcWebsocketRoutefate (test-only consumers now);chatBusycollapse onto the run record; virtualizer re-arm on reconnect guarantee; out-of-band ask mount race (attach-window vs plain timeout);clearScriptdrain wired into the other scripted suites;notifyRunDisconnectedunreachable (detach written from core;sandboxKeyunstamped on viewer departure); durable log truncates on disconnect (hydrate covers reload); recorder frame-splitter fate; unused@orpc/standard-server*catalog entries.🤖 Generated with Claude Code