Sync main-xavier with upstream main

.oxlintrc.json

@@ -9,7 +9,7 @@
     "**/routeTree.gen.ts"
   ],
   "plugins": ["eslint", "oxc", "react", "unicorn", "typescript"],
-  "jsPlugins": ["./oxlint-plugin-t3code/index.ts"],
+  "jsPlugins": ["./oxlint-plugin-t3code/index.js"],
   "categories": {
     "correctness": "warn",
     "suspicious": "warn",

README.md

@@ -40,6 +40,16 @@ brew install --cask t3-code
 yay -S t3code-bin
 ```
 
+## Fork Releases
+
+If you want desktop releases and auto-updates from a fork or branch such as `main-xavier`, use the `Release Desktop` GitHub Actions workflow with:
+
+- `target_branch`: the branch you want to release from, for example `main-xavier`
+- `publish_cli`: `false` for fork/private desktop-only releases
+- `finalize_version_bump`: `false` unless you want the workflow to push the version bump commit back to that branch
+
+The packaged desktop app will target the current GitHub repository for updater assets during CI builds, so fork releases will update from that fork's GitHub Releases.
+
 ## Some notes
 
 We are very very early in this project. Expect bugs.

apps/desktop/src/settings/DesktopClientSettings.test.ts

@@ -13,6 +13,7 @@ import * as DesktopClientSettings from "./DesktopClientSettings.ts";
 
 const clientSettings: ClientSettings = {
   autoOpenPlanSidebar: false,
+  assistantResponseCopyFormat: "markdown",
   confirmThreadArchive: true,
   confirmThreadDelete: false,
   dismissedProviderUpdateNotificationKeys: [],

apps/server/integration/OrchestrationEngineHarness.integration.ts

@@ -216,12 +216,15 @@ export interface OrchestrationIntegrationHarness {
       timeoutMs?: number,
     ): Effect.Effect<Receipt, never>;
   };
+  readonly startReactor: Effect.Effect<void, never>;
   readonly dispose: Effect.Effect<void, never>;
 }
 
 interface MakeOrchestrationIntegrationHarnessOptions {
   readonly provider?: ProviderDriverKind;
   readonly realCodex?: boolean;
+  readonly rootDir?: string;
+  readonly autoStartReactor?: boolean;
 }
 
 export const makeOrchestrationIntegrationHarness = (
@@ -244,9 +247,11 @@ export const makeOrchestrationIntegrationHarness = (
           makeAdapterRegistryMock({ [adapterHarness.provider]: adapterHarness.adapter }),
         )
       : null;
-    const rootDir = yield* fileSystem.makeTempDirectoryScoped({
-      prefix: "t3-orchestration-integration-",
-    });
+    const rootDir =
+      options?.rootDir ??
+      (yield* fileSystem.makeTempDirectoryScoped({
+        prefix: "t3-orchestration-integration-",
+      }));
     const workspaceDir = path.join(rootDir, "workspace");
     const { stateDir, dbPath } = yield* deriveServerPaths(rootDir, undefined).pipe(
       Effect.provideService(Path.Path, path),
@@ -404,9 +409,12 @@ export const makeOrchestrationIntegrationHarness = (
     ).pipe(Effect.orDie);
 
     const scope = yield* Scope.make("sequential");
-    yield* tryRuntimePromise("start OrchestrationReactor", () =>
+    const startReactor = tryRuntimePromise("start OrchestrationReactor", () =>
       runtime.runPromise(reactor.start().pipe(Scope.provide(scope))),
     ).pipe(Effect.orDie);
+    if (options?.autoStartReactor !== false) {
+      yield* startReactor;
+    }
     const receiptHistory = yield* Ref.make<ReadonlyArray<OrchestrationRuntimeReceipt>>([]);
     yield* Stream.runForEach(runtimeReceiptBus.streamEventsForTest, (receipt) =>
       Ref.update(receiptHistory, (history) => [...history, receipt]).pipe(Effect.asVoid),
@@ -546,6 +554,7 @@ export const makeOrchestrationIntegrationHarness = (
       waitForDomainEvent,
       waitForPendingApproval,
       waitForReceipt,
+      startReactor,
       dispose,
     } satisfies OrchestrationIntegrationHarness;
   });

apps/server/integration/orchestrationEngine.integration.test.ts

@@ -1,5 +1,6 @@
 // @effect-diagnostics nodeBuiltinImport:off
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 import {
@@ -106,6 +107,17 @@ function withHarness<A, E>(
   ).pipe(Effect.provide(NodeServices.layer));
 }
 
+function withHarnessOptions<A, E>(
+  options: Parameters<typeof makeOrchestrationIntegrationHarness>[0],
+  use: (harness: OrchestrationIntegrationHarness) => Effect.Effect<A, E>,
+) {
+  return Effect.acquireUseRelease(
+    makeOrchestrationIntegrationHarness(options),
+    use,
+    (harness) => harness.dispose,
+  ).pipe(Effect.provide(NodeServices.layer));
+}
+
 function withRealCodexHarness<A, E>(
   use: (harness: OrchestrationIntegrationHarness) => Effect.Effect<A, E>,
 ) {
@@ -266,6 +278,90 @@ it.live("runs a single turn end-to-end and persists checkpoint state in sqlite +
   ),
 );
 
+it.live("replays queued follow-ups after orchestration restarts", () =>
+  Effect.gen(function* () {
+    const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3-orchestration-queue-restart-"));
+
+    yield* withHarnessOptions({ rootDir }, (harness) =>
+      Effect.gen(function* () {
+        yield* seedProjectAndThread(harness);
+
+        yield* harness.engine.dispatch({
+          type: "thread.queued-follow-up.enqueue",
+          commandId: CommandId.makeUnsafe("cmd-queued-follow-up-restart-enqueue"),
+          threadId: THREAD_ID,
+          followUp: {
+            id: "follow-up-restart-1",
+            createdAt: nowIso(),
+            prompt: "Resume this after restart",
+            attachments: [],
+            terminalContexts: [],
+            modelSelection: {
+              instanceId: ProviderInstanceId.make("codex"),
+              provider: "codex",
+              model: DEFAULT_MODEL_BY_PROVIDER[ProviderDriverKind.make("codex")] ?? DEFAULT_MODEL,
+            },
+            runtimeMode: "approval-required",
+            interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+            lastSendError: null,
+          },
+          createdAt: nowIso(),
+        });
+
+        const queuedThread = yield* harness.waitForThread(
+          THREAD_ID,
+          (thread) => thread.queuedFollowUps.length === 1,
+        );
+        assert.equal(queuedThread.queuedFollowUps[0]?.prompt, "Resume this after restart");
+      }),
+    );
+
+    yield* withHarnessOptions({ rootDir, autoStartReactor: false }, (harness) =>
+      Effect.gen(function* () {
+        yield* harness.adapterHarness!.queueTurnResponseForNextSession({
+          events: [
+            {
+              type: "turn.started",
+              ...runtimeBase("evt-queued-restart-1", "2026-03-28T12:05:00.000Z"),
+              threadId: THREAD_ID,
+              turnId: FIXTURE_TURN_ID,
+            },
+            {
+              type: "message.delta",
+              ...runtimeBase("evt-queued-restart-2", "2026-03-28T12:05:00.050Z"),
+              threadId: THREAD_ID,
+              turnId: FIXTURE_TURN_ID,
+              delta: "Recovered queued follow-up output.\n",
+            },
+            {
+              type: "turn.completed",
+              ...runtimeBase("evt-queued-restart-3", "2026-03-28T12:05:00.100Z"),
+              threadId: THREAD_ID,
+              turnId: FIXTURE_TURN_ID,
+              status: "completed",
+            },
+          ],
+        });
+
+        yield* harness.startReactor;
+
+        const recoveredThread = yield* harness.waitForThread(
+          THREAD_ID,
+          (thread) =>
+            thread.queuedFollowUps.length === 0 &&
+            thread.messages.some(
+              (message) =>
+                message.role === "assistant" &&
+                message.text.includes("Recovered queued follow-up output."),
+            ),
+        );
+
+        assert.equal(recoveredThread.queuedFollowUps.length, 0);
+      }),
+    );
+  }).pipe(Effect.provide(NodeServices.layer)),
+);
+
 it.live.skipIf(!process.env.CODEX_BINARY_PATH)(
   "keeps the same Codex provider thread across runtime mode switches",
   () =>

apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts

@@ -148,6 +148,7 @@ describe("OrchestrationEngine", () => {
           archivedAt: null,
           deletedAt: null,
           messages: [],
+          queuedFollowUps: [],
           proposedPlans: [],
           activities: [],
           checkpoints: [],

apps/server/src/orchestration/Layers/OrchestrationEngine.ts

@@ -307,9 +307,13 @@ const makeOrchestrationEngine = Effect.gen(function* () {
       return yield* Deferred.await(result);
     });
 
+  const getReadModel: OrchestrationEngineShape["getReadModel"] = () =>
+    Effect.sync(() => commandReadModel);
+
   return {
     readEvents,
     dispatch,
+    getReadModel,
     // Each access creates a fresh PubSub subscription so that multiple
     // consumers (wsServer, ProviderRuntimeIngestion, CheckpointReactor, etc.)
     // each independently receive all domain events.