fix(cli): t3 thread finds the project from inside its git worktrees

apps/server/src/cli/thread.test.ts

@@ -1,8 +1,19 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { assert, it } from "@effect/vitest";
-import { RunId, ThreadId } from "@t3tools/contracts";
+import { ProjectId, RunId, ThreadId } from "@t3tools/contracts";
+import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as Effect from "effect/Effect";
-
-import { readLatestMessages, type ThreadTools, titleFromMessage, waitForRun } from "./thread.ts";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+
+import {
+  readLatestMessages,
+  resolveProject,
+  type ThreadTools,
+  titleFromMessage,
+  waitForRun,
+} from "./thread.ts";
 
 const threadId = ThreadId.make("thread-1");
 const runId = RunId.make("run-1");
@@ -165,3 +176,69 @@ it("titles from a long first line without splitting an emoji", () => {
   const title = titleFromMessage(`${"a".repeat(78)}😀 and the rest of a long first line`);
   assert.strictEqual(title, `${"a".repeat(78)}…`);
 });
+
+const git = Effect.fn("test.git")(function* (cwd: string, args: ReadonlyArray<string>) {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const exitCode = yield* spawner.exitCode(ChildProcess.make("git", args, { cwd }));
+  assert.strictEqual(Number(exitCode), 0, `git ${args.join(" ")}`);
+});
+
+const commitAll = (cwd: string) =>
+  Effect.andThen(
+    git(cwd, ["add", "."]),
+    git(cwd, [
+      "-c",
+      "user.name=Test",
+      "-c",
+      "user.email=test@example.test",
+      "commit",
+      "--quiet",
+      "-m",
+      "initial",
+    ]),
+  );
+
+it.live("resolves a path inside a git worktree of the project's repository to that project", () =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const root = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-thread-worktree-" });
+    const repo = path.join(root, "sample");
+    const worktree = path.join(root, "worktrees", "sample", "t3-8ff64c24");
+    const feature = path.join(root, "wt", "feature");
+    const featureWorktree = path.join(root, "worktrees", "feature", "t3-1a2b3c4d");
+    yield* fileSystem.makeDirectory(path.join(repo, "pkg"), { recursive: true });
+    yield* fileSystem.writeFileString(path.join(repo, "pkg", "index.ts"), "export {};\n");
+    yield* git(repo, ["init", "--quiet", "-b", "main"]);
+    yield* commitAll(repo);
+    yield* git(repo, ["worktree", "add", "--quiet", "-b", "t3/8ff64c24", worktree]);
+    yield* git(repo, ["worktree", "add", "--quiet", "-b", "feature", feature]);
+    yield* git(feature, ["worktree", "add", "--quiet", "-b", "t3/1a2b3c4d", featureWorktree]);
+
+    const project = (id: string, workspaceRoot: string) => ({
+      id: ProjectId.make(id),
+      title: path.basename(workspaceRoot),
+      workspaceRoot,
+    });
+    const sample = project("project-sample", repo);
+    const featureProject = project("project-feature", feature);
+    const resolveFrom = (
+      projects: ReadonlyArray<ReturnType<typeof project>>,
+      workingDirectory: string,
+      identifier = ".",
+    ) =>
+      resolveProject(
+        scriptedTools({ t3_project_list: [{ projects, nextCursor: null }] }).tools,
+        identifier,
+      ).pipe(Effect.provideService(HostProcess.WorkingDirectory, workingDirectory));
+
+    assert.deepStrictEqual(yield* resolveFrom([sample], worktree), sample);
+    assert.deepStrictEqual(yield* resolveFrom([sample], path.join(worktree, "pkg")), sample);
+    assert.deepStrictEqual(yield* resolveFrom([sample], worktree, "pkg/index.ts"), sample);
+    assert.deepStrictEqual(yield* resolveFrom([featureProject], featureWorktree), featureProject);
+    const ambiguous = yield* Effect.flip(resolveFrom([sample, featureProject], featureWorktree));
+    assert.strictEqual(ambiguous._tag, "ThreadUsageError");
+    assert.include(ambiguous.message, "sample (project-sample)");
+    assert.include(ambiguous.message, "feature (project-feature)");
+  }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);

apps/server/src/cli/thread.ts

@@ -29,6 +29,7 @@ import { Argument, Command, Flag, GlobalFlag } from "effect/cli";
 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
 import * as ServerConfig from "../config.ts";
 import { mcpToolSession, type McpToolSession } from "../mcp/AcpMcpStdioBridge.ts";
+import * as ProcessRunner from "../processRunner.ts";
 import { readPersistedServerRuntimeState } from "../serverRuntimeState.ts";
 import { projectLocationFlags, resolveCliAuthConfig } from "./config.ts";
 
@@ -272,8 +273,34 @@ const listAllProjects = Effect.fn("cli.thread.listAllProjects")(function* (tools
   return projects;
 });
 
