feat(server): index worktrees for active agents, outside the repo

apps/mobile/src/features/files/FileCodeRelationships.tsx

@@ -50,7 +50,7 @@ function coverageLine(coverage: ProjectCodeCoverage): string {
     case "stale":
       return "Stale · some files changed since indexing. Verify in source.";
     case "unavailable":
-      return "The code index is unavailable for this checkout.";
+      return "The code index is not ready for this checkout.";
   }
 }
 
@@ -220,7 +220,7 @@ function Body(props: {
   return (
     <ScrollView className="max-h-80" nestedScrollEnabled>
       <Note>{coverageLine(data.coverage)}</Note>
-      {data.nodes.length === 0 ? (
+      {data.coverage.state === "unavailable" ? null : data.nodes.length === 0 ? (
         <Note>No indexed declarations in this file. Its language may be unsupported.</Note>
       ) : (
         data.nodes.map((node) => (

apps/mobile/src/features/settings/ThreadSettingsSections.tsx

@@ -244,40 +244,81 @@ function BetaSettingsSection() {
       environment.connection.phase === "connected" &&
       environment.serverConfig?.environment.capabilities.peerLinks === true,
   );
-  const writable = useEnvironmentsWithScope(supported, AuthSettingsWriteScope);
+  const indexing = environments.filter(
+    (environment) =>
+      environment.connection.phase === "connected" &&
+      environment.serverConfig?.environment.capabilities.projectCode === true,
+  );
+  const writable = useEnvironmentsWithScope(environments, AuthSettingsWriteScope);
   const updateSettings = useAtomCommand(serverEnvironment.updateSettings, {
     label: "linked environments beta update",
     reportFailure: true,
   });
-  if (supported.length === 0) return null;
+  if (supported.length === 0 && indexing.length === 0) return null;
   return (
-    <View className="gap-3">
-      <SettingsSection title="Beta: Linked environments">
-        {supported.map((environment) => {
-          const policy = environment.serverConfig?.managedPolicy;
-          const managed = isManagedSettingPath(policy, "linkedEnvironmentsEnabled");
-          return (
-            <SettingsSwitchRow
-              key={environment.environmentId}
-              icon="link"
-              label={environment.label}
-              {...(managed ? { subtitle: `Managed by ${policy?.organization}.` } : {})}
-              value={environment.serverConfig?.settings.linkedEnvironmentsEnabled === true}
-              disabled={managed || !writable.has(environment.environmentId)}
-              onValueChange={(value) =>
-                void updateSettings({
-                  environmentId: environment.environmentId,
-                  input: { patch: { linkedEnvironmentsEnabled: value } },
-                })
-              }
-            />
-          );
-        })}
-      </SettingsSection>
-      <Text className="px-2 text-sm text-foreground-muted">
-        Let agents on a machine work on your other machines, and theirs on it. Turn it on for each
-        machine. While it is off, nothing new starts over a link; tasks already running finish.
-      </Text>
+    <View className="gap-6">
+      {supported.length === 0 ? null : (
+        <View className="gap-3">
+          <SettingsSection title="Beta: Linked environments">
+            {supported.map((environment) => {
+              const policy = environment.serverConfig?.managedPolicy;
+              const managed = isManagedSettingPath(policy, "linkedEnvironmentsEnabled");
+              return (
+                <SettingsSwitchRow
+                  key={environment.environmentId}
+                  icon="link"
+                  label={environment.label}
+                  {...(managed ? { subtitle: `Managed by ${policy?.organization}.` } : {})}
+                  value={environment.serverConfig?.settings.linkedEnvironmentsEnabled === true}
+                  disabled={managed || !writable.has(environment.environmentId)}
+                  onValueChange={(value) =>
+                    void updateSettings({
+                      environmentId: environment.environmentId,
+                      input: { patch: { linkedEnvironmentsEnabled: value } },
+                    })
+                  }
+                />
+              );
+            })}
+          </SettingsSection>
+          <Text className="px-2 text-sm text-foreground-muted">
+            Let agents on a machine work on your other machines, and theirs on it. Turn it on for
+            each machine. While it is off, nothing new starts over a link; tasks already running
+            finish.
+          </Text>
+        </View>
+      )}
+      {indexing.length === 0 ? null : (
+        <View className="gap-3">
+          <SettingsSection title="Beta: Automatic code indexing">
+            {indexing.map((environment) => {
+              const policy = environment.serverConfig?.managedPolicy;
+              const managed = isManagedSettingPath(policy, "autoCodeIndexEnabled");
+              return (
+                <SettingsSwitchRow
+                  key={environment.environmentId}
+                  icon="magnifyingglass"
+                  label={environment.label}
+                  {...(managed ? { subtitle: `Managed by ${policy?.organization}.` } : {})}
+                  value={environment.serverConfig?.settings.autoCodeIndexEnabled !== false}
+                  disabled={managed || !writable.has(environment.environmentId)}
+                  onValueChange={(value) =>
+                    void updateSettings({
+                      environmentId: environment.environmentId,
+                      input: { patch: { autoCodeIndexEnabled: value } },
+                    })
+                  }
+                />
+              );
+            })}
+          </SettingsSection>
+          <Text className="px-2 text-sm text-foreground-muted">
+            Index a project when you add it, and a worktree while an agent works in it. A worktree's
+            index is removed when its thread settles. While this is off, a checkout only indexes
+            when something asks it a code question.
+          </Text>
+        </View>
+      )}
     </View>
   );
 }

apps/server/src/config.ts

@@ -45,6 +45,7 @@ export interface ServerDerivedPaths {
   readonly providerStatusCacheDir: string;
   readonly worktreesDir: string;
   readonly attachmentsDir: string;
+  readonly codeIndexDir: string;
   readonly browserArtifactsDir: string;
   readonly logsDir: string;
   readonly serverTracePath: string;
@@ -161,6 +162,7 @@ export const deriveServerPaths = Effect.fn(function* (
     providerStatusCacheDir,
     worktreesDir: join(baseDir, "worktrees"),
     attachmentsDir,
+    codeIndexDir: join(stateDir, "code-index"),
     browserArtifactsDir: join(stateDir, "browser-artifacts"),
     logsDir,
     serverTracePath: join(logsDir, "server.trace.ndjson"),
@@ -185,6 +187,7 @@ export const ensureServerDirectories = Effect.fn(function* (derivedPaths: Server
       fs.makeDirectory(derivedPaths.providerLogsDir, { recursive: true }),
       fs.makeDirectory(derivedPaths.terminalLogsDir, { recursive: true }),
       fs.makeDirectory(derivedPaths.attachmentsDir, { recursive: true }),
+      fs.makeDirectory(derivedPaths.codeIndexDir, { recursive: true }),
       fs.makeDirectory(derivedPaths.worktreesDir, { recursive: true }),
       fs.makeDirectory(path.dirname(derivedPaths.keybindingsConfigPath), { recursive: true }),
       fs.makeDirectory(path.dirname(derivedPaths.settingsPath), { recursive: true }),

apps/server/src/orchestration-v2/RunFinalizationService.test.ts

@@ -15,6 +15,7 @@ import {
   ProviderInstanceId,
   RunId,
   ThreadId,
+  VcsProcessExitError,
   type OrchestrationV2ThreadShell,
 } from "@t3tools/contracts";
 import * as Deferred from "effect/Deferred";
@@ -29,9 +30,12 @@ import * as TestClock from "effect/testing/TestClock";
 
 import * as ServerConfig from "../config.ts";
 import * as CodeIntelligence from "../project/knowledge/CodeIntelligence.ts";
+import { indexRootFor } from "../project/knowledge/codeIndexLayout.ts";
 import * as ModelEvaluations from "../modelEvaluations/ModelEvaluations.ts";
 import * as PullRequestService from "../pullRequest/PullRequestService.ts";
+import * as ServerSettings from "../serverSettings.ts";
 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
+import * as VcsDriver from "../vcs/VcsDriver.ts";
 import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
 import * as WorkspaceEntries from "../workspace/WorkspaceEntries.ts";
 import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
@@ -425,6 +429,13 @@ it.effect("finalizes a run without waiting for the code index refresh its checkp
           const threadId = ThreadId.make("thread_index_refresh");
           const runId = RunId.make("run_index_refresh");
           const scopeId = CheckpointScopeId.make("scope_index_refresh");
+          const configContext = yield* Layer.build(
+            ServerConfig.layerTest(process.cwd(), { prefix: "t3-finalize-index-config-" }).pipe(
+              Layer.provide(NodeServices.layer),
+            ),
+          );
+          const config = yield* ServerConfig.ServerConfig.pipe(Effect.provide(configContext));
+          const indexRoot = indexRootFor(config.codeIndexDir, root);
           const layer = RunFinalization.layer.pipe(
             Layer.provideMerge(RunFinalization.layerObserver),
             Layer.provideMerge(CodeIntelligence.layer),
@@ -465,6 +476,19 @@ it.effect("finalizes a run without waiting for the code index refresh its checkp
                       truncated: false,
                     }),
                 }),
+                Layer.mock(VcsDriver.VcsDriver)({
+                  checkpoints: {} as VcsDriver.VcsDriver["Service"]["checkpoints"],
+                  listWorkspaceFiles: () =>
+                    Effect.fail(
+                      new VcsProcessExitError({
+                        operation: "test",
+                        command: "git ls-files",
+                        cwd: root,
+                        exitCode: 128,
+                        detail: "not a git repository",
+                      }),
+                    ),
+                }),
                 Layer.mock(PullRequestService.PullRequestService)({
                   refreshAfterTurn: () => Effect.void,
                 }),
@@ -479,6 +503,8 @@ it.effect("finalizes a run without waiting for the code index refresh its checkp
                       workingTree: { files: [], insertions: 0, deletions: 0 },
                     }),
                 }),
+                ServerSettings.layerTest(),
+                Layer.succeed(ServerConfig.ServerConfig, config),
               ),
             ),
           );
@@ -492,12 +518,12 @@ it.effect("finalizes a run without waiting for the code index refresh its checkp
           const finalize = finalization.finalize({ threadId, runId, scopeId });
           const published = () =>
             Effect.promise(() =>
-              NodeFSP.readFile(NodePath.join(root, ".codegraph-t3/published"), "utf8"),
+              NodeFSP.readFile(NodePath.join(indexRoot, ".codegraph-t3/published"), "utf8"),
             );
 
           // A checkout nobody has queried is not indexed behind the user's back.
           yield* finalize;
-          assert.isFalse(NodeFS.existsSync(NodePath.join(root, ".codegraph-t3")));
+          assert.isFalse(NodeFS.existsSync(indexRoot));
 
           assert.deepEqual(yield* intelligence.refresh({ projectId }), {
             _tag: "Published",
@@ -510,7 +536,7 @@ it.effect("finalizes a run without waiting for the code index refresh its checkp
           const buildHeld = yield* Deferred.make<void>();
           const releaseBuild = yield* Deferred.make<void>();
           const lease = yield* withWorkspaceLease(
-            NodePath.join(root, ".codegraph-t3"),
+            indexRoot,
             Deferred.succeed(buildHeld, undefined).pipe(
               Effect.andThen(Deferred.await(releaseBuild)),
             ),

apps/server/src/orchestration-v2/testkit/ProviderReplayHarness.ts

@@ -99,6 +99,7 @@ export function makeReplayServerConfig(
     const providerLogsDir = path.join(logsDir, "provider");
     const terminalLogsDir = path.join(logsDir, "terminals");
     const attachmentsDir = path.join(stateDir, "attachments");
+    const codeIndexDir = path.join(stateDir, "code-index");
     const environmentThemesDir = path.join(stateDir, "themes");
     const worktreesDir = path.join(baseDir, "worktrees");
     const providerStatusCacheDir = path.join(baseDir, "caches");
@@ -109,6 +110,7 @@ export function makeReplayServerConfig(
       providerLogsDir,
       terminalLogsDir,
       attachmentsDir,
+      codeIndexDir,
       environmentThemesDir,
       worktreesDir,
       providerStatusCacheDir,
@@ -152,6 +154,7 @@ export function makeReplayServerConfig(
       providerStatusCacheDir,
       worktreesDir,
       attachmentsDir,
+      codeIndexDir: path.join(stateDir, "code-index"),
       browserArtifactsDir: path.join(stateDir, "browser-artifacts"),
       environmentThemesDir,
       logsDir,