@@ -510,6 +510,35 @@ it.layer(layerTest, { excludeTestServices: true })("WorkspaceEntries", (it) => {
         expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
       }),
     );
+
+    it.effect("finds a path inside a gitignored nested git worktree only by its exact path", () =>
+      Effect.gen(function* () {
+        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-worktree-", git: true });
+        const env = {
+          ...process.env,
+          GIT_AUTHOR_NAME: "Test",
+          GIT_AUTHOR_EMAIL: "[email protected]",
+          GIT_COMMITTER_NAME: "Test",
+          GIT_COMMITTER_EMAIL: "[email protected]",
+        };
+        yield* writeTextFile(cwd, ".gitignore", ".worktrees/\n");
+        yield* git(cwd, ["add", ".gitignore"]);
+        yield* git(cwd, ["commit", "-m", "init"], env);
+        yield* git(cwd, ["worktree", "add", "-b", "x", ".worktrees/x"]);
+        yield* writeTextFile(cwd, ".worktrees/x/src/foo.py", "print(1)");
+
+        const exact = yield* searchWorkspaceEntries({
+          cwd,
+          query: "src/foo.py",
+          limit: 25,
+          kind: "file",
+        });
+        expect(exact.entries).toEqual([{ path: ".worktrees/x/src/foo.py", kind: "file" }]);
+
+        const partial = yield* searchWorkspaceEntries({ cwd, query: "src/fo", limit: 25 });
+        expect(partial.entries.map((entry) => entry.path)).not.toContain(".worktrees/x/src/foo.py");
+      }),
+    );
   });
 
   describe("searchContents", () => {
 
@@ -260,7 +260,7 @@ export const make = Effect.gen(function* () {
       const normalizedQuery = normalizeSearchQuery(input.query, {
         trimLeadingPattern: /^[@./]+/,
       });
-      return yield* Effect.gen(function* () {
+      const result = yield* Effect.gen(function* () {
         const searchIndex = yield* WorkspaceSearchIndex.WorkspaceSearchIndex;
         return yield* searchIndex.search(normalizedQuery, input.limit, input.kind, input.imageOnly);
       }).pipe(
@@ -270,9 +270,83 @@ export const make = Effect.gen(function* () {
           ),
         ),
       );
+      if (input.kind === "directory" || input.imageOnly) return result;
+      const worktreeFiles = yield* findNestedWorktreeFiles(
+        normalizedCwd,
+        input.query,
+        result.entries,
+      );
+      if (worktreeFiles.length === 0) return result;
+      const entries = [...worktreeFiles, ...result.entries];
+      return {
+        entries: entries.slice(0, input.limit),
+        truncated: result.truncated || entries.length > input.limit,
+      };
     },
   );
 
+  // The index skips gitignored folders, where agents often put worktrees (`.worktrees/x`).
+  // A path relative to such a worktree is found only when it names an existing file exactly.
+  const findNestedWorktreeFiles = Effect.fn("WorkspaceEntries.findNestedWorktreeFiles")(function* (
+    cwd: string,
+    query: string,
+    indexed: ReadonlyArray<ProjectEntry>,
+  ) {
+    const relativePath = query.trim().replaceAll("\\", "/");
+    if (
+      !relativePath.includes("/") ||
+      relativePath.endsWith("/") ||
+      path.isAbsolute(relativePath) ||
+      isWindowsAbsolutePath(relativePath) ||
+      relativePath.split("/").some((segment) => segment === "..") ||
+      indexed.some(
+        (entry) =>
+          entry.kind === "file" &&
+          (entry.path === relativePath || entry.path.endsWith(`/${relativePath}`)),
+      )
+    ) {
+      return [];
+    }
+    const listed = yield* vcsProcess
+      .run({
+        operation: "WorkspaceEntries.listWorktrees",
+        command: "git",
+        args: ["worktree", "list", "--porcelain"],
+        cwd,
+        allowNonZeroExit: true,
+        timeoutMs: 5_000,
+      })
+      .pipe(Effect.orElseSucceed(() => undefined));
+    if (!listed || listed.exitCode !== 0) return [];
+    const realCwd = yield* Effect.promise(() => NodeFSP.realpath(cwd).catch(() => cwd));
+    const worktreeRoots = listed.stdout.split(/\n\s*\n/).flatMap((record) => {
+      const lines = record.split("\n");
+      const worktree = lines.find((line) => line.startsWith("worktree "));
+      // A `prunable` record's directory is gone; another checkout may now sit there.
+      if (worktree === undefined || lines.some((line) => line.startsWith("prunable"))) return [];
+      const root = worktree.slice("worktree ".length);
+      const relativeRoot = path.relative(realCwd, root);
+      return relativeRoot === "" ||
+        relativeRoot === ".." ||
+        relativeRoot.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeRoot)
+        ? []
+        : [relativeRoot.split(path.sep).join("/")];
+    });
+    const matches = yield* Effect.promise(() =>
+      Promise.all(
+        worktreeRoots.map(async (relativeRoot) => {
+          const candidate = `${relativeRoot}/${relativePath}`;
+          const stat = await NodeFSP.stat(path.join(realCwd, candidate)).catch(() => null);
+          return stat?.isFile() ? candidate : null;
+        }),
+      ),
+    );
+    return matches
+      .filter((candidate) => candidate !== null)
+      .map((candidate): ProjectEntry => ({ path: candidate, kind: "file" }));
+  });
+
   const searchContents: WorkspaceEntries["Service"]["searchContents"] = Effect.fn(
     "WorkspaceEntries.searchContents",
   )(function* (input) {