Merge upstream 7df7cb9999 (sync stage 1 of 2)

.task-cache.json

@@ -0,0 +1,3 @@
+{
+  "endpoint": "https://t3-task-cache.pinglabs.workers.dev/projects/t3code"
+}

apps/coder-gateway/src/server.ts

@@ -106,7 +106,7 @@ function sendText(
     "Cache-Control": "no-store",
     "Content-Type": contentType,
     "Content-Security-Policy":
-      "default-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'; style-src 'self' 'unsafe-inline'; script-src 'self' 'wasm-unsafe-eval' 'sha256-66N88M2Gs4tvXNc8z6k+OKKok8OCKne3d83NpL7KJ9A='; connect-src 'self' blob: https: http: ws://127.0.0.1:*; img-src 'self' data: blob: https: http:; media-src 'self' blob: https: http:; worker-src 'self' blob:; object-src 'self' blob:; frame-src 'self' blob:",
+      "default-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'; style-src 'self' 'unsafe-inline'; script-src 'self' 'wasm-unsafe-eval' 'sha256-+xUlzIW26WOhLd/WV5CUp/KDzSwFacmCLHCiJxm72Yw='; connect-src 'self' blob: https: http: ws://127.0.0.1:*; img-src 'self' data: blob: https: http:; media-src 'self' blob: https: http:; worker-src 'self' blob:; object-src 'self' blob:; frame-src 'self' blob:",
     "X-Content-Type-Options": "nosniff",
     "X-Frame-Options": "DENY",
     "Cross-Origin-Resource-Policy": "same-origin",

apps/coder-helper/src/bin.ts

@@ -75,6 +75,19 @@ export const coderHelperStdioLayer = RpcServer.layer(
   Layer.provide(Layer.succeed(Logger.LogToStderr)(true)),
 );
 
-if (import.meta.main) {
+// Coder: upstream's `bin.ts` dispatch for `DocumentText.ts`, which runs office document text
+// extraction in a child process of the server's own entry point; here that is the helper bundle.
+if (import.meta.main && process.argv[2] === "__document-text") {
+  const { extractDocumentText } = await import("t3/src/provider/documentTextWorker.ts");
+  try {
+    process.stdout.write(await extractDocumentText(process.argv[3]!, process.argv[4]!));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && /^E[A-Z0-9]+$/.test(String(error.code))) {
+      throw error;
+    }
+    // Exit 2 identifies document rejections; OS and process failures remain retryable.
+    process.exitCode = 2;
+  }
+} else if (import.meta.main) {
   Layer.launch(coderHelperStdioLayer).pipe(NodeRuntime.runMain);
 }

apps/server/integration/SqlStatementCounter.integration.ts

@@ -5,11 +5,7 @@ export interface SqlStatementCounter {
   readonly count: () => number;
 }
 
-/**
- * Install the same counter on every runtime under test, otherwise statements
- * run by background reactors and statements run by request handlers land in
- * different counters.
- */
+/** Install on every test runtime to include background reactor statements. */
 export function makeSqlStatementCounter(): SqlStatementCounter {
   let statements = 0;
   const tracer = Tracer.make({

apps/server/integration/transferBudgetV2.integration.test.ts

@@ -16,7 +16,9 @@ import {
   EnvironmentAuthenticatedPrincipal,
   ORCHESTRATION_V2_WS_METHODS,
   OrchestrationV2RpcSchemas,
+  OrchestrationV2ThreadBoundedSnapshot,
   OrchestrationV2ThreadDetailSnapshot,
+  OrchestrationV2ThreadHistoryPage,
   OrchestrationV2ShellSnapshot,
   OrchestrationV2GetThreadProjectionError,
   OrchestrationV2GetShellSnapshotError,
@@ -63,11 +65,23 @@ import {
   type TransferBudgetRun,
 } from "./TransferBudgetReport.integration.ts";
 import { TRANSFER_HISTORY_TURN_COUNT } from "./fixtures/transferBudget.ts";
-import { THREAD_ID, threadCreated, turnEvents } from "./TransferBudgetV2Fixture.integration.ts";
+import {
+  LONG_TURN_THREAD_ID,
+  longTurnThreadBatches,
+  THREAD_ID,
+  threadCreated,
+  turnEvents,
+} from "./TransferBudgetV2Fixture.integration.ts";
 
 const decodeThreadSnapshot = Schema.decodeUnknownEffect(
   Schema.fromJsonString(Schema.toCodecJson(OrchestrationV2ThreadDetailSnapshot)),
 );
+const decodeBoundedSnapshot = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.toCodecJson(OrchestrationV2ThreadBoundedSnapshot)),
+);
+const decodeHistoryPage = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.toCodecJson(OrchestrationV2ThreadHistoryPage)),
+);
 const decodeShellSnapshot = Schema.decodeUnknownEffect(
   Schema.fromJsonString(Schema.toCodecJson(OrchestrationV2ShellSnapshot)),
 );
@@ -87,6 +101,10 @@ const layerManagement = Layer.unwrap(
       getThreadSnapshot: (id) => projections.getThreadSnapshot(id).pipe(Effect.orDie),
       getThreadSnapshotWindow: (id, options) =>
         projections.getThreadSnapshotWindow(id, options).pipe(Effect.orDie),
+      getThreadHistoryPage: (id, cursor, throughEntryId, conversationOnly) =>
+        projections
+          .getThreadHistoryPage(id, cursor, throughEntryId, conversationOnly)
+          .pipe(Effect.orDie),
       getThreadShell: (id) => projections.getThreadShell(id).pipe(Effect.orDie),
       getShellSnapshot: (options) => projections.getShellSnapshot(options).pipe(Effect.orDie),
       listActiveSubagentThreadIds: () =>
@@ -331,7 +349,29 @@ it.live("reports V2 thread HTTP and WebSocket transfer budgets", () =>
           const shellMode = yield* synchronized(rsq);
           const reconnectThread = { ...resumedThread.recorder.totals(), mode: threadMode };
           const reconnectShell = { ...resumedShell.recorder.totals(), mode: shellMode };
+          const reconnectSqlStatements = counter.count() - reconnectSqlStart;
           assert.equal(threadMode, "snapshot");
+
+          for (const events of longTurnThreadBatches(provider)) yield* sink.write({ events });
+          const longTurnColdOpen = yield* measureHttpGet({
+            url: `${base}/api/orchestration/threads/${LONG_TURN_THREAD_ID}/bounded?compactTurnItems=1`,
+            headers: { [ORCHESTRATION_PROTOCOL_HEADER]: String(ORCHESTRATION_PROTOCOL_VERSION) },
+          });
+          assert.equal(longTurnColdOpen.status, 200);
+          const coldOpen = yield* decodeBoundedSnapshot(
+            Buffer.from(longTurnColdOpen.decodedBody).toString(),
+          );
+          const cursor = coldOpen.historyCursor;
+          if (cursor === null) return yield* Effect.die("Expected older long-turn history");
+          const longTurnHistoryPage = yield* measureHttpGet({
+            url: `${base}/api/orchestration/threads/${LONG_TURN_THREAD_ID}/history?cursor=${encodeURIComponent(cursor)}`,
+            headers: { [ORCHESTRATION_PROTOCOL_HEADER]: String(ORCHESTRATION_PROTOCOL_VERSION) },
+          });
+          assert.equal(longTurnHistoryPage.status, 200);
+          const historyPage = yield* decodeHistoryPage(
+            Buffer.from(longTurnHistoryPage.decodedBody).toString(),
+          );
+          assert.isTrue(historyPage.hasMoreHistory);
           return {
             provider,
             threadSnapshot,
@@ -342,7 +382,12 @@ it.live("reports V2 thread HTTP and WebSocket transfer budgets", () =>
             measuredTurnSqlStatements,
             reconnectThread,
             reconnectShell,
-            reconnectSqlStatements: counter.count() - reconnectSqlStart,
+            reconnectSqlStatements,
+            longTurnColdOpen: {
+              http: longTurnColdOpen,
+              rows: coldOpen.projection.visibleTurnItems.length,
+            },
+            longTurnHistoryPage: { http: longTurnHistoryPage, rows: historyPage.items.length },
           } satisfies TransferBudgetRun;
         }).pipe(
           Effect.provide(Layer.fresh(layerServices).pipe(Layer.provideMerge(NodeServices.layer))),

apps/server/package.json

@@ -17,11 +17,14 @@
     "@t3tools/source-control-core": "workspace:*",
     "@t3tools/source-control-definitions": "workspace:*",
     "@t3tools/source-control-gitlab": "workspace:*",
+    "character-entities": "2.0.2",
     "effect": "catalog:",
     "node-pty": "1.2.0-beta.15",
+    "saxes": "6.0.0",
     "stream-chain": "^4.2.5",
     "stream-json": "3.6.0",
-    "yaml": "catalog:"
+    "yaml": "catalog:",
+    "yauzl": "^3.4.0"
   },
   "devDependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.276",
@@ -33,6 +36,7 @@
     "@t3tools/shared": "workspace:*",
     "@t3tools/source-control-testing": "workspace:*",
     "@types/node": "catalog:",
+    "@types/yauzl": "^3.4.0",
     "effect-acp": "workspace:*",
     "effect-codex-app-server": "workspace:*",
     "vite-plus": "catalog:"

apps/server/scripts/acp-mock-agent.ts

@@ -52,6 +52,7 @@ const emitGrokMonitorPostTurnPoll = process.env.T3_ACP_EMIT_GROK_MONITOR_POST_TU
 const emitGrokBackgroundTaskStarted = process.env.T3_ACP_EMIT_GROK_BACKGROUND_TASK_STARTED === "1";
 const emitGrokBackgroundTaskPoll = process.env.T3_ACP_GROK_BACKGROUND_TASK_COMPLETION === "poll";
 const emitForeignSessionUpdates = process.env.T3_ACP_EMIT_FOREIGN_SESSION_UPDATES === "1";
+const omitInitializeModelState = process.env.T3_ACP_OMIT_INITIALIZE_MODEL_STATE === "1";
 const waitForResumeRelease = process.env.T3_ACP_WAIT_FOR_RESUME_RELEASE === "1";
 const completeFirstPromptOnCancel = process.env.T3_ACP_COMPLETE_FIRST_PROMPT_ON_CANCEL === "1";
 const floodStderr = process.env.T3_ACP_FLOOD_STDERR === "1";
@@ -429,8 +430,7 @@ function modeState(): AcpCompat.SessionModeState {
   };
 }
 
-// Mirrors the real Grok ACP: it advertises versioned model ids, never the CLI's own
-// "grok-build" product name.
+// Grok ACP advertises versioned model ids, never the CLI product name.
 const grokAcpModels: ReadonlyArray<AcpCompat.ModelInfo> = [
   {
     modelId: process.env.T3_ACP_GROK_MODEL ?? "grok-4.6",
@@ -576,7 +576,7 @@ const program = Effect.gen(function* () {
       return {
         protocolVersion: 2,
         info: { name: "t3-acp-mock-agent", version: "0.0.0" },
-        _meta: { modelState: modelState() },
+        ...(omitInitializeModelState ? {} : { _meta: { modelState: modelState() } }),
         capabilities: {
           session: {
             ...(supportsSessionLifecycle ? { fork: {}, additionalDirectories: {} } : {}),
@@ -600,8 +600,7 @@ const program = Effect.gen(function* () {
     }),
   );
 
-  // Mirrors the real Antigravity agent: the API key method reads
-  // GEMINI_API_KEY from the process environment and rejects when it is missing.
+  // Antigravity requires GEMINI_API_KEY for API key authentication.
   yield* agent.handleAuthenticate((request) =>
     Effect.gen(function* () {
       if (antigravityProfile) {
@@ -938,21 +937,20 @@ const program = Effect.gen(function* () {
             },
           });
         });
-        yield* Effect.sleep("1200 millis")
-          .pipe(
-            Effect.andThen(
-              Effect.sync(() => {
-                writeJsonRpcNotification("_x.ai/task_completed", {
-                  sessionId: cancelledSessionId,
-                  update: {
-                    sessionUpdate: "task_completed",
-                    task_snapshot: { task_id: "task-bg-1", command: "sleep 30" },
-                  },
-                });
-              }),
-            ),
-          )
-          .pipe(Effect.forkDetach);
+        yield* Effect.sleep("1200 millis").pipe(
+          Effect.andThen(
+            Effect.sync(() => {
+              writeJsonRpcNotification("_x.ai/task_completed", {
+                sessionId: cancelledSessionId,
+                update: {
+                  sessionUpdate: "task_completed",
+                  task_snapshot: { task_id: "task-bg-1", command: "sleep 30" },
+                },
+              });
+            }),
+          ),
+          Effect.forkDetach,
+        );
       }
     }),
   );
@@ -962,6 +960,124 @@ const program = Effect.gen(function* () {
       const requestedSessionId = String(request.sessionId ?? sessionId);
       beginAcpMockPrompt(cancelledSessions, requestedSessionId);
       promptCount += 1;
+      const idleError = process.env.T3_ACP_IDLE_ERROR;
+      if (idleError === "grok-background" && promptCount === 1) {
+        // The structured completion lands before the prompt settles, so it is buffered.
+        const taskId = "call-idle-error-background";
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "tool_call",
+            toolCallId: taskId,
+            title: "run_terminal_command",
+            kind: "execute",
+            status: "in_progress",
+            rawInput: { command: "sleep 1; echo done" },
+          },
+        });
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: taskId,
+            status: "completed",
+            rawOutput: {
+              type: "BackgroundTaskStarted",
+              task_id: taskId,
+              task_type: "bash",
+              status: "running",
+              command: "sleep 1; echo done",
+            },
+          },
+        });
+        writeJsonRpcNotification("_x.ai/task_completed", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "task_completed",
+            task_snapshot: { task_id: taskId, kind: "bash", exit_code: 0, output: "done\n" },
+          },
+        });
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: { sessionUpdate: "state_update", state: "idle", stopReason: "error" },
+        });
+        return {};
+      }
+      if (idleError !== undefined && promptCount === 1) {
+        const toolCallId = "tool-call-idle-error-1";
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId,
+            title: "Terminal",
+            kind: "execute",
+            status: "in_progress",
+            rawInput: { command: ["long-running-tool"] },
+          },
+        });
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "tool-call-idle-error-monitor",
+            title: "Monitor",
+            kind: "execute",
+            status: "in_progress",
+            rawInput: { command: ["background-monitor"] },
+          },
+        });
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "tool-call-idle-error-subagent",
+            title: "Subagent",
+            kind: "other",
+            status: "in_progress",
+            rawInput: {},
+          },
+        });
+        writeJsonRpcNotification("session/update", {
+          sessionId: "mock-child-session-idle-error",
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId: "tool-call-idle-error-child",
+            title: "Child tool",
+            kind: "execute",
+            status: "in_progress",
+            rawInput: { command: ["child-tool"] },
+          },
+        });
+        writeJsonRpcNotification("session/update", {
+          sessionId: requestedSessionId,
+          update: {
+            sessionUpdate: "state_update",
+            state: "idle",
+            stopReason: "error",
+            ...(idleError === "details"
+              ? { error: { code: -32000, message: "Missing Authentication header" } }
+              : {}),
+          },
+        });
+        // The agent outlives the failed prompt, so its subagent finishes afterwards.
+        yield* Effect.sleep("50 millis").pipe(
+          Effect.andThen(
+            Effect.sync(() =>
+              writeJsonRpcNotification("session/update", {
+                sessionId: requestedSessionId,
+                update: {
+                  sessionUpdate: "tool_call_update",
+                  toolCallId: "tool-call-idle-error-subagent",
+                  status: "completed",
+                },
+              }),
+            ),
+          ),
+          Effect.forkDetach,
+        );
+        return {};
+      }
       if (
         process.env.T3_ACP_CRASH_PROMPT === "1" &&
         request.prompt.some((part) => part.type === "text" && part.text === "crash now")
@@ -1464,11 +1580,9 @@ const program = Effect.gen(function* () {
             const detachedCommand = runningCommandIgnoresTerm
               ? 'trap "" TERM; bash -c \'trap "" TERM; while :; do sleep 1; done\' & child=$!; printf "%s %s %s\n" "$PPID" "$$" "$child" > "$1"; echo published; wait "$child"'
               : 'sleep 120 & child=$!; printf "%s %s %s\n" "$PPID" "$$" "$child" > "$1"; echo published; wait "$child"';
-            // Nested bash publishes "$PPID $$ $child" once it starts. Do not
-            // write the launcher PID alone here: that races with bash and can
-            // clobber the triple that interrupt tests wait for. It then prints a
-            // line, so an agent that exits after launch only exits once the
-            // triple exists instead of racing a slow launcher start.
+            // Only nested bash writes the "$PPID $$ $child" triple; writing the launcher PID
+            // here would race it. The launcher's printed line keeps the agent alive until the
+            // triple exists.
             const detachedLauncher = NodeChildProcess.spawn(
               process.execPath,
               ["-e", launcher, "bash", "-c", detachedCommand, "bash", runningCommandPidPath],
@@ -2322,7 +2436,7 @@ const program = Effect.gen(function* () {
       }
 
       if (emitXAiPlanMdWrite) {
-        // Match Grok's real session layout so isGrokPlanMarkdownPath accepts it.
+        // isGrokPlanMarkdownPath requires Grok's session layout.
         const planRoot = process.env.T3_ACP_PLAN_ROOT ?? "/tmp/mock-home/.grok";
         const planPath = `${planRoot}/sessions/${requestedSessionId}/plan.md`;
         const planBody = "# Mock plan\n\n- Write the feature\n- Add a test\n- Ship it\n";