Repository navigation
feat(grok): build native provider integration - #844
Merged
Merged
Conversation
…the other headless packages
Preserve complete projection payloads through switch, duplicate and rewind so Grok summary metadata is not discarded. Add strict Grok snapshot reads and exclusive, summary-last file-set publication with rollback confined to owned unpublished directories. Pin the pushed headless and parser implementations. Verify 62 switching unit tests, nine filesystem/parser integration tests, app typechecking and an installed-Grok loopback resume using the app publisher. Full provider runtime and renderer registration remain subsequent stages. Refs #832
This was referenced Sep 9, 2026
Closed
Carry the installed-native control evidence forward and distinguish normal cleanup from the unresolved TUI crash and fallback lifetime boundary. Refs #832
Carry the published ACP and guard implementation into the source-only app build, and update integration gates with the scoped native fault evidence. Runtime and renderer registration remain the next stage. Refs #832
Owner
Author
|
Continuation checkpoint: 06719c3 brings the branch onto main 364e5a1 and fixes the new Codex clone caller to pass TranscriptPublication to both identity extraction and storage. The recorded-clone regression, full app typecheck and 84 provider-switch tests passed; app CI is green for that commit. 93e5a16 now pins published headless 4814a17 (owned ACP plus framed TUI guard) and updates the integration plan. With that exact pin, all seven source checkouts verify, full app typecheck and the 84 provider-switch tests pass. CI for this newest pin is separate from the preceding green run. Headless has 198 passing deterministic tests and green CI. Native fault proofs cover failed attachment, idle crash and mid-turn crash under independently verified test-only OS no-fork containment. Next is runtime/pane adoption, native session identity controls, and the app rendering/reset/registration work. Grok remains unselectable and this PR remains draft. Refs #832; refs Juliusolsson05/grok-code-headless#3. |
Integrate main 552914f, retaining both native package entries in the shared submodule manifest. Verify all eight runtime checkouts, full app typechecking and the provider-switch/capability tests.
Owner
Author
|
Follow-up: main advanced with the OpenCode Terminal package, producing a shared .gitmodules conflict on the new Grok pin. Resolved by retaining both package entries and syncing main 552914f in 51d37e5. All eight pinned runtime checkouts verify, full app typecheck passes, and 90 selected provider-switch/capability tests pass. The PR is mergeable again and its new CI run is in progress. No PR merge was performed. |
Pause further runtime implementation pending explicit approval. Separate capture, observed-case catalog, isolated runtime ownership, app translation, client reconciliation and final registration; distinguish existing verdicts and synthetic fault tests from a replayable lifecycle corpus. Refs #832
Owner
Author
|
Planning gate updated in 37f0e86: docs/decomposition/grok-controlled-runtime.md is PROPOSED and awaits explicit user approval. Further runtime implementation is paused. The next step after approval is recording real multi-source behavior, followed by an observed-case catalog, one isolated runtime owner, one app adaptation boundary, client reconciliation and final registration. The document identifies existing artifact limits, ownership decisions for user approval, forbidden imports, unknowns and fixture provenance/privacy rules. Metadata-only native probe verdicts and hand-authored fault packets are not being treated as an end-to-end recorded runtime corpus. Only documentation changed in this step. Refs #832. |
The approved decomposition put a process-owning session-runtime coordinator inside the Grok headless package. Every sibling package takes a consumer-spawned PTY and never spawns or kills a process, and every side process a session needs is started by the app session through a package helper whose handle it owns. The user rejected the divergence, so Stages 3 and 4 and the isolation rules now copy that shape: GrokHeadless takes the PTY, launch/prepareLaunch prepares the TUI, the leader and guard are app-started helpers, and reconciliation lives in an isolated reconcile/ layer like OpenCode Terminal. Refs #832 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DNfwByFTh7HaMdhuvvUMBC
Stage 1 of the controlled-runtime decomposition is complete in the headless package, and the plan is the record later sessions start from. The note names the produced artifacts, how each was verified, the coverage gap that remains, and that the installed native version is now 1.0.30 rather than the 1.0.25 of the earlier probes, so Stage 2 does not re-derive any of it. Refs #832 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DNfwByFTh7HaMdhuvvUMBC
The branch was 161 commits behind main, which left PR #844 conflicting, and a conflicting PR gets no CI run at all. The plan also needs a current base before Stage 4 builds src/providers/grok/ next to the siblings as they are now, not as they were when this branch last merged main. The only textual conflict was .gitmodules: main registered the extension API submodule at the same spot where this branch registered grok-code-headless. Both entries are kept. The auto-merged transcript engine only takes main's larger OpenCode transform deadline, and the Grok aliases in the Vite and Vitest configs are unaffected. Refs #832 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DNfwByFTh7HaMdhuvvUMBC
Stage 2 could not settle acceptance, Stop or terminal conversation changes without recordings, and the plan's unknowns 1 and 3 had to stay visible until evidenced. The Stage 1 status note now records what the three new 1.0.30 scenarios showed: - native adopts client prompt ids; - session/cancel stops only the running turn; - terminal /new is visible only in the terminal's own requests, while native keeps streaming the original session to it. It also records the product decisions still open for the catalog. Refs #832 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DNfwByFTh7HaMdhuvvUMBC
…story boundary
Stage 4 of the controlled-runtime decomposition (docs/decomposition/
grok-controlled-runtime.md), first commit: the runtime side of the
provider adapter.
- packages/grok-code-headless submodule bumped to the Stage 3 runtime
(6db1cfc): consumer-owned processes, acceptance-based submitPrompt,
rewrite-snapshot-marked durable entries, observer seams on the control
helper and guard.
- src/providers/grok/runtime/grokSession.ts: the AgentSession. Starts in
the one order the recordings pin (leader -> session over control ->
guard -> prepared launch -> terminal PTY -> attach), rolls back in
reverse on failure, re-seeds MCP on terminal-loaded, fences input on
session-switched, and maps headless events onto the session contract
(activity/semantic/entry/conditions/history/transcript-error/
live-state/exit). Prompts go over control only; cancelRunningTurn
sends the recorded session/cancel.
- runtime/promptDelivery.ts: SubmitPromptResult outcomes onto the shared
dispositions (not-sent -> retry, refused -> nothing ran, uncertain/
unconfirmed -> possibly performed, never resent).
- runtime/skillDiscovery.ts: empty by evidence; native Grok skill layout
is unrecorded and the plan forbids inventing it.
- renderer/ identity, composerSubmit, conditions/policy,
semanticFoldPolicy ('grok-acp' sources; snapshot rows never replace a
live turn).
- src/shared/types/session.ts: ProviderHistoryBoundaryEvent + the
'history-boundary' session event (reset/caught-up per generation);
Stage 5 delivers it through preload and both SessionFeeds.
- grokTranscript.live.test.ts migrated off the removed legacy
GrokHeadless API onto the app-owned process order.
Remaining Stage 4: renderer views/rows/mapper and registry wiring
(Stage 6), adapter tests against recorded output.
- ClaudeSessionEvents/CodexSessionEvents declare 'history-boundary' for AgentSession parity (optional-by-convention, like 'prompt-gate'; only grok emits it today). - grokSession emits the flat ProviderHistoryBoundaryEvent payload, maps the app's built-in MCP configs (bearer kept out of plain headers into the Authorization header) onto Grok's native server shape, and widens the condition snapshot's provider label pending Stage 6 registration. - skill discovery returns a visible notice with its empty roots. Both tsc projects are clean.
Picks up the verification fixes: the guard's terminal observer now reads reassembled frames (coalesced session/load chunks no longer drop terminal-loaded, the MCP re-seed trigger), the control passthroughs are async (a closed lifetime rejects instead of throwing through submitPrompt), and the live test reads isClosed through a getter — which GrokSession now does too for the same reason.
- GrokSession unit coverage mirroring the OpenCode terminal adapter tests: the recorded start order (leader -> session over control -> guard -> prepared launch -> PTY with --leader-socket/--resume args), rollback of already-started resources on guard and spawn failure, the session-switched fence (input dropped, pane not ready, switched error naming the bound identity), the MCP re-seed on terminal-loaded with the bearer mapped into Authorization, prompt outcome mapping (not-ready before start, acceptance via the first queue notification, refused, uncertain on control close), and teardown order with a late-exit silenced. 7 tests, injected fakes only (no grok binary). - Grok condition views (permission rendering native's own option list, cancel-only question, plan approval) following the OpenCode defineView/eraseRegistry pattern, and the grok condition state kinds in shared/types/providerConditions.ts mirroring the headless modules. Verified with the repo's own tsc -b (the per-project ad-hoc invocations read stale .tsc-out declarations; build mode rebuilds them).
- createGrokTranscriptEntryMapper: one durable row fans out into Claude-shaped feed entries (genuine user text; assistant text + tool_use blocks with parsed arguments; tool_result as its own user entry threaded by tool_use_id; reasoning sibling rows as thinking-only assistant entries). Synthetic user rows, system rows and opaque backend tool calls render nothing, each for the reason the header documents. uuids derive from (generation, lineStartOffset) so rewrite re-delivery dedups instead of duplicating. Identity envelope carries no row and no marker. - renderGrokOperation: fallback-only by evidence — no grok tool-row capture exists; specialized rows land one evidence-backed tool at a time. - Mapper unit tests (6) covering every fan-out and filter decision. Verified: grok provider tests 13/13, tsc -b clean.
…Feeds from one pure owner Per the decomposition plan, the shared pure reconciliation owner is named in the stage contract BEFORE either client is edited: renderer/session-runtime/historyBoundary.ts owns every decision a boundary forces (strictly-newer resets only, caught-up never clears, stale-chunk identity guard, the preserve list); transports never interpret. Transport, both feeds, one ordering discipline (jsonl-error's): the forwarder and the remote SessionFeedSource flush the 100 ms semantic window and the pending jsonl batch BEFORE the boundary crosses, and the boundary itself is never coalesced or cached for late joiners. - shared/sessionFeed: SessionHistoryBoundaryEvent + the onSessionHistoryBoundary contract member (SessionFeed.contract lock). - sessionManager manager event + per-session relay (ownership-gated, activity-marked); preload session:history-boundary; IpcSessionFeed; FakeSessionFeed; remote protocol/wire channel unions; WebSocketSessionFeed listener; session recorder allowlist. - replay parity: the recorded channel is real, and applyFeedEvent consumes boundaries through the same pure owner (wipe window, clear dedup, await a fresh turn_started — suffixes and api_error excepted) so recordings cannot diverge from production. Pure-owner tests (4) + transport suites green (38) + remote-client green; tsc -b clean. Desktop/phone client application and the grok-session-feed recordings land next.
All 12 review defects, with the two highs first: - HIGH natural exit orphans ownership: the headless 'exit' handler now releases the guard and the leader after the pane learns of the exit. The terminal was the guard's only dependent and nothing can attach to the leader anymore; keeping them leaked two processes until a stop() a dead pane never gets. Field-nilling makes a later stop() a no-op. - HIGH stop() racing start() leaks the starting helper: every stale-generation exit in start() now disposes exactly what THIS attempt created (leader, guard, PTY), the codex start-attempt shape reduced to Grok's three resources. - MEDIUM resume no longer sends a control session/load (an open catalog gap): the recorded restart-resume epoch has only the terminal loading and control re-seeding MCP on the load answer, so the adapter does exactly that. - MEDIUM leader loss and a refused terminal load are user-visible: grok_live_disconnected and grok_resume_failed jsonl-errors explain what was lost and what to do. - MEDIUM teardown no longer waits forever on the guard's exit acknowledgement (bounded 2 s race; a leaked temp dir beats a leaked lifecycle). - MEDIUM mapper uuids documented and pinned by test: generation-scoped on purpose — stable while the window lives, distinct across the reset that wipes it, so snapshots never dedup against superseded content. - MEDIUM test-claim gaps closed: natural exit releases helpers, stop-during-start disposes, the unconfirmed outcome maps to a possibly-performed never-retry failure, and the delivery policy has its own suite (5 tests). - LOWs: the readiness grace cannot undo the session-switch fence, dead rollback-test setup removed, live test reads isClosed through a getter. Grok provider tests 22/22; tsc -b clean.
…isions Both clients now consume the pure owner instead of deciding for themselves (the divergence Stage 5 existed to prevent): - Desktop (useIpcSubscriptions): onSessionHistoryBoundary flushes the semantic queue first (the jsonl/exit boundary discipline), asks session-runtime/historyBoundary.ts what the boundary means, and on an applied reset clears the superseded generation's entries, dedup set, history cursor and live turn state while conditions, busy state and exit state survive (the shared preserve list). A per-session gate in handleSemanticEvent drops stale suffixes until a fresh turn_started (api_error passes). Window identity and the gate live on WorkspaceRefs so they survive subscription restarts; the test refs factories gain the two refs. - Phone (TranscriptStore): boundaries route through the same owner; an applied reset reuses resetTranscript (whose preserve list the owner documents) and re-arms awaitingSemanticStart. The window survives the reset — wiping it would forget the generation just armed against and let a re-delivered duplicate boundary reset again. chunkFileConflicts now asks the owner (file identity, generation-aware once chunks carry one). - Replay already applies the same decisions (previous commit). tsc -b clean; remote-client, session-runtime and sessionFeed suites green.
The last Stage 5 deliverable: app-owned recordings of the app's own delivery behavior under testing/fixtures/grok-session-feed/. - The capture test (node side) drives the REAL wireSessionForwarder with the session-level script of a recorded rewrite (modeled on the corpus text-load-repeat generation-1 rewrite) and checks the result in byte-for-byte: committed rows batch ahead of the boundary, the 100 ms semantic preview is flushed before it, the boundary itself is never coalesced, and stale duplicate boundaries cross unchanged. - The replay test (renderer side) applies the checked-in recording through the shared fold: the reset wipes the superseded generation, the snapshot re-appends the conversation, the new answer lands after caught-up, and the recorded stale duplicates change nothing. The fold state is built by hand with the grok mapper until Stage 6 registers the kind. - The capture test lives in the node project and the replay test in the renderer project: the replay imports renderer-only modules, and a node-side import of them drags renderer files into the node tsc project (TS6307).
Adding 'grok' to AGENT_PROVIDER_KINDS turns the compile-forced checklist on: every registry row the compiler demands is filled, and nothing more. - registry.main: GrokSession as both session factories (grok has exactly one runtime shape — the native terminal), resolveTranscriptPath from the package, transcriptLastModifiedAt from the file mtime, honest personalAgentSkills:false (native skill discovery unrecorded), deliverGrokPrompt. - registry.renderer + capabilities: the shared Agent surface with the real native terminal (TileLeaf, no display pinning), GROK_IDENTITY/ VIEWS/condition+fold policies, the transcript mapper, fallback-only row dispatch, isSpawnTool:false until a spawn tool is captured. - registry.setup: optional like OpenCode (no launch blocking). - featureCapabilities: inAppResume + verified external resume command (recorded --resume attach); rewind/duplicate/extraction and switch edges off until the grok transcript-engine adapter exists — the switch-graph guard now scopes completeness to adapter-having kinds, with grok explicitly outside, rather than pretending edges exist. - BUILT_IN_MCP_DOMAINS_BY_PROVIDER.grok (seeded over control, re-seeded on the terminal load answer — the recorded tool.mcp path); SUPPRESSION_POLICY.grok (per-item rows, no whole-turn id, MCP pairing like codex); nativeHistoryControl enum + coverage; AgentTranscriptReader grok branches (no timestamps in rows; no item extractor until one is evidence-backed). - GrokConversationSource: native sessions index (summary.json walk via the package) with generated-title semantics, genuine-user prompts from chat_history; registered in the conversation service. - Enumeration tests extended (providerKind, providerFeatures). tsc -b clean; 228 tests green across providers, kind guards, conversations, session-runtime and grok.
…tch graph The last Stage 6 build item: grok joins the existing switch/duplicate/ rewind transactions. - grokTranscript gains snapshot loaders (loadGrokSnapshot / loadGrokSnapshotAt) returning the conversation document plus one rewind prompt reference per GENUINE user row, line-numbered exactly as the parser's decode numbers them; readGrokTranscript now reuses the loader so the read path cannot drift from the rewind path. - transcriptEngine's grokAdapter: read/locate/readAt/listPrompts/ plainDraft, resolveGrokTargetProfile (GROK_MODEL override, then the corpus-recorded grok-4.6; conservative 128k budget — an unknown window must fail before the source pane is retired), projectNativeResume through the parser's recorded projection (rows + summary sidecar intact), write through the atomic session publisher, sessionId from the summary identity. - featureCapabilities: grok rewind/duplicate/extraction on, full pairwise switch edges in both directions; the complete-graph guard covers every kind again, unchanged from its pre-grok form. tsc -b clean; provider features, providerSwitch, grok and conversations suites green.
Follow-up to e59632e: the per-provider expectation for OpenCode's targets also enumerates kinds and needed grok. 198/198 green.
The full app check surfaced three grok-registration follow-ups, none in
grok files:
- The four workspace test-refs factories and the rehydrate test gave
historyAwaitingTurnStartRef a bare Set instead of a ref OBJECT, so the
shared semantic gate's .has threw on every event ('a session event
sink threw'), failing five useIpcSubscriptions/OpenCode renderer
suites. Both refs are proper { current } objects now.
- providerChoices' picker expectations gain the Grok entries the kind
registration legitimately added (switch pickers list Grok, and every
provider's targets include grok:structured).
- The electron.system and terminalFollow failures were load flakes from
the 19-minute full run; both pass in isolation.
With these, the full npm run check suite is green (4251 tests).
…verywhere The review's unifying root cause: the parser's decode already owns the real user-row semantics, and three hand-rolled copies drifted from it. - Rewind prompt references now come from the DECODED document (user message entries), not a row classifier that also admitted the untagged <user_info> bootstrap — which resolveUserPrompt refused, breaking the rewind picker on 20 of 26 recorded sessions. New adapter-level test over the real session layout, including the moved format guard. - The chat-format and identity guards moved into the snapshot loaders, so every production read path (read/readAt/listPrompts) refuses unsupported formats and mismatched directories — not just a helper only tests called. The cwd identity check lives in loadGrokSnapshot. - The renderer mapper drops the bootstrap row and unwraps <user_query> exactly as decode does (46 of 50 corpus prompts are wrapped), so optimistic echoes reconcile by exact text instead of doubling every in-app prompt with a raw-tagged twin. Mapper tests use the corpus shapes. - The conversation source scopes with the shared family matcher (subdirectory sessions no longer vanish), decodes prompts through the same snapshot loader (preamble gone, wrapper gone), returns them newest-first per the contract, and survives a deleted cwd. - Model resolution is honest: newest native session's modelId (a rewind/duplicate's own model), then the corpus-recorded grok-4.6; the invented GROK_MODEL override is gone. - The dead transcriptLastModifiedAt is deleted (locator providers only; it resolved against the wrong cwd anyway). - The Stage 5 recording script is faithful to native shapes now (snapshot rows marked inRewriteSnapshot, the appended row past the declared snapshot end, <user_query>-wrapped user rows); the replay test uses the real registered fold factory; stale comments fixed. - Grok crosses the rewind IPC boundary (address shape unchanged). Grok provider tests 30/30; providerSwitch + conversations green; tsc -b clean.
- The Claude subagent sidecar watcher no longer starts on Grok panes: subagentsDirFromTranscript refuses Grok's fixed chat_history.jsonl row name (deriving a subagents dir from it fabricated a directory that never exists and turned a useless 600 ms poller on per pane), and the session-feed capture test emits 'removed' so its watcher stops. - The dead USER_TEXTS const in the Grok conversation source is gone (discovery intentionally lists without reading histories; prompts() serves search). - Misplaced comments restored to their owners (the adapter-registry note back above its map, OpenCode's feature comment back above OpenCode), and the AgentTranscriptReader grok branches now say they are unreachable rather than 'skipped'. tsc -b clean; subagents, provider features and grok suites green.
- The control plane accepts Grok end to end: the resume/switch/ agent-create command schemas and the control-sdk transcripts schema include 'grok' (the native-history results already listed it — the inputs refused what the outputs advertised). - A grok rewind or duplicate takes the SOURCE session's model (its summary's current_model_id) before the newest-session fallback, so an import cannot land under some other session's model. - The adapter-registry comment is whole again; the recording test uses single quotes like the rest of the file. tsc -b clean; grok, providerSwitch, control and control-sdk suites green (144 tests).
… agent-list filter Round-3 leftovers: the adapter-registry WHY comment was whole again (and the Grok profile comment now describes the source-model-first behavior), and the control plane's agent-list provider filter accepts 'grok' alongside its siblings and 'terminal'.
Juliusolsson05
marked this pull request as ready for review
September 19, 2026 04:05
…tion # Conflicts: # packages/agent-transcript-parser
This was referenced Sep 19, 2026
Juliusolsson05
added a commit
that referenced
this pull request
Sep 19, 2026
Bring #992's unified stage up to current main (117 commits). Five conflicts, plus one semantic conflict the type checker caught: - globalCapabilities: keep #992's placement vocabulary and add main's 'grok' provider. - featureReference: drop BOTH side's additions. #992 added system-perf, which main deleted as superseded (24c3604); main added tile-tabs, which #992 deletes. - remote-client SessionView: take main's v2 phone header plus Reader. #992's only change there was dropping `relatedAgentTabs`, which main's rewrite no longer passes. - performance/ui/PerformancePanel: deleted, as main superseded it with the Performance Monitor. #992's edit to it only removed a tileTabs read. - catalog.test: counts re-derived from the real merged catalog, 123 = #992's 119 + Goal Loop's 2 (#1001) + the 2 generated Grok splits (#844). The governance subtrahend goes to 42 and the right-hand side stays 102. - SEMANTIC: main's new performance-monitor/agentIdentity walked tileTabs/dispatchMode/Tab.root, all deleted by #992. It is ported to the stage model, where the always-visible index wins, the same rule as resolveAgentPaneLabel. Its tests move to the v3 fixture shape. The monitor's UI test had hidden a v2 literal behind an `unknown` cast. Verified: tsc -b clean. All 48 test files main added or changed since the merge base pass on the merged tree (renderer 64/64, unit 188/188), and so does catalog.test (24/24). Co-Authored-By: Claude Opus 5 (1M context) <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.
Status
Draft for the full Grok provider integration. Grok is not selectable yet. Continue implementation on this branch; older wiring PR #835 is already included.
Structure decision (2026-09-12): Grok mirrors Claude, Codex and OpenCode one-to-one. The app session (
src/providers/grok/runtime/grokSession.ts) spawns and owns every process: it prepares the launch, starts the leader and TUI guard helpers, spawns the TUI PTY and hands it toGrokHeadless, which never spawns or kills anything. Reconciliation lives in the package's isolatedreconcile/layer. The earlier plan's process-owningsession-runtimecoordinator is withdrawn (plan amendment 63e6924).Implemented in the app
docs/decomposition/grok-controlled-runtime.md(approved staged decomposition, amended 63e6924 for the sibling structure).Component progress
Stage 1 (record real Grok behaviour) is complete in headless PR #1, and the plan records the exit gate:
Earlier installed Grok 1.0.25 proofs passed for normal guarded TUI/MCP/permissions and failed attachment, idle crash and mid-turn crash. These are scoped component proofs, not app readiness.
App verification
Remaining gates (in plan order)
Stage 1done (see above; headless PR refactor: reshape tree, break up god-files, go all-absolute imports #1 now carries 446 green tests through Stage 3 and the verification round).Stage 2done: the catalog/contract landed in PR refactor: reshape tree, break up god-files, go all-absolute imports #1 (30 facts, 5 decisions — all approved, including the user-confirmed Stop-cancels-foreign-turn), re-derived from the corpus by gates.Stage 3done: the package is the sibling-shaped runtime (consumer-owned processes, acceptance-based submitPrompt, rewrite-snapshot-marked durable entries); PR refactor: reshape tree, break up god-files, go all-absolute imports #1's verification round found and fixed the guard's coalesced-chunk observer bug and the submitPrompt sync-throw.Stage 4done:src/providers/grok/— GrokSession (recorded start order + rollback, session-switch fence, MCP re-seed on terminal-loaded, outcome-mapped delivery), prompt delivery policy, renderer (views/mapper/dispatch/policies), 25 tests; the adapter review's 12 findings (2 high) are fixed.Stage 5done: the history-boundary event flows through preload and BOTH SessionFeeds with jsonl-error's flush-first ordering, and desktop, phone and replay all apply the ONE pure owner (renderer/session-runtime/historyBoundary.ts); wire-form recordings under testing/fixtures/grok-session-feed/.Stage 6done: grok registered in every compile-forced row, GrokConversationSource in the catalog, and the transcript-engine adapter (snapshot loaders, recorded native-resume projection, atomic publisher) completes the pairwise switch graph — Claude, Codex and OpenCode panes can switch/duplicate/rewind into Grok and back.Verification: app
npm run checkgreen (4,251 tests; two Electron suites that flaked under the 19-minute full run pass in isolation), headlessnpm run checkgreen (446 tests, CI 6/6),tsc -bclean. Orchestrated review sign-off: the Stage 4 adapter review's 12 findings and the Stage 5+6 review's 10 findings are all fixed and re-verified through four review rounds — the final round returned no findings. One unrelated environmental failure exists (an imageAttachment corpus fixture cites a personal session file deleted outside the repo). Note: GitHub Actions stopped queueing runs for this repository mid-day (last run anywhere 02:38; third-party suites frozen queued), so the newest commits carry local verification only until CI un-stalls. Merge awaits the user's explicit decision.Refs #832
Headless: Juliusolsson05/grok-code-headless#1
Parser: Juliusolsson05/agent-transcript-parser#27
No Electron app launch or PR merge was performed. No merge is authorized.
🤖 Generated with Claude Code
https://claude.ai/code/session_01DNfwByFTh7HaMdhuvvUMBC