chore: sync with upstream (2026-10-27)

.github/scripts/ci-changes.cjs

@@ -32,6 +32,8 @@ const RUST = /^native\/(resource-monitor|kde-snap-shot|hyprland-snap-shot)\//;
 
 // These tests read other packages without declaring dependencies.
 const TEST_ONLY_DEPS = {
+  // Evals import the server's source to test its real model-facing text.
+  "@t3tools/evals": ["t3"],
   "@t3tools/provider-pi": ["@t3tools/client-runtime"],
   "@t3tools/scripts": [
     "@t3tools/desktop",

.github/workflows/agent-context-budget.yml

@@ -0,0 +1,55 @@
+name: Agent Context Budget
+
+# Fails when a PR raises a value in agentContextBudget.json above main's. AgentContextBudget.test.ts
+# keeps that file equal to the measured context, so the context cannot grow by editing the file.
+# To accept growth on purpose, a maintainer adds the agent-context-increase label.
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled, unlabeled]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: agent-context-budget-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  budget:
+    name: Agent context budget
+    runs-on: ubuntu-24.04
+    timeout-minutes: 5
+    env:
+      BUDGET: apps/server/src/provider/agentContextBudget.json
+      ALLOW_INCREASE: ${{ contains(github.event.pull_request.labels.*.name, 'agent-context-increase') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: apps/server/src/provider/agentContextBudget.json
+          sparse-checkout-cone-mode: false
+
+      - name: Compare with main
+        run: |
+          git fetch --quiet --depth=1 origin main
+          if ! git cat-file -e "FETCH_HEAD:$BUDGET" 2>/dev/null; then
+            echo "main has no agent context budget yet."
+            exit 0
+          fi
+          git show "FETCH_HEAD:$BUDGET" > "$RUNNER_TEMP/main.json"
+          grown=$(jq -r --slurpfile main "$RUNNER_TEMP/main.json" '
+            to_entries[]
+            | select($main[0][.key] != null and .value > $main[0][.key])
+            | "\(.key): \($main[0][.key]) -> \(.value) (+\(.value - $main[0][.key]))"
+          ' "$BUDGET")
+          if [ -z "$grown" ]; then
+            echo "Agent context is not larger than main."
+            exit 0
+          fi
+          printf 'Agent context grew compared to main:\n%s\n' "$grown"
+          if [ "$ALLOW_INCREASE" = "true" ]; then
+            echo "Accepted by the agent-context-increase label."
+            exit 0
+          fi
+          echo "::error file=$BUDGET::Agent context grew compared to main. Cut the added text, or ask a maintainer to add the agent-context-increase label."
+          exit 1

AGENTS.md

@@ -90,7 +90,7 @@ The most common defect in this repo is a change that works on the path you teste
 
 An empty database is a bad test. Seed your worktree's `.t3` with a copy of real data instead of pointing at live state:
 
-- The first `vp run dev` in a worktree does this for you when its database is missing. `--no-seed` or `T3CODE_DEV_SEED=0` skips it.
+- The first `vp run dev` in a worktree does this for you when its database is missing and the source is at most 500 MiB. Larger sources warn and dev starts with an empty database. `--no-seed` or `T3CODE_DEV_SEED=0` skips seeding. Manual migration still accepts larger sources and may use substantial disk space before pruning.
 - Run `vp run migrate-dev-db` with your dev server stopped to refresh. It rebuilds `<worktree>/.t3/userdata/statev2.sqlite` from a read-only snapshot of `~/.t3/userdata/statev2.sqlite`, the developer's real data. It keeps recent projects and their stopped threads, and drops scheduled tasks, pending work, and auth sessions, so your dev server never runs the developer's agents. Raise `--projects` and `--threads-per-project` for more data.
 - Refresh `statev2.sqlite`, not `state.sqlite`. The server copies the V1 `state.sqlite` only when `statev2.sqlite` is missing.
 - Bring `secrets` and `settings.json` only if the flow under test needs them.
@@ -136,6 +136,10 @@ An empty database is a bad test. Seed your worktree's `.t3` with a copy of real
 
 For authorized mobile verification, a missing or outdated native client is an install step, not a blocker. Run `vp run mobile:install <ios|android> [device-id]` on the device host before starting Metro; it targets the only booted simulator or connected Android device when the id is omitted. It installs the dev client for this checkout's native fingerprint from the shared cache in seconds and builds only when no machine has built it yet, so prefer it over `expo run:*`, `xcodebuild`, or `gradlew`, which rebuild from scratch. Its stdout is one JSON line; build output goes to the log it names. See `test-t3-mobile` for the full workflow.
 
+## Evals
+
+`evals/` checks how real models behave with T3 Code's model-facing text: agent instructions, MCP tool descriptions and schemas, and generated titles. Before you change that text, read [evals/README.md](evals/README.md) and run the evals it names. When you fix a model behavior bug, add a case that fails before the fix.
+
 ## Pull requests
 
 - Never make a PR unless the developer explicitly asks you to do so.

README.md

@@ -94,6 +94,7 @@ We are (mostly) not accepting contributions yet. Small fixes may be considered.
 
 Full docs live in [docs/](./docs). There's no docs site yet.
 
+- [FAQ](./docs/user/faq.md)
 - [Install and first run](./docs/user/install.md)
 - [Permission modes](./docs/user/permission-modes.md)
 - [Keyboard shortcuts](./docs/user/keybindings.md)

apps/desktop/src/app/DesktopAppActivation.ts

@@ -382,7 +382,10 @@ export const make = Effect.gen(function* () {
         webContents.send(DESKTOP_APP_ACTIVATION_REQUEST_CHANNEL, request);
       });
     }),
-    complete: (response) => Effect.sync(() => broker.complete(response)),
+    // The IPC handler owns the activation-completion span.
+    complete: Effect.fnUntraced(function* (response) {
+      return yield* Effect.sync(() => broker.complete(response));
+    }),
   });
 });
 

