chore(fork): integrate upstream v0.1.7-nightly.20261101.4048

FORK.md

@@ -126,8 +126,8 @@ The shared plumbing packets register into, specified in
 | ----------------------------------------------------------------------------------------------- | --------------------------- | ----------------------------------------------------------------------------------------------------------- |
 | `apps/mobile/src/features/settings/SettingsProjectOverviewRouteScreen.tsx`                      | `ext-settings`              | Mount project agent-tool choices for each selected computer.                                                |
 | `apps/server/src/provider/AgentContextBudget.test.ts`                                           | `ext-mcp`                   | Measure the ordinary session catalog through production capability filtering.                               |
-| `apps/server/src/orchestration-v2/ProviderSessionManager.ts`                                    | `ext-mcp`                   | Prepare and reuse credentials with project tool-family capabilities.                                        |
-| `apps/server/src/orchestration-v2/ProviderSessionManager.test.ts`                               | `ext-mcp`                   | Verify stable credential reuse and replacement when tool families change.                                   |
+| `apps/server/src/orchestration-v2/ProviderSessionManager.ts`                                    | `ext-mcp`                   | Prepare project tool-family capabilities and keep credentials when they change.                             |
+| `apps/server/src/orchestration-v2/ProviderSessionManager.test.ts`                               | `ext-mcp`                   | Verify the credential stays stable when tool families change.                                               |
 | `apps/server/src/mcp/McpInvocationContext.ts`                                                   | `ext-mcp`                   | Admit Hardware, Reach and Sites session capabilities.                                                       |
 | `apps/server/src/mcp/McpToolAccess.ts`                                                          | `ext-mcp`                   | Check family capabilities on direct tool calls.                                                             |
 | `apps/server/src/server.ts`                                                                     | `ext-mcp`                   | Supply the shared tool policy before orchestration without a fork-runtime cycle.                            |
@@ -249,6 +249,8 @@ The renderer follows the web app's React version, which comes from the workspace
 | File                                                            | Packet                | Why                                                                          |
 | --------------------------------------------------------------- | --------------------- | ---------------------------------------------------------------------------- |
 | `apps/web/src/hooks/useThreadActionMenu.ts`                     | `attention-status`    | Retry failed runs and resume held queues from the conversation header.       |
+| `apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts`  | `project-profiles`    | Pre-approve the read-only project settings tool in read-only sandboxes.      |
+| `evals/mcp-tool-use/devices.test.ts`                            | `project-profiles`    | Expect the project-scoped device access denial agents can resolve from chat. |
 | `apps/web/src/components/Sidebar.tsx`                           | `library-projects`    | Use the Library retention setting in single and bulk delete confirmations.   |
 | `apps/web/src/hooks/useThreadActions.permissions.test.ts`       | `library-projects`    | Await async confirmation while preserving permission rechecks.               |
 | `apps/web/src/hooks/useThreadActions.ts`                        | `library-projects`    | Explain saved Library retention before deleting an archived thread.          |
@@ -280,7 +282,6 @@ The renderer follows the web app's React version, which comes from the workspace
 | `apps/mobile/src/features/threads/ThreadMarkdownImage.test.tsx` | `cloudflare-access`   | Keep the native Access keychain out of markdown image tests.                 |
 | `apps/server/src/orchestration-v2/ThreadFork.execution.test.ts` | `deleted-history`     | Expect the deleted-source refusal that rejects a side chat first.            |
 | `apps/server/src/process/externalLauncher.test.ts`              | `hermetic-tests`      | Keep the host's installed editors out of the Insiders bundle case.           |
-| `apps/server/src/usage/UsageService.test.ts`                    | `hermetic-tests`      | Pin the clock so removed-directory usage stays inside retention.             |
 
 L46 adds the print check worker to the server pack entries in `apps/server/vite.config.ts`
 (`fork: model-print-check`) so the worker ships beside `bin.mjs`. The single-file executable