-/** A project id, or a path inside a project's folder (deepest project wins). */
-const resolveProject = Effect.fn("cli.thread.resolveProject")(function* (
+/** The checkouts of the git repository at `directory`, or none outside a repository. */
+const listGitCheckouts = Effect.fn("cli.thread.listGitCheckouts")(function* (directory: string) {
+  const processRunner = yield* ProcessRunner.ProcessRunner;
+  const list = (args: ReadonlyArray<string>) =>
+    processRunner
+      .run({ command: "git", args: ["worktree", "list", "--porcelain", ...args], cwd: directory })
+      .pipe(
+        Effect.option,
+        Effect.map((result) =>
+          Option.isSome(result) && result.value.code === 0 ? result.value.stdout : undefined,
+        ),
+      );
+  // Pre-2.36 Git rejects worktree list -z; normalize its line output to NUL records.
+  const stdout = (yield* list(["-z"])) ?? (yield* list([]))?.replaceAll("\n", "\0") ?? "";
+  return stdout.split("\0\0").flatMap((record) => {
+    const [first = "", ...attributes] = record.split("\0");
+    return first.startsWith("worktree ") && !attributes.includes("bare")
+      ? [first.slice("worktree ".length)]
+      : [];
+  });
+});
+
+/**
+ * A project id, or a path inside a project's folder (deepest project wins).
+ * A path inside a git worktree resolves as the same path in the repository's
+ * other checkouts.
+ */
+export const resolveProject = Effect.fn("cli.thread.resolveProject")(function* (
   tools: ThreadTools,
   identifier: string,
 ) {
@@ -291,19 +318,51 @@ const resolveProject = Effect.fn("cli.thread.resolveProject")(function* (
   const roots = yield* Effect.forEach(projects, (project) =>
     Effect.map(realPath(project.workspaceRoot), (root) => ({ project, root })),
   );
-  const containing = roots
-    .filter(({ root }) => {
-      const relative = path.relative(root, target);
-      return (
-        relative === "" ||
-        (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
-      );
-    })
-    .toSorted((left, right) => right.root.length - left.root.length)[0];
-  if (containing === undefined) {
+  const contains = (root: string, candidate: string) => {
+    const relative = path.relative(root, candidate);
+    return (
+      relative === "" ||
+      (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
+    );
+  };
+  const deepestContaining = (candidate: string) =>
+    roots
+      .filter(({ root }) => contains(root, candidate))
+      .toSorted((left, right) => right.root.length - left.root.length)[0]?.project;
+
+  const containing = deepestContaining(target);
+  if (containing !== undefined) return containing;
+  const targetInfo = yield* fileSystem.stat(target).pipe(Effect.option);
+  const gitDirectory =
+    Option.isSome(targetInfo) && targetInfo.value.type === "File" ? path.dirname(target) : target;
+  const listed = yield* listGitCheckouts(gitDirectory).pipe(
+    Effect.flatMap((paths) => Effect.forEach(paths, realPath)),
+    Effect.provide(ProcessRunner.layer),
+  );
+  const ownCheckout = listed
+    .filter((checkout) => contains(checkout, target))
+    .toSorted((left, right) => right.length - left.length)[0];
+  if (ownCheckout === undefined) {
+    return yield* new ThreadProjectNotFoundError({ identifier });
+  }
+  const relative = path.relative(ownCheckout, target);
+  const matches = new Map<ProjectId, (typeof projects)[number]>();
+  for (const checkout of listed) {
+    if (checkout === ownCheckout) continue;
+    const project = deepestContaining(path.join(checkout, relative));
+    if (project !== undefined) matches.set(project.id, project);
+  }
+  const [match, ...others] = matches.values();
+  if (match === undefined) {
     return yield* new ThreadProjectNotFoundError({ identifier });
   }
-  return containing.project;
+  if (others.length > 0) {
+    const names = [match, ...others].map((project) => `${project.title} (${project.id})`);
+    return yield* new ThreadUsageError({
+      detail: `'${identifier}' is in a git worktree shared by several projects: ${names.join(", ")}. Pass a project id instead.`,
+    });
+  }
+  return match;
 });
 
 /** Every item on a timeline view, oldest first. */

docs/user/outside-agents.md

@@ -104,11 +104,11 @@ t3 thread show "$id"
 t3 thread list
 ```
 
-`.` means the project that contains the current folder; a project id also
-works. A new thread uses the project's default model and permission mode, and
-runs in the project folder unless you pass `--worktree <base-branch>`. `send`
-never interrupts: a busy thread gets the message as its next turn. Pass `-` as
-the message to read it from stdin.
+`.` means the project that contains the current folder, or a git worktree of
+its repository; a project id also works. A new thread uses the project's
+default model and permission mode, and runs in the project folder unless you
+pass `--worktree <base-branch>`. `send` never interrupts: a busy thread gets
+the message as its next turn. Pass `-` as the message to read it from stdin.
 
 `--wait` prints the agent's reply. It exits 1 when the run fails or stops, and
 2 when the agent waits for an answer you give in the app. Add `--json` for a