apps/desktop/src/app/DesktopObservability.ts

@@ -459,90 +459,91 @@ const makeBackendOutputLogShape = (
 ): Effect.Effect<DesktopBackendOutputLogShape> =>
   Option.match(sink, {
     onNone: () => Effect.succeed(DesktopBackendOutputLogNoop),
-    onSome: (logFile) =>
-      Effect.gen(function* () {
-        const sessionRef = yield* Ref.make(Option.none<BackendOutputSession>());
-        const writeFailure = Effect.fn("desktop.observability.backendOutput.writeFailure")(
-          function* (session: BackendOutputSession, details: string) {
-            yield* writeBackendChildLogRecord(logFile, {
-              message: "backend child process failure output start",
-              level: "ERROR",
-              annotations: {
-                component: "desktop-backend-child",
-                runId: session.runId,
-                instanceId: id,
-                phase: "START",
-                details: session.startDetails,
-              },
-            });
-            for (const output of session.chunks) {
-              yield* writeBackendChildLogRecord(logFile, {
-                message: "backend child process output",
-                level: output.streamName === "stderr" ? "ERROR" : "INFO",
-                annotations: {
-                  component: "desktop-backend-child",
-                  runId: session.runId,
-                  instanceId: id,
-                  stream: output.streamName,
-                  text: textDecoder.decode(output.chunk.subarray(output.offset)),
-                },
-              });
-            }
-            yield* writeBackendChildLogRecord(logFile, {
-              message: "backend child process failure output end",
-              level: "ERROR",
-              annotations: {
-                component: "desktop-backend-child",
-                runId: session.runId,
-                instanceId: id,
-                phase: "END",
-                details: sanitizeLogValue(details),
-              },
-            });
+    // The enclosing operation owns the span for this inline handler.
+    onSome: Effect.fnUntraced(function* (logFile) {
+      const sessionRef = yield* Ref.make(Option.none<BackendOutputSession>());
+      const writeFailure = Effect.fn("desktop.observability.backendOutput.writeFailure")(function* (
+        session: BackendOutputSession,
+        details: string,
+      ) {
+        yield* writeBackendChildLogRecord(logFile, {
+          message: "backend child process failure output start",
+          level: "ERROR",
+          annotations: {
+            component: "desktop-backend-child",
+            runId: session.runId,
+            instanceId: id,
+            phase: "START",
+            details: session.startDetails,
           },
-        );
-        return {
-          beginSession: Effect.fn("desktop.observability.backendOutput.beginSession")(function* ({
-            details,
-          }) {
-            const runId = yield* currentDesktopRunId;
-            yield* Ref.set(
-              sessionRef,
-              Option.some({
-                runId,
-                startDetails: sanitizeLogValue(details),
-                chunks: [],
-                byteLength: 0,
-              }),
-            );
-          }),
-          writeOutputChunk: Effect.fnUntraced(function* (streamName, chunk) {
-            if (environment.isDevelopment) {
-              yield* writeDevelopmentConsoleOutput(streamName, chunk);
-            }
-            yield* Ref.update(
-              sessionRef,
-              Option.map((session) => appendBoundedOutputChunk(session, streamName, chunk)),
-            );
-          }),
-          persistFailureSnapshot: Effect.fn(
-            "desktop.observability.backendOutput.persistFailureSnapshot",
-          )(function* ({ details }) {
-            const session = yield* Ref.get(sessionRef);
-            if (Option.isSome(session)) {
-              yield* writeFailure(session.value, details);
-            }
-          }),
-          persistFailure: Effect.fn("desktop.observability.backendOutput.persistFailure")(
-            function* ({ details }) {
-              const session = yield* Ref.modify(sessionRef, (current) => [current, Option.none()]);
-              if (Option.isNone(session)) return;
-              yield* writeFailure(session.value, details);
+        });
+        for (const output of session.chunks) {
+          yield* writeBackendChildLogRecord(logFile, {
+            message: "backend child process output",
+            level: output.streamName === "stderr" ? "ERROR" : "INFO",
+            annotations: {
+              component: "desktop-backend-child",
+              runId: session.runId,
+              instanceId: id,
+              stream: output.streamName,
+              text: textDecoder.decode(output.chunk.subarray(output.offset)),
             },
-          ),
-          discardSession: Ref.set(sessionRef, Option.none()),
-        } satisfies DesktopBackendOutputLogShape;
-      }),
+          });
+        }
+        yield* writeBackendChildLogRecord(logFile, {
+          message: "backend child process failure output end",
+          level: "ERROR",
+          annotations: {
+            component: "desktop-backend-child",
+            runId: session.runId,
+            instanceId: id,
+            phase: "END",
+            details: sanitizeLogValue(details),
+          },
+        });
+      });
+      return {
+        beginSession: Effect.fn("desktop.observability.backendOutput.beginSession")(function* ({
+          details,
+        }) {
+          const runId = yield* currentDesktopRunId;
+          yield* Ref.set(
+            sessionRef,
+            Option.some({
+              runId,
+              startDetails: sanitizeLogValue(details),
+              chunks: [],
+              byteLength: 0,
+            }),
+          );
+        }),
+        writeOutputChunk: Effect.fnUntraced(function* (streamName, chunk) {
+          if (environment.isDevelopment) {
+            yield* writeDevelopmentConsoleOutput(streamName, chunk);
+          }
+          yield* Ref.update(
+            sessionRef,
+            Option.map((session) => appendBoundedOutputChunk(session, streamName, chunk)),
+          );
+        }),
+        persistFailureSnapshot: Effect.fn(
+          "desktop.observability.backendOutput.persistFailureSnapshot",
+        )(function* ({ details }) {
+          const session = yield* Ref.get(sessionRef);
+          if (Option.isSome(session)) {
+            yield* writeFailure(session.value, details);
+          }
+        }),
+        persistFailure: Effect.fn("desktop.observability.backendOutput.persistFailure")(function* ({
+          details,
+        }) {
+          const session = yield* Ref.modify(sessionRef, (current) => [current, Option.none()]);
+          if (Option.isNone(session)) return;
+          yield* writeFailure(session.value, details);
+        }),
+        discardSession: Ref.set(sessionRef, Option.none()),
+      } satisfies DesktopBackendOutputLogShape;
+    }),
   });
 
 const layerBackendOutputLogFactory = Layer.effect(
@@ -589,7 +590,9 @@ const layerBackendOutputLogFactory = Layer.effect(
       });
 
     return DesktopBackendOutputLogFactory.of({
-      forInstance: (id) => makeForId(id),
+      forInstance: Effect.fn("DesktopBackendOutputLogFactory.forInstance")(function (id) {
+        return makeForId(id);
+      }),
     });
   }),
 );

apps/desktop/src/app/DesktopWebLinks.ts

@@ -69,16 +69,15 @@ const make = Effect.gen(function* () {
   });
 
   return DesktopWebLinks.of({
-    receive: (url) =>
-      Effect.suspend(() => {
+    receive: Effect.fn("DesktopWebLinks.receive")(function (url) {
+      return Effect.suspend(() => {
         pending.push(url);
         return flush;
-      }).pipe(Effect.withSpan("DesktopWebLinks.receive")),
-    setRendererReady: (ready) =>
-      (ready ? startListening : Effect.sync(stopListening)).pipe(
-        Effect.andThen(flush),
-        Effect.withSpan("DesktopWebLinks.setRendererReady"),
-      ),
+      });
+    }),
+    setRendererReady: Effect.fn("DesktopWebLinks.setRendererReady")(function (ready) {
+      return ready ? startListening : Effect.sync(stopListening);
+    }, Effect.andThen(flush)),
   });
 });