@@ -593,11 +594,9 @@ The `test-temp-isolation` seam in `apps/server/src/git/GitManager.test.ts` (9) c
 test's extra worktree inside its own scoped temp directory. Upstream placed them beside the
 scoped repository, so every run left orphaned worktree folders in `$TMPDIR`.
 
-The `hermetic-tests` seams keep upstream tests independent of the host and today's date.
+The `hermetic-tests` seams keep upstream tests independent of the host.
 `externalLauncher.test.ts` (3 marker lines) hides the host's real editor installs from the
-macOS VS Code Insiders case, and `UsageService.test.ts` (2) pins the clock in the
-removed-directory usage case so its saved usage is not pruned. Upstream's `main` pins that
-clock itself after this nightly; drop the `UsageService.test.ts` seam once that lands.
+macOS VS Code Insiders case.
 
 The `agent-work` seams add one Delete all for archived subagent and bot run conversations to
 Settings > Archived. Parent conversations keep their agent receipts and runs keep their results,

apps/desktop/scripts/main-process-bundle.test.mjs

@@ -3,6 +3,7 @@ import * as NodeFSP from "node:fs/promises";
 import * as NodeOS from "node:os";
 import * as NodePath from "node:path";
 import * as NodeVM from "node:vm";
+import * as NodeURL from "node:url";
 import { build } from "vite-plus/pack";
 import { assert, it } from "vite-plus/test";
 
