t3code-cli 0.6.0 → 0.7.0

package/dist/bin.js

@@ -8,7 +8,7 @@ import { C as make$12, S as Crypto, x as T3Auth } from "./layer-CfC5qZol.js";
 import { n as T3Config, t as Environment } from "./service-CLmRO2Dp.js";
 import { t as T3Application } from "./service-ybOWV9pL.js";
 import { i as resolveWorktreePath, r as resolveThreadId, t as resolveCommandProjectRef } from "./scope-GycYiJ54.js";
-import { d as latestAssistantMessage, f as threadStatus, m as ThreadSessionError, p as ProjectLookupError, t as AppLayer } from "./layer-DIg0RxSO.js";
+import { d as latestAssistantMessage, f as threadStatus, m as ThreadSessionError, p as ProjectLookupError, t as AppLayer } from "./layer-MqCKkIGD.js";
 import { t as NodeEnvironmentLive } from "./layer-DHhKS5jd.js";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeCrypto from "node:crypto";
@@ -4859,7 +4859,7 @@ var T3Version = class extends Service()("t3cli/T3Version") {};
 //#endregion
 //#region src/version/layer.ts
 const PackageJsonSchema = fromJsonString(Struct({ version: String$1 }));
-const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.6.0" }));
+const T3VersionBundledLive = sync$2(T3Version, () => ({ version: "0.7.0" }));
 effect(T3Version, gen(function* () {
 	const packageJson = yield* (yield* FileSystem).readFileString(fileURLToPath(new URL("../../package.json", import.meta.url)));
 	return { version: (yield* decodeUnknownEffect(PackageJsonSchema)(packageJson)).version };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as T3Application } from "./service-ybOWV9pL.js";
-import { n as AuthAppLayer, t as AppLayer } from "./layer-DIg0RxSO.js";
+import { n as AuthAppLayer, t as AppLayer } from "./layer-MqCKkIGD.js";
 import "./application.js";
 import "./runtime.js";
 export { AppLayer, AuthAppLayer, T3Application };

package/dist/{layer-DIg0RxSO.js → layer-MqCKkIGD.js}

@@ -120,73 +120,68 @@ const makeModelsApplication = fn("makeModelsApplication")(function* () {
 //#endregion
 //#region src/domain/helpers.ts
 const resolveProjectScope = fn("resolveProjectScope")(function* (snapshot, input) {
-	const absoluteRef = yield* resolveAbsolutePath(input.ref, input.cwd);
+	const path = yield* Path;
 	const byId = findProjectById(snapshot, input.ref);
 	if (byId !== null) return { project: byId };
-	const byExactPath = yield* findProjectByWorkspaceRoot(snapshot, absoluteRef, input.cwd);
-	if (byExactPath !== void 0) return { project: byExactPath };
-	const byAncestor = yield* findProjectByAncestorPath(snapshot, absoluteRef, input.cwd);
-	if (byAncestor !== void 0) return byAncestor;
-	return yield* findProjectByKnownWorktreePath(snapshot, absoluteRef, input.cwd);
+	if (!path.isAbsolute(input.ref)) return;
+	return yield* findProjectByPathPriority(snapshot, path.normalize(input.ref));
 });
 function findProjectById(snapshot, projectId) {
 	return snapshot.projects.find((project) => project.id === projectId) ?? null;
 }
-const resolveAbsolutePath = fn("resolveAbsolutePath")(function* (ref, cwd) {
-	const path = yield* Path;
-	return path.isAbsolute(ref) ? path.normalize(ref) : path.normalize(path.resolve(cwd, ref));
-});
 const isDescendantPath = fn("isDescendantPath")(function* (parent, child) {
 	const path = yield* Path;
 	if (child === parent) return true;
 	const relative = path.relative(parent, child);
 	return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
 });
-const findProjectByWorkspaceRoot = fn("findProjectByWorkspaceRoot")(function* (snapshot, absolutePath, cwd) {
-	for (const project of snapshot.projects) if ((yield* resolveAbsolutePath(project.workspaceRoot, cwd)) === absolutePath) return project;
-});
-const findProjectByAncestorPath = fn("findProjectByAncestorPath")(function* (snapshot, absolutePath, cwd) {
-	let bestProject;
-	let bestWorkspaceRoot = "";
-	for (const project of snapshot.projects) {
-		const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
-		if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) continue;
-		if (workspaceRoot.length > bestWorkspaceRoot.length) {
-			bestProject = project;
-			bestWorkspaceRoot = workspaceRoot;
-		}
-	}
-	if (bestProject === void 0) return;
-	if (absolutePath === bestWorkspaceRoot) return { project: bestProject };
-	return {
-		project: bestProject,
-		inferredWorktreePath: absolutePath
-	};
-});
-const findProjectByKnownWorktreePath = fn("findProjectByKnownWorktreePath")(function* (snapshot, absolutePath, cwd) {
+const findProjectByPathPriority = fn("findProjectByPathPriority")(function* (snapshot, absolutePath) {
+	const path = yield* Path;
 	const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
-	let bestProject;
-	let bestKnownPath = "";
+	const workspaceRoots = new Map(snapshot.projects.map((project) => [project.id, path.normalize(project.workspaceRoot)]));
+	const candidates = [];
 	for (const thread of snapshot.threads) {
 		if (thread.worktreePath === null) continue;
 		const project = projectsById.get(thread.projectId);
 		if (project === void 0) continue;
-		const knownPath = yield* resolveAbsolutePath(thread.worktreePath, cwd);
-		if (!(yield* isDescendantPath(knownPath, absolutePath))) continue;
-		if (knownPath.length > bestKnownPath.length) {
-			bestProject = project;
-			bestKnownPath = knownPath;
-		}
+		const workspaceRoot = workspaceRoots.get(thread.projectId);
+		if (workspaceRoot === void 0) continue;
+		const matchPath = path.normalize(thread.worktreePath);
+		if (!(yield* isDescendantPath(matchPath, absolutePath))) continue;
+		candidates.push({
+			project,
+			matchPath,
+			workspaceRoot,
+			source: "worktree"
+		});
+	}
+	for (const project of snapshot.projects) {
+		const workspaceRoot = workspaceRoots.get(project.id);
+		if (workspaceRoot === void 0) continue;
+		if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) continue;
+		candidates.push({
+			project,
+			matchPath: workspaceRoot,
+			workspaceRoot,
+			source: "project"
+		});
+	}
+	if (candidates.length === 0) return;
+	candidates.sort((left, right) => {
+		if (left.matchPath.length !== right.matchPath.length) return right.matchPath.length - left.matchPath.length;
+		if (left.source === right.source) return 0;
+		return left.source === "worktree" ? -1 : 1;
+	});
+	const best = candidates[0];
+	if (absolutePath === best.matchPath) {
+		if (best.source === "worktree" && best.matchPath !== best.workspaceRoot) return {
+			project: best.project,
+			inferredWorktreePath: best.matchPath
+		};
+		return { project: best.project };
 	}
-	if (bestProject === void 0) return;
-	const workspaceRoot = yield* resolveAbsolutePath(bestProject.workspaceRoot, cwd);
-	if (absolutePath === workspaceRoot) return { project: bestProject };
-	if (absolutePath === bestKnownPath) return bestKnownPath === workspaceRoot ? { project: bestProject } : {
-		project: bestProject,
-		inferredWorktreePath: bestKnownPath
-	};
 	return {
-		project: bestProject,
+		project: best.project,
 		inferredWorktreePath: absolutePath
 	};
 });
@@ -444,10 +439,7 @@ const makeThreadApplication = fn("makeThreadApplication")(function* () {
 	const environment = yield* Environment;
 	const listThreads = fn("T3ApplicationLive.listThreads")(function* (projectRef) {
 		const snapshot = yield* orchestration.getShellSnapshot();
-		const scope = yield* resolveProjectScope(snapshot, {
-			ref: projectRef,
-			cwd: environment.cwd
-		}).pipe(provideService(Path, path));
+		const scope = yield* resolveProjectScope(snapshot, { ref: projectRef }).pipe(provideService(Path, path));
 		if (scope === void 0) return yield* fail(new ProjectLookupError({
 			message: `project not found: ${projectRef}`,
 			ref: projectRef
@@ -471,10 +463,7 @@ const makeThreadApplication = fn("makeThreadApplication")(function* () {
 			message: "project is required",
 			ref: environment.cwd
 		}));
-		const scope = yield* resolveProjectScope(snapshot, {
-			ref: projectRef,
-			cwd: environment.cwd
-		}).pipe(provideService(Path, path));
+		const scope = yield* resolveProjectScope(snapshot, { ref: projectRef }).pipe(provideService(Path, path));
 		if (scope === void 0) return yield* fail(new ProjectLookupError({
 			message: `project not found: ${projectRef}`,
 			ref: projectRef

package/dist/orchestration.js

@@ -1,2 +1,2 @@
-import { l as T3OrchestrationLayer, u as T3Orchestration } from "./layer-DIg0RxSO.js";
+import { l as T3OrchestrationLayer, u as T3Orchestration } from "./layer-MqCKkIGD.js";
 export { T3Orchestration, T3OrchestrationLayer };

package/dist/runtime.js

@@ -1,3 +1,3 @@
-import { a as T3AuthTransportLayer, c as T3LocalAuthTokenLayer, i as T3AuthPairingLayer, l as T3OrchestrationLayer, n as AuthAppLayer, o as T3LocalAuthLayer, r as T3AuthLayer, s as T3LocalAuthOriginLayer, t as AppLayer } from "./layer-DIg0RxSO.js";
+import { a as T3AuthTransportLayer, c as T3LocalAuthTokenLayer, i as T3AuthPairingLayer, l as T3OrchestrationLayer, n as AuthAppLayer, o as T3LocalAuthLayer, r as T3AuthLayer, s as T3LocalAuthOriginLayer, t as AppLayer } from "./layer-MqCKkIGD.js";
 import { t as NodeEnvironmentLive } from "./layer-DHhKS5jd.js";
 export { AppLayer, AuthAppLayer, NodeEnvironmentLive, T3AuthLayer, T3AuthPairingLayer, T3AuthTransportLayer, T3LocalAuthLayer, T3LocalAuthOriginLayer, T3LocalAuthTokenLayer, T3OrchestrationLayer };

package/dist/src/domain/helpers.d.ts

@@ -91,7 +91,6 @@ export declare const resolveProjectScope: (snapshot: {
     readonly updatedAt: string;
 }, input: {
     readonly ref: string;
-    readonly cwd: string;
 }) => Effect.Effect<{
     project: {
         readonly id: string & import("effect/Brand").Brand<"ProjectId">;
@@ -128,7 +127,7 @@ export declare const resolveProjectScope: (snapshot: {
             readonly name?: string;
         } | null | undefined;
     };
-    inferredWorktreePath?: never;
+    inferredWorktreePath: string;
 } | {
     project: {
         readonly id: string & import("effect/Brand").Brand<"ProjectId">;
@@ -165,6 +164,6 @@ export declare const resolveProjectScope: (snapshot: {
             readonly name?: string;
         } | null | undefined;
     };
-    inferredWorktreePath: string;
+    inferredWorktreePath?: never;
 } | undefined, never, Path.Path>;
 export declare function findProjectById(snapshot: OrchestrationShellSnapshot, projectId: string): OrchestrationProjectShell | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",
@@ -93,13 +93,15 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
+    "@effect/vitest": "4.0.0-beta.78",
+    "@total-typescript/shoehorn": "^0.1.2",
     "@types/node": "^25.9.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.1.24",
     "@t3tools/contracts": "0.0.24"
   },
   "engines": {
-    "node": "^24.0.0"
+    "node": ">=24.0.0"
   },
   "scripts": {
     "build": "vp pack && tsc -p tsconfig.dts.json",
@@ -108,6 +110,7 @@
     "format:check": "vp fmt --check",
     "lint": "vp lint",
     "lint:fix": "vp lint --fix",
+    "test": "vp test run",
     "changeset": "changeset",
     "release:version": "changeset version && pnpm format",
     "release:check": "pnpm check && pnpm typecheck && pnpm pack --dry-run",

package/src/application/threads.ts

@@ -29,7 +29,6 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     const snapshot = yield* orchestration.getShellSnapshot();
     const scope = yield* resolveProjectScope(snapshot, {
       ref: projectRef,
-      cwd: environment.cwd,
     }).pipe(Effect.provideService(Path.Path, path));
     if (scope === undefined) {
       return yield* Effect.fail(
@@ -70,7 +69,6 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     }
     const scope = yield* resolveProjectScope(snapshot, {
       ref: projectRef,
-      cwd: environment.cwd,
     }).pipe(Effect.provideService(Path.Path, path));
     if (scope === undefined) {
       return yield* Effect.fail(

package/src/domain/helpers.test.ts

@@ -0,0 +1,103 @@
+import "vite-plus/test/config";
+
+import * as Effect from "effect/Effect";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import { fromPartial } from "@total-typescript/shoehorn";
+
+import type { OrchestrationShellSnapshot } from "#t3tools/contracts";
+
+import { resolveProjectScope } from "./helpers.ts";
+
+describe("resolveProjectScope", () => {
+  it.layer(NodeServices.layer)("resolveProjectScope", (t) => {
+    t.effect("resolves by id first (even if ref not absolute)", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [{ id: "proj-1", workspaceRoot: "/workspace" }],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "proj-1" });
+        assert.equal(scope?.project.id, "proj-1");
+        assert.equal(scope?.inferredWorktreePath, undefined);
+      }),
+    );
+
+    t.effect("returns undefined for non-absolute path refs", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [{ id: "proj-1", workspaceRoot: "/workspace" }],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "workspace/subdir" });
+        assert.equal(scope, undefined);
+      }),
+    );
+
+    t.effect("prefers longest matching workspaceRoot", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [
+            { id: "proj-a", workspaceRoot: "/workspace" },
+            { id: "proj-b", workspaceRoot: "/workspace/sub" },
+          ],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/sub/deep" });
+        assert.equal(scope?.project.id, "proj-b");
+        assert.equal(scope?.inferredWorktreePath, "/workspace/sub/deep");
+      }),
+    );
+
+    t.effect("does not infer worktree when ref equals workspaceRoot", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [
+            { id: "proj-a", workspaceRoot: "/workspace" },
+            { id: "proj-b", workspaceRoot: "/workspace/sub" },
+          ],
+          threads: [],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/sub" });
+        assert.equal(scope?.project.id, "proj-b");
+        assert.equal(scope?.inferredWorktreePath, undefined);
+      }),
+    );
+
+    t.effect("prefers worktree candidate over project candidate for same match path", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [
+            { id: "proj-a", workspaceRoot: "/workspace" },
+            { id: "proj-b", workspaceRoot: "/workspace/proj" },
+          ],
+          threads: [{ projectId: "proj-a", worktreePath: "/workspace/proj" }],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/proj" });
+        assert.equal(scope?.project.id, "proj-a");
+        assert.equal(scope?.inferredWorktreePath, "/workspace/proj");
+      }),
+    );
+
+    t.effect("prefers longest matching worktree path", () =>
+      Effect.gen(function* () {
+        const snapshot: OrchestrationShellSnapshot = fromPartial({
+          projects: [{ id: "proj-a", workspaceRoot: "/workspace" }],
+          threads: [
+            { projectId: "proj-a", worktreePath: "/workspace/proj" },
+            { projectId: "proj-a", worktreePath: "/workspace/proj/deep" },
+          ],
+        });
+
+        const scope = yield* resolveProjectScope(snapshot, { ref: "/workspace/proj/deep/child" });
+        assert.equal(scope?.project.id, "proj-a");
+        assert.equal(scope?.inferredWorktreePath, "/workspace/proj/deep/child");
+      }),
+    );
+  });
+});

package/src/domain/helpers.ts

@@ -11,27 +11,20 @@ export const resolveProjectScope = Effect.fn("resolveProjectScope")(function* (
   snapshot: OrchestrationShellSnapshot,
   input: {
     readonly ref: string;
-    readonly cwd: string;
   },
 ) {
-  const absoluteRef = yield* resolveAbsolutePath(input.ref, input.cwd);
+  const path = yield* Path.Path;
 
   const byId = findProjectById(snapshot, input.ref);
   if (byId !== null) {
     return { project: byId };
   }
 
-  const byExactPath = yield* findProjectByWorkspaceRoot(snapshot, absoluteRef, input.cwd);
-  if (byExactPath !== undefined) {
-    return { project: byExactPath };
-  }
-
-  const byAncestor = yield* findProjectByAncestorPath(snapshot, absoluteRef, input.cwd);
-  if (byAncestor !== undefined) {
-    return byAncestor;
+  if (!path.isAbsolute(input.ref)) {
+    return undefined;
   }
 
-  return yield* findProjectByKnownWorktreePath(snapshot, absoluteRef, input.cwd);
+  return yield* findProjectByPathPriority(snapshot, path.normalize(input.ref));
 });
 
 export function findProjectById(
@@ -41,11 +34,6 @@ export function findProjectById(
   return snapshot.projects.find((project) => project.id === projectId) ?? null;
 }
 
-const resolveAbsolutePath = Effect.fn("resolveAbsolutePath")(function* (ref: string, cwd: string) {
-  const path = yield* Path.Path;
-  return path.isAbsolute(ref) ? path.normalize(ref) : path.normalize(path.resolve(cwd, ref));
-});
-
 const isDescendantPath = Effect.fn("isDescendantPath")(function* (parent: string, child: string) {
   const path = yield* Path.Path;
   if (child === parent) {
@@ -55,61 +43,23 @@ const isDescendantPath = Effect.fn("isDescendantPath")(function* (parent: string
   return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
 });
 
-const findProjectByWorkspaceRoot = Effect.fn("findProjectByWorkspaceRoot")(function* (
-  snapshot: OrchestrationShellSnapshot,
-  absolutePath: string,
-  cwd: string,
-) {
-  for (const project of snapshot.projects) {
-    const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
-    if (workspaceRoot === absolutePath) {
-      return project;
-    }
-  }
-  return undefined;
-});
-
-const findProjectByAncestorPath = Effect.fn("findProjectByAncestorPath")(function* (
+const findProjectByPathPriority = Effect.fn("findProjectByPathPriority")(function* (
   snapshot: OrchestrationShellSnapshot,
   absolutePath: string,
-  cwd: string,
-) {
-  let bestProject: OrchestrationProjectShell | undefined;
-  let bestWorkspaceRoot = "";
-
-  for (const project of snapshot.projects) {
-    const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
-    if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) {
-      continue;
-    }
-    if (workspaceRoot.length > bestWorkspaceRoot.length) {
-      bestProject = project;
-      bestWorkspaceRoot = workspaceRoot;
-    }
-  }
-
-  if (bestProject === undefined) {
-    return undefined;
-  }
-
-  if (absolutePath === bestWorkspaceRoot) {
-    return { project: bestProject };
-  }
-
-  return {
-    project: bestProject,
-    inferredWorktreePath: absolutePath,
-  };
-});
-
-const findProjectByKnownWorktreePath = Effect.fn("findProjectByKnownWorktreePath")(function* (
-  snapshot: OrchestrationShellSnapshot,
-  absolutePath: string,
-  cwd: string,
 ) {
+  const path = yield* Path.Path;
   const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
-  let bestProject: OrchestrationProjectShell | undefined;
-  let bestKnownPath = "";
+  const workspaceRoots = new Map(
+    snapshot.projects.map(
+      (project) => [project.id, path.normalize(project.workspaceRoot)] as const,
+    ),
+  );
+  const candidates: Array<{
+    readonly project: OrchestrationProjectShell;
+    readonly matchPath: string;
+    readonly workspaceRoot: string;
+    readonly source: "worktree" | "project";
+  }> = [];
 
   for (const thread of snapshot.threads) {
     if (thread.worktreePath === null) {
@@ -119,33 +69,59 @@ const findProjectByKnownWorktreePath = Effect.fn("findProjectByKnownWorktreePath
     if (project === undefined) {
       continue;
     }
-    const knownPath = yield* resolveAbsolutePath(thread.worktreePath, cwd);
-    if (!(yield* isDescendantPath(knownPath, absolutePath))) {
+    const workspaceRoot = workspaceRoots.get(thread.projectId);
+    if (workspaceRoot === undefined) {
       continue;
     }
-    if (knownPath.length > bestKnownPath.length) {
-      bestProject = project;
-      bestKnownPath = knownPath;
+    const matchPath = path.normalize(thread.worktreePath);
+    if (!(yield* isDescendantPath(matchPath, absolutePath))) {
+      continue;
     }
+    candidates.push({
+      project,
+      matchPath,
+      workspaceRoot,
+      source: "worktree",
+    });
   }
 
-  if (bestProject === undefined) {
-    return undefined;
+  for (const project of snapshot.projects) {
+    const workspaceRoot = workspaceRoots.get(project.id);
+    if (workspaceRoot === undefined) {
+      continue;
+    }
+    if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) {
+      continue;
+    }
+    candidates.push({
+      project,
+      matchPath: workspaceRoot,
+      workspaceRoot,
+      source: "project",
+    });
   }
 
-  const workspaceRoot = yield* resolveAbsolutePath(bestProject.workspaceRoot, cwd);
-  if (absolutePath === workspaceRoot) {
-    return { project: bestProject };
+  if (candidates.length === 0) {
+    return undefined;
   }
 
-  if (absolutePath === bestKnownPath) {
-    return bestKnownPath === workspaceRoot
-      ? { project: bestProject }
-      : { project: bestProject, inferredWorktreePath: bestKnownPath };
+  candidates.sort((left, right) => {
+    if (left.matchPath.length !== right.matchPath.length) {
+      return right.matchPath.length - left.matchPath.length;
+    }
+    if (left.source === right.source) {
+      return 0;
+    }
+    return left.source === "worktree" ? -1 : 1;
+  });
+
+  const best = candidates[0]!;
+  if (absolutePath === best.matchPath) {
+    if (best.source === "worktree" && best.matchPath !== best.workspaceRoot) {
+      return { project: best.project, inferredWorktreePath: best.matchPath };
+    }
+    return { project: best.project };
   }
 
-  return {
-    project: bestProject,
-    inferredWorktreePath: absolutePath,
-  };
+  return { project: best.project, inferredWorktreePath: absolutePath };
 });