@@ -114,18 +115,16 @@ it("loads the emitted packaged boot entry and backend cache preload", async () =
   const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-desktop-boot-"));
   try {
     const entries = ["src/boot.ts", "src/compileCache.ts"];
-    await NodeFSP.mkdir(NodePath.join(directory, "src"));
-    await Promise.all(
-      entries.map((entry) =>
-        NodeFSP.copyFile(new URL(`../${entry}`, import.meta.url), NodePath.join(directory, entry)),
-      ),
-    );
     assert.ok(Array.isArray(desktopConfig.pack));
     for (const packConfig of desktopConfig.pack) {
       if (!Array.isArray(packConfig.entry)) continue;
       if (!packConfig.entry.some((entry) => entries.includes(entry))) continue;
       await build({
         ...packConfig,
+        entry: packConfig.entry.map((entry) =>
+          NodeURL.fileURLToPath(new URL(`../${entry}`, import.meta.url)),
+        ),
+        outDir: NodePath.join(directory, "dist-electron"),
         config: false,
         cwd: directory,
         tsconfig: false,

apps/desktop/src/app/DesktopManagedPolicy.ts

@@ -0,0 +1,65 @@
+/**
+ * DesktopManagedPolicy - the administrator's managed policy as the desktop app reads it, at most
+ * once: every desktop check needs the same answer.
+ *
+ * @module DesktopManagedPolicy
+ */
+import type { ManagedPolicyDocument } from "@t3tools/contracts";
+import {
+  layerWindowsRegistry,
+  ManagedPolicyFileError,
+  readManagedPolicy,
+  WindowsRegistry,
+} from "@t3tools/shared/managedPolicyFile";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { ChildProcessSpawner } from "effect/process";
+
+import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+
+type FoundPolicy = Effect.Success<ReturnType<typeof readManagedPolicy>>;
+const isManagedPolicyFileError = Schema.is(ManagedPolicyFileError);
+
+export class DesktopManagedPolicy extends Context.Service<
+  DesktopManagedPolicy,
+  {
+    /** The policy on this machine, undefined without one; fails when it cannot be used. */
+    readonly read: Effect.Effect<FoundPolicy, ManagedPolicyFileError>;
+  }
+>()("@t3tools/desktop/app/DesktopManagedPolicy") {}
+
+export const layer = Layer.effect(
+  DesktopManagedPolicy,
+  Effect.gen(function* () {
+    const { platform } = yield* DesktopEnvironment.DesktopEnvironment;
+    const read = yield* Effect.cached(
+      readManagedPolicy(platform).pipe(
+        Effect.provideService(FileSystem.FileSystem, yield* FileSystem.FileSystem),
+        Effect.provideService(
+          ChildProcessSpawner.ChildProcessSpawner,
+          yield* ChildProcessSpawner.ChildProcessSpawner,
+        ),
+        Effect.provideService(WindowsRegistry, yield* WindowsRegistry),
+      ),
+    );
+    return DesktopManagedPolicy.of({ read });
+  }),
+).pipe(Layer.provide(layerWindowsRegistry(() => import("ffi-rs"))));
+
+/** A machine with `policy` deployed, one whose policy cannot be used, or none. */
+export const layerTest = (policy?: ManagedPolicyDocument | ManagedPolicyFileError) =>
+  Layer.succeed(
+    DesktopManagedPolicy,
+    DesktopManagedPolicy.of({
+      read:
+        policy === undefined
+          ? // @effect-diagnostics-next-line effectSucceedWithVoid:off - No policy is undefined, not void.
+            Effect.succeed(undefined)
+          : isManagedPolicyFileError(policy)
+            ? Effect.fail(policy)
+            : Effect.succeed({ source: "/test/policy.json", document: policy }),
+    }),
+  );

apps/desktop/src/backend/DesktopBackendConfiguration.test.ts

@@ -8,9 +8,11 @@ import * as Layer from "effect/Layer";
 import * as ManagedRuntime from "effect/ManagedRuntime";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
 import { ChildProcessSpawner } from "effect/process";
 
 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
+import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts";
 import * as DesktopBackendConfiguration from "./DesktopBackendConfiguration.ts";
 import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
 import * as DesktopConfig from "../app/DesktopConfig.ts";
@@ -22,6 +24,8 @@ import * as DesktopWslServerTree from "../wsl/DesktopWslServerTree.ts";
 const layerShellEnvironment = (prepared = true) =>
   Layer.succeed(DesktopShellEnvironment.DesktopShellEnvironment, {
     installIntoProcess: Effect.succeed(prepared),
+    awaitDiscovery: Effect.succeed(prepared),
+    updates: Stream.empty,
   });
 
 const layerBackendConfiguration = (prepared = true) =>
@@ -245,6 +249,7 @@ describe("DesktopBackendConfiguration", () => {
         assert.equal(first.cwd, environment.backendCwd);
         assert.equal(first.captureOutput, true);
         assert.equal(first.env.ELECTRON_RUN_AS_NODE, "1");
+        assert.equal(first.env.T3CODE_DESKTOP_SHELL_DISCOVERY_PENDING, "1");
         assert.isUndefined(first.env.T3CODE_PORT);
         assert.isUndefined(first.env.T3CODE_MODE);
         assert.isUndefined(first.env.T3CODE_DESKTOP_LAN_HOST);
@@ -1010,6 +1015,7 @@ describe("DesktopBackendConfiguration", () => {
         Layer.provideMerge(DesktopAppSettings.layerTest()),
         Layer.provideMerge(DesktopWslServerTree.layerTest()),
         Layer.provideMerge(DesktopWslEnvironment.layer),
+        Layer.provideMerge(DesktopManagedPolicy.layerTest()),
         Layer.provideMerge(
           Layer.succeed(
             ChildProcessSpawner.ChildProcessSpawner,

apps/desktop/src/backend/DesktopBackendConfiguration.ts

@@ -543,6 +543,7 @@ const resolvePrimaryStartConfig = Effect.fn("desktop.backendConfiguration.resolv
       env: {
         ...backendChildEnvPatch(),
         ELECTRON_RUN_AS_NODE: "1",
+        T3CODE_DESKTOP_SHELL_DISCOVERY_PENDING: "1",
         T3CODE_CLI_PATH: Option.getOrUndefined(input.cliPath),
       },
       extendEnv: true,

apps/desktop/src/backend/DesktopServerExposure.test.ts

@@ -7,13 +7,15 @@ import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
 import * as ChildProcess from "effect/process/ChildProcess"; // fork: tailnet-ownership
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 
 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
 import * as DesktopConfig from "../app/DesktopConfig.ts";
+import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts";
 import * as DesktopNetworkInterfaces from "./DesktopNetworkInterfaces.ts";
 import * as DesktopServerExposure from "./DesktopServerExposure.ts";
 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
@@ -133,6 +135,7 @@ function layer(input: {
   readonly env?: Record<string, string | undefined>;
   readonly spawnerLayer?: Layer.Layer<ChildProcessSpawner.ChildProcessSpawner>;
   readonly desktopSettingsLayer?: Layer.Layer<DesktopAppSettings.DesktopAppSettings>;
+  readonly managedPolicyLayer?: Layer.Layer<DesktopManagedPolicy.DesktopManagedPolicy>;
 }) {
   const env = { T3CODE_HOME: input.baseDir, ...input.env };
   const layerEnvironment = layerEnvironmentFor(input.baseDir, env);
@@ -142,6 +145,7 @@ function layer(input: {
 
   return DesktopServerExposure.layer.pipe(
     Layer.provideMerge(input.desktopSettingsLayer ?? DesktopAppSettings.layer),
+    Layer.provideMerge(input.managedPolicyLayer ?? DesktopManagedPolicy.layerTest()),
     Layer.provideMerge(NodeFileSystem.layer),
     Layer.provideMerge(NodeHttpClient.layerUndici),
     Layer.provideMerge(input.spawnerLayer ?? layerMockSpawner()),
@@ -165,6 +169,7 @@ const withHarness = <A, E, R>(
   env: Record<string, string | undefined> = {},
   spawnerLayer?: Layer.Layer<ChildProcessSpawner.ChildProcessSpawner>,
   desktopSettingsLayer?: Layer.Layer<DesktopAppSettings.DesktopAppSettings>,
+  managedPolicyLayer?: Layer.Layer<DesktopManagedPolicy.DesktopManagedPolicy>,
 ) =>
   Effect.gen(function* () {
     const fileSystem = yield* FileSystem.FileSystem;
@@ -179,6 +184,7 @@ const withHarness = <A, E, R>(
           env,
           ...(spawnerLayer ? { spawnerLayer } : {}),
           ...(desktopSettingsLayer ? { desktopSettingsLayer } : {}),
+          ...(managedPolicyLayer ? { managedPolicyLayer } : {}),
         }),
       ),
     );
@@ -234,6 +240,41 @@ describe("DesktopServerExposure", () => {
     ),
   );
 
+  it.effect("starts local-only, Serve off, when a managed policy keeps clients local", () =>
+    withHarness(
+      lanNetworkInterfaces,
+      Effect.gen(function* () {
+        const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
+        const settings = yield* DesktopAppSettings.DesktopAppSettings;
+        yield* settings.setServerExposureMode("network-accessible");
+        yield* settings.setTailscaleServe({ enabled: true, port: Option.none() });
+
+        const state = yield* serverExposure.configureFromSettings({ port: 4173 });
+        assert.equal(state.mode, "local-only");
+        const backendConfig = yield* serverExposure.backendConfig;
+        assert.equal(backendConfig.bindHost, "127.0.0.1");
+        assert.isFalse(backendConfig.tailscaleServeEnabled);
+        // Choosing them again while the policy applies does not widen the backend either.
+        yield* serverExposure.setMode("network-accessible");
+        yield* serverExposure.setTailscaleServeEnabled({ enabled: true });
+        assert.equal((yield* serverExposure.backendConfig).bindHost, "127.0.0.1");
+        assert.isFalse((yield* serverExposure.backendConfig).tailscaleServeEnabled);
+        // The saved choice returns once the policy allows it.
+        const saved = yield* settings.get;
+        assert.equal(saved.serverExposureMode, "network-accessible");
+        assert.isTrue(saved.tailscaleServeEnabled);
+      }),
+      {},
+      undefined,
+      undefined,
+      DesktopManagedPolicy.layerTest({
+        schemaVersion: 1,
+        organization: "Example Corp",
+        limits: { clients: ["desktop"] },
+      }),
+    ),
+  );
+
   it.effect("persists network-accessible mode and updates backend binding state", () =>
     withHarness(
       lanNetworkInterfaces,

apps/desktop/src/backend/DesktopServerExposure.ts

@@ -33,6 +33,7 @@ import * as Semaphore from "effect/Semaphore";
 import * as HttpClient from "effect/http/HttpClient";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 
+import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts";
 import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
 import * as DesktopConfig from "../app/DesktopConfig.ts";
 import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; // fork: tailnet-ownership
@@ -586,6 +587,18 @@ export const make = Effect.gen(function* () {
       Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, childProcessSpawner),
     );
 
+  // The server refuses to bind wider than the policy's clients allow, so network access or Serve
+  // saved before the policy would keep the backend from starting. The backend runs without them;
+  // the saved choice stays for when the policy allows it.
+  const remoteAllowed = yield* (yield* DesktopManagedPolicy.DesktopManagedPolicy).read.pipe(
+    Effect.map((found) => found?.document.limits?.clients?.includes("remote") ?? true),
+    Effect.orElseSucceed(() => false),
+  );
+  const withinPolicy = (settings: DesktopAppSettings.DesktopSettings) =>
+    remoteAllowed
+      ? settings
+      : { ...settings, serverExposureMode: "local-only" as const, tailscaleServeEnabled: false };
+
   const readCurrentState = (currentNetworkInterfaces: DesktopNetworkInterfaces.NetworkInterfaces) =>
     Ref.get(stateRef).pipe(
       Effect.map((state) =>
@@ -611,8 +624,8 @@ export const make = Effect.gen(function* () {
       const settings = yield* desktopSettings.get;
       const currentNetworkInterfaces = yield* readNetworkInterfaces;
       const resolved = resolveRuntimeState({
-        requestedMode: settings.serverExposureMode,
-        settings,
+        requestedMode: withinPolicy(settings).serverExposureMode,
+        settings: withinPolicy(settings),
         port,
         networkInterfaces: currentNetworkInterfaces,
         advertisedHostOverride: config.desktopLanHostOverride,
@@ -634,8 +647,8 @@ export const make = Effect.gen(function* () {
     };
     const currentNetworkInterfaces = yield* readNetworkInterfaces;
     const resolved = resolveRuntimeState({
-      requestedMode: mode,
-      settings: nextSettings,
+      requestedMode: withinPolicy(nextSettings).serverExposureMode,
+      settings: withinPolicy(nextSettings),
       port: previous.port,
       networkInterfaces: currentNetworkInterfaces,
       advertisedHostOverride: config.desktopLanHostOverride,
@@ -679,9 +692,12 @@ export const make = Effect.gen(function* () {
         });
       }
       // Refuse before saving: the backend would only fail to claim the port on every launch.
-      const inspection = input.enabled
-        ? yield* inspectServe({ port: current.port, servePort })
-        : null;
+      // A policy that keeps clients local saves the choice without applying it, so skip the check.
+      // fork: tailnet-ownership
+      const inspection =
+        input.enabled && remoteAllowed
+          ? yield* inspectServe({ port: current.port, servePort })
+          : null;
       if (inspection !== null && REFUSED_TAILSCALE_SERVE_STATES.has(inspection.state)) {
         return yield* new DesktopTailscaleServeRefusedError({
           port: servePort,
@@ -707,7 +723,7 @@ export const make = Effect.gen(function* () {
 
       const nextState = yield* Ref.updateAndGet(stateRef, (current) => ({
         ...current,
-        tailscaleServeEnabled: result.settings.tailscaleServeEnabled,
+        tailscaleServeEnabled: withinPolicy(result.settings).tailscaleServeEnabled,
         tailscaleServePort: result.settings.tailscaleServePort,
       }));