gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.eeb3520

package/src/resources/extensions/gsd/doctor.ts

@@ -1,15 +1,14 @@
-import { existsSync, mkdirSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
 import { loadFile, parsePlan, parseRoadmap, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
+import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences, type GSDPreferences } from "./preferences.js";
 
-import type { DoctorIssue, DoctorIssueCode, DoctorReport } from "./doctor-types.js";
+import type { DoctorIssue, DoctorIssueCode } from "./doctor-types.js";
 import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
-import type { RoadmapSliceEntry } from "./types.js";
 import { checkGitHealth, checkRuntimeHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
@@ -18,7 +17,7 @@ import { runProviderChecks } from "./doctor-providers.js";
 // All public types and functions from extracted modules are re-exported here
 // so that existing imports from "./doctor.js" continue to work unchanged.
 export type { DoctorSeverity, DoctorIssueCode, DoctorIssue, DoctorReport, DoctorSummary } from "./doctor-types.js";
-export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt, formatDoctorReportJson } from "./doctor-format.js";
+export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt } from "./doctor-format.js";
 export { runEnvironmentChecks, runFullEnvironmentChecks, formatEnvironmentReport, type EnvironmentCheckResult } from "./doctor-environment.js";
 export { computeProgressScore, computeProgressScoreWithContext, formatProgressLine, formatProgressReport, type ProgressScore, type ProgressLevel } from "./progress-score.js";
 
@@ -351,60 +350,10 @@ export async function selectDoctorScope(basePath: string, requestedScope?: strin
   return state.registry[0]?.id;
 }
 
-// ── Helper: circular dependency detection ──────────────────────────────────
-function detectCircularDependencies(slices: RoadmapSliceEntry[]): string[][] {
-  const known = new Set(slices.map(s => s.id));
-  const adj = new Map<string, string[]>();
-  for (const s of slices) adj.set(s.id, s.depends.filter(d => known.has(d)));
-  const state = new Map<string, "unvisited" | "visiting" | "done">();
-  for (const s of slices) state.set(s.id, "unvisited");
-  const cycles: string[][] = [];
-  function dfs(id: string, path: string[]): void {
-    const st = state.get(id);
-    if (st === "done") return;
-    if (st === "visiting") { cycles.push([...path.slice(path.indexOf(id)), id]); return; }
-    state.set(id, "visiting");
-    for (const dep of adj.get(id) ?? []) dfs(dep, [...path, id]);
-    state.set(id, "done");
-  }
-  for (const s of slices) if (state.get(s.id) === "unvisited") dfs(s.id, []);
-  return cycles;
-}
-
-// ── Helper: doctor run history ──────────────────────────────────────────────
-interface DoctorHistoryEntry { ts: string; ok: boolean; errors: number; warnings: number; fixes: number; codes: string[] }
-
-async function appendDoctorHistory(basePath: string, report: DoctorReport): Promise<void> {
-  try {
-    const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
-    const entry = JSON.stringify({
-      ts: new Date().toISOString(),
-      ok: report.ok,
-      errors: report.issues.filter(i => i.severity === "error").length,
-      warnings: report.issues.filter(i => i.severity === "warning").length,
-      fixes: report.fixesApplied.length,
-      codes: [...new Set(report.issues.map(i => i.code))],
-    } satisfies DoctorHistoryEntry);
-    const existing = existsSync(historyPath) ? readFileSync(historyPath, "utf-8") : "";
-    await saveFile(historyPath, existing + entry + "\n");
-  } catch { /* non-fatal */ }
-}
-
-/** Read the last N doctor history entries. Returns most-recent-first. */
-export async function readDoctorHistory(basePath: string, lastN = 50): Promise<DoctorHistoryEntry[]> {
-  try {
-    const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
-    if (!existsSync(historyPath)) return [];
-    const lines = readFileSync(historyPath, "utf-8").split("\n").filter(l => l.trim());
-    return lines.slice(-lastN).reverse().map(l => JSON.parse(l) as DoctorHistoryEntry);
-  } catch { return []; }
-}
-
-export async function runGSDDoctor(basePath: string, options?: { fix?: boolean; dryRun?: boolean; scope?: string; fixLevel?: "task" | "all"; isolationMode?: "none" | "worktree" | "branch"; includeBuild?: boolean; includeTests?: boolean }): Promise<DoctorReport> {
+export async function runGSDDoctor(basePath: string, options?: { fix?: boolean; scope?: string; fixLevel?: "task" | "all"; isolationMode?: "none" | "worktree" | "branch" }): Promise<import("./doctor-types.js").DoctorReport> {
   const issues: DoctorIssue[] = [];
   const fixesApplied: string[] = [];
   const fix = options?.fix === true;
-  const dryRun = options?.dryRun === true;
   const fixLevel = options?.fixLevel ?? "all";
 
   // Issue codes that represent completion state transitions — creating summary
@@ -415,18 +364,11 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
 
   /** Whether a given issue code should be auto-fixed at the current fixLevel. */
   const shouldFix = (code: DoctorIssueCode): boolean => {
-    if (!fix || dryRun) return false;
+    if (!fix) return false;
     if (fixLevel === "task" && COMPLETION_TRANSITION_CODES.has(code)) return false;
     return true;
   };
 
-  /** Log a dry-run "would fix" entry when fix=true but dryRun=true. */
-  const dryRunCanFix = (code: DoctorIssueCode, message: string): void => {
-    if (dryRun && fix && !(fixLevel === "task" && COMPLETION_TRANSITION_CODES.has(code))) {
-      fixesApplied.push(`[dry-run] would fix: ${message}`);
-    }
-  };
-
   const prefs = loadEffectiveGSDPreferences();
   if (prefs) {
     const prefIssues = validatePreferenceShape(prefs.preferences);
@@ -443,33 +385,21 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
     }
   }
 
-  // Git health checks — timed
-  const t0git = Date.now();
+  // Git health checks (orphaned worktrees, stale branches, corrupt merge state, tracked runtime files)
   const isolationMode: "none" | "worktree" | "branch" = options?.isolationMode ??
     (prefs?.preferences?.git?.isolation === "none" ? "none" :
     prefs?.preferences?.git?.isolation === "branch" ? "branch" : "worktree");
   await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode);
-  const gitMs = Date.now() - t0git;
 
-  // Runtime health checks — timed
-  const t0runtime = Date.now();
+  // Runtime health checks (crash locks, completed-units, hook state, activity logs, STATE.md, gitignore)
   await checkRuntimeHealth(basePath, issues, fixesApplied, shouldFix);
-  const runtimeMs = Date.now() - t0runtime;
 
-  // Environment health checks — timed
-  const t0env = Date.now();
-  await checkEnvironmentHealth(basePath, issues, {
-    includeRemote: !options?.scope,
-    includeBuild: options?.includeBuild,
-    includeTests: options?.includeTests,
-  });
-  const envMs = Date.now() - t0env;
+  // Environment health checks (#1221: missing tools, port conflicts, stale deps, disk space)
+  await checkEnvironmentHealth(basePath, issues, { includeRemote: !options?.scope });
 
   const milestonesPath = milestonesDir(basePath);
   if (!existsSync(milestonesPath)) {
-    const report: DoctorReport = { ok: issues.every(i => i.severity !== "error"), basePath, issues, fixesApplied, timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: 0 } };
-    await appendDoctorHistory(basePath, report);
-    return report;
+    return { ok: issues.every(issue => issue.severity !== "error"), basePath, issues, fixesApplied };
   }
 
   const requirementsPath = resolveGsdRootFile(basePath, "REQUIREMENTS");
@@ -535,43 +465,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
     if (!roadmapContent) continue;
     const roadmap = parseRoadmap(roadmapContent);
 
-    // ── Circular dependency detection ──────────────────────────────────────
-    for (const cycle of detectCircularDependencies(roadmap.slices)) {
-      issues.push({
-        severity: "error",
-        code: "circular_slice_dependency",
-        scope: "milestone",
-        unitId: milestoneId,
-        message: `Circular dependency detected: ${cycle.join(" → ")}`,
-        file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
-        fixable: false,
-      });
-    }
-
-    // ── Orphaned slice directories ─────────────────────────────────────────
-    try {
-      const slicesDir = join(milestonePath, "slices");
-      if (existsSync(slicesDir)) {
-        const knownSliceIds = new Set(roadmap.slices.map(s => s.id));
-        for (const entry of readdirSync(slicesDir)) {
-          try {
-            if (!lstatSync(join(slicesDir, entry)).isDirectory()) continue;
-          } catch { continue; }
-          if (!knownSliceIds.has(entry)) {
-            issues.push({
-              severity: "warning",
-              code: "orphaned_slice_directory",
-              scope: "milestone",
-              unitId: milestoneId,
-              message: `Directory "${entry}" exists in ${milestoneId}/slices/ but is not referenced in the roadmap`,
-              file: `${relMilestonePath(basePath, milestoneId)}/slices/${entry}`,
-              fixable: false,
-            });
-          }
-        }
-      }
-    } catch { /* non-fatal */ }
-
     for (const slice of roadmap.slices) {
       const unitId = `${milestoneId}/${slice.id}`;
       if (options?.scope && !matchesScope(unitId, options.scope) && options.scope !== milestoneId) continue;
@@ -646,33 +539,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
         continue;
       }
 
-      // ── Duplicate task IDs ───────────────────────────────────────────────
-      const taskIdCounts = new Map<string, number>();
-      for (const task of plan.tasks) taskIdCounts.set(task.id, (taskIdCounts.get(task.id) ?? 0) + 1);
-      for (const [taskId, count] of taskIdCounts) {
-        if (count > 1) {
-          issues.push({ severity: "error", code: "duplicate_task_id", scope: "slice", unitId,
-            message: `Task ID "${taskId}" appears ${count} times in ${slice.id}-PLAN.md — duplicate IDs cause dispatch failures`,
-            file: relSliceFile(basePath, milestoneId, slice.id, "PLAN"), fixable: false });
-        }
-      }
-
-      // ── Task files on disk not in plan ────────────────────────────────────
-      try {
-        if (tasksDir) {
-          const planTaskIds = new Set(plan.tasks.map(t => t.id));
-          for (const f of readdirSync(tasksDir)) {
-            if (!f.endsWith("-SUMMARY.md")) continue;
-            const diskTaskId = f.replace(/-SUMMARY\.md$/, "");
-            if (!planTaskIds.has(diskTaskId)) {
-              issues.push({ severity: "info", code: "task_file_not_in_plan", scope: "slice", unitId,
-                message: `Task summary "${f}" exists on disk but "${diskTaskId}" is not in ${slice.id}-PLAN.md`,
-                file: relTaskFile(basePath, milestoneId, slice.id, diskTaskId, "SUMMARY"), fixable: false });
-            }
-          }
-        }
-      } catch { /* non-fatal */ }
-
       let allTasksDone = plan.tasks.length > 0;
       for (const task of plan.tasks) {
         const taskUnitId = `${unitId}/${task.id}`;
@@ -689,7 +555,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
             file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"),
             fixable: true,
           });
-          dryRunCanFix("task_done_missing_summary", `create stub summary for ${taskUnitId}`);
           if (shouldFix("task_done_missing_summary")) {
             const stubPath = join(
               basePath, ".gsd", "milestones", milestoneId, "slices", slice.id, "tasks",
@@ -753,22 +618,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
           }
         }
 
-        // ── Future timestamp check ─────────────────────────────────────
-        if (task.done && hasSummary && summaryPath) {
-          try {
-            const rawSummary = await loadFile(summaryPath);
-            const m = rawSummary?.match(/^completed_at:\s*(.+)$/m);
-            if (m) {
-              const ts = new Date(m[1].trim());
-              if (!isNaN(ts.getTime()) && ts.getTime() > Date.now() + 24 * 60 * 60 * 1000) {
-                issues.push({ severity: "warning", code: "future_timestamp", scope: "task", unitId: taskUnitId,
-                  message: `Task ${task.id} has completed_at "${m[1].trim()}" which is more than 24h in the future`,
-                  file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"), fixable: false });
-              }
-            }
-          } catch { /* non-fatal */ }
-        }
-
         allTasksDone = allTasksDone && task.done;
       }
 
@@ -797,13 +646,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
         }
       }
 
-      // ── Stale REPLAN: exists but all tasks done ────────────────────────
-      if (replanPath && allTasksDone) {
-        issues.push({ severity: "info", code: "stale_replan_file", scope: "slice", unitId,
-          message: `${slice.id} has a REPLAN.md but all tasks are done — REPLAN.md may be stale`,
-          file: relSliceFile(basePath, milestoneId, slice.id, "REPLAN"), fixable: false });
-      }
-
       const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, slice.id, "SUMMARY");
       const sliceUatPath = join(slicePath, `${slice.id}-UAT.md`);
       const hasSliceSummary = !!(sliceSummaryPath && await loadFile(sliceSummaryPath));
@@ -819,7 +661,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
           file: relSliceFile(basePath, milestoneId, slice.id, "SUMMARY"),
           fixable: true,
         });
-        dryRunCanFix("all_tasks_done_missing_slice_summary", `create placeholder summary for ${unitId}`);
         if (shouldFix("all_tasks_done_missing_slice_summary")) await ensureSliceSummaryStub(basePath, milestoneId, slice.id, fixesApplied);
       }
 
@@ -833,7 +674,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
           file: `${relSlicePath(basePath, milestoneId, slice.id)}/${slice.id}-UAT.md`,
           fixable: true,
         });
-        dryRunCanFix("all_tasks_done_missing_slice_uat", `create placeholder UAT for ${unitId}`);
         if (shouldFix("all_tasks_done_missing_slice_uat")) await ensureSliceUatStub(basePath, milestoneId, slice.id, fixesApplied);
       }
 
@@ -847,7 +687,6 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
           file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
           fixable: true,
         });
-        dryRunCanFix("all_tasks_done_roadmap_not_checked", `mark ${slice.id} done in roadmap`);
         if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary" && issue.unitId === unitId))) {
           await markSliceDoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
         }
@@ -905,17 +744,14 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
     }
   }
 
-  if (fix && !dryRun && fixesApplied.length > 0) {
+  if (fix && fixesApplied.length > 0) {
     await updateStateFile(basePath, fixesApplied);
   }
 
-  const report: DoctorReport = {
+  return {
     ok: issues.every(issue => issue.severity !== "error"),
     basePath,
     issues,
     fixesApplied,
-    timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: Math.max(0, Date.now() - t0env - envMs) },
   };
-  await appendDoctorHistory(basePath, report);
-  return report;
 }

package/src/resources/extensions/gsd/tests/cmux.test.ts

@@ -100,99 +100,6 @@ test("buildCmuxStatusLabel and progress prefer deepest active unit", () => {
   assert.deepEqual(buildCmuxProgress(state), { value: 0.4, label: "2/5 tasks" });
 });
 
-describe("createGridLayout", () => {
-  // Create a mock CmuxClient that tracks createSplitFrom calls
-  function makeMockClient() {
-    let nextId = 1;
-    const calls: Array<{ source: string | undefined; direction: string }> = [];
-
-    const client = {
-      calls,
-      async createGridLayout(count: number) {
-        // Simulate the grid layout logic with a fake client
-        if (count <= 0) return [];
-        const surfaces: string[] = [];
-
-        const createSplitFrom = async (source: string | undefined, direction: string) => {
-          calls.push({ source, direction });
-          return `surface-${nextId++}`;
-        };
-
-        const rightCol = await createSplitFrom("gsd-surface", "right");
-        surfaces.push(rightCol);
-        if (count === 1) return surfaces;
-
-        const bottomRight = await createSplitFrom(rightCol, "down");
-        surfaces.push(bottomRight);
-        if (count === 2) return surfaces;
-
-        const bottomLeft = await createSplitFrom("gsd-surface", "down");
-        surfaces.push(bottomLeft);
-        if (count === 3) return surfaces;
-
-        let lastSurface = bottomRight;
-        for (let i = 3; i < count; i++) {
-          const next = await createSplitFrom(lastSurface, "down");
-          surfaces.push(next);
-          lastSurface = next;
-        }
-
-        return surfaces;
-      },
-    };
-    return client;
-  }
-
-  test("1 agent creates single right split", async () => {
-    const mock = makeMockClient();
-    const surfaces = await mock.createGridLayout(1);
-    assert.equal(surfaces.length, 1);
-    assert.deepEqual(mock.calls, [
-      { source: "gsd-surface", direction: "right" },
-    ]);
-  });
-
-  test("2 agents creates right column then splits it down", async () => {
-    const mock = makeMockClient();
-    const surfaces = await mock.createGridLayout(2);
-    assert.equal(surfaces.length, 2);
-    assert.deepEqual(mock.calls, [
-      { source: "gsd-surface", direction: "right" },
-      { source: "surface-1", direction: "down" },
-    ]);
-  });
-
-  test("3 agents creates 2x2 grid (gsd + 3 agent surfaces)", async () => {
-    const mock = makeMockClient();
-    const surfaces = await mock.createGridLayout(3);
-    assert.equal(surfaces.length, 3);
-    assert.deepEqual(mock.calls, [
-      { source: "gsd-surface", direction: "right" },
-      { source: "surface-1", direction: "down" },
-      { source: "gsd-surface", direction: "down" },
-    ]);
-  });
-
-  test("4 agents creates 2x2 grid with extra split", async () => {
-    const mock = makeMockClient();
-    const surfaces = await mock.createGridLayout(4);
-    assert.equal(surfaces.length, 4);
-    assert.deepEqual(mock.calls, [
-      { source: "gsd-surface", direction: "right" },
-      { source: "surface-1", direction: "down" },
-      { source: "gsd-surface", direction: "down" },
-      { source: "surface-2", direction: "down" },
-    ]);
-  });
-
-  test("0 agents returns empty", async () => {
-    const mock = makeMockClient();
-    const surfaces = await mock.createGridLayout(0);
-    assert.equal(surfaces.length, 0);
-    assert.equal(mock.calls.length, 0);
-  });
-});
-
 describe("cmux extension discovery opt-out", () => {
   test("cmux directory has package.json with pi manifest to prevent auto-discovery as extension", () => {
     const cmuxDir = path.resolve(

package/src/resources/extensions/gsd/tests/worktree.test.ts

@@ -11,7 +11,6 @@ import {
   getMainBranch,
   getSliceBranchName,
   parseSliceBranch,
-  resolveProjectRoot,
   setActiveMilestoneId,
   SLICE_BRANCH_RE,
 } from "../worktree.ts";
@@ -166,52 +165,6 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
-  // ── detectWorktreeName: symlink-resolved paths ───────────────────────────
-  console.log("\n=== detectWorktreeName (symlink-resolved paths) ===");
-  assertEq(
-    detectWorktreeName("/Users/fran/.gsd/projects/89e1c9ad49bf/worktrees/M001"),
-    "M001",
-    "detects milestone in symlink-resolved path",
-  );
-  assertEq(
-    detectWorktreeName("/Users/fran/.gsd/projects/abc123/worktrees/M002/subdir"),
-    "M002",
-    "detects milestone with trailing subdir in symlink-resolved path",
-  );
-  assertEq(
-    detectWorktreeName("/Users/fran/.gsd/projects/abc123"),
-    null,
-    "returns null for project root without worktrees segment",
-  );
-  assertEq(
-    detectWorktreeName("/foo/.gsd/worktrees/M001"),
-    "M001",
-    "still detects direct layout path",
-  );
-
-  // ── resolveProjectRoot: symlink-resolved paths ──────────────────────────
-  console.log("\n=== resolveProjectRoot (symlink-resolved paths) ===");
-  assertEq(
-    resolveProjectRoot("/Users/fran/.gsd/projects/89e1c9ad49bf/worktrees/M001"),
-    "/Users/fran",
-    "resolves to user home for symlink-resolved path",
-  );
-  assertEq(
-    resolveProjectRoot("/foo/.gsd/worktrees/M001"),
-    "/foo",
-    "still resolves direct layout path",
-  );
-  assertEq(
-    resolveProjectRoot("/some/repo"),
-    "/some/repo",
-    "returns unchanged for non-worktree path",
-  );
-  assertEq(
-    resolveProjectRoot("/data/.gsd/projects/deadbeef/worktrees/M003/nested"),
-    "/data",
-    "resolves correctly with nested subdirs after worktree name",
-  );
-
   rmSync(base, { recursive: true, force: true });
   report();
 }

package/src/resources/extensions/gsd/worktree.ts

@@ -67,60 +67,40 @@ export function captureIntegrationBranch(basePath: string, milestoneId: string,
 
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
 
-/**
- * Find the worktrees segment in a path, supporting both direct
- * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
- * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
- * paths contain the intermediate `projects/<hash>/` segment that the old
- * single-marker check missed.
- */
-function findWorktreeSegment(normalizedPath: string): { gsdIdx: number; afterWorktrees: number } | null {
-  // Direct layout: /.gsd/worktrees/<name>
-  const directMarker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(directMarker);
-  if (idx !== -1) {
-    return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
-  }
-  // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
-  const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
-  const match = normalizedPath.match(symlinkRe);
-  if (match && match.index !== undefined) {
-    return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
-  }
-  return null;
-}
-
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath: string): string | null {
   const normalizedPath = basePath.replaceAll("\\", "/");
-  const seg = findWorktreeSegment(normalizedPath);
-  if (!seg) return null;
-  const afterMarker = normalizedPath.slice(seg.afterWorktrees);
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  if (idx === -1) return null;
+  const afterMarker = normalizedPath.slice(idx + marker.length);
   const name = afterMarker.split("/")[0];
   return name || null;
 }
 
 /**
  * Resolve the project root from a path that may be inside a worktree.
- * If the path contains a worktrees segment, returns the portion before
- * `/.gsd/`. Otherwise returns the input unchanged.
+ * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
+ * before `/.gsd/`. Otherwise returns the input unchanged.
  *
  * Use this in commands that call `process.cwd()` to ensure they always
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath: string): string {
   const normalizedPath = basePath.replaceAll("\\", "/");
-  const seg = findWorktreeSegment(normalizedPath);
-  if (!seg) return basePath;
-  // Return the original path up to the /.gsd/ boundary
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  if (idx === -1) return basePath;
+  // Return the original path up to the .gsd/ marker (un-normalized)
+  // Account for potential OS-specific separators
   const sep = basePath.includes("\\") ? "\\" : "/";
-  const gsdMarker = `${sep}.gsd${sep}`;
-  const gsdIdx = basePath.indexOf(gsdMarker);
-  if (gsdIdx !== -1) return basePath.slice(0, gsdIdx);
-  return basePath.slice(0, seg.gsdIdx);
+  const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
+  const idxOs = basePath.indexOf(markerOs);
+  if (idxOs !== -1) return basePath.slice(0, idxOs);
+  return basePath.slice(0, idx);
 }
 
 /**

package/src/resources/extensions/subagent/index.ts

@@ -452,7 +452,7 @@ async function runSingleAgent(
 
 async function runSingleAgentInCmuxSplit(
 	cmuxClient: CmuxClient,
-	directionOrSurfaceId: "right" | "down" | string,
+	direction: "right" | "down",
 	defaultCwd: string,
 	agents: AgentConfig[],
 	agentName: string,
@@ -503,12 +503,7 @@ async function runSingleAgentInCmuxSplit(
 		const stdoutPath = path.join(tmpOutputDir, "stdout.jsonl");
 		const stderrPath = path.join(tmpOutputDir, "stderr.log");
 		const exitPath = path.join(tmpOutputDir, "exit.code");
-		// Accept either a pre-created surface ID or a direction to create a new split
-		const isDirection = directionOrSurfaceId === "right" || directionOrSurfaceId === "down"
-			|| directionOrSurfaceId === "left" || directionOrSurfaceId === "up";
-		const cmuxSurfaceId = isDirection
-			? await cmuxClient.createSplit(directionOrSurfaceId as "right" | "down" | "left" | "up")
-			: directionOrSurfaceId;
+		const cmuxSurfaceId = await cmuxClient.createSplit(direction);
 		if (!cmuxSurfaceId) {
 			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
 		}
@@ -811,16 +806,12 @@ export default function (pi: ExtensionAPI) {
 				const MAX_RETRIES = 1; // Retry failed tasks once
 				const batchId = crypto.randomUUID();
 				const batchSize = params.tasks.length;
-				// Pre-create a grid layout for cmux splits so agents get a clean tiled arrangement
-				const gridSurfaces = cmuxSplitsEnabled
-					? await cmuxClient.createGridLayout(Math.min(batchSize, MAX_CONCURRENCY))
-					: [];
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
 					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
 					const runTask = () => cmuxSplitsEnabled
 						? runSingleAgentInCmuxSplit(
 							cmuxClient,
-							gridSurfaces[index] ?? (index % 2 === 0 ? "right" : "down"),
+							index % 2 === 0 ? "right" : "down",
 							ctx.cwd,
 							agents,
 							t.agent,

package/dist/welcome-screen.d.ts

@@ -1,12 +0,0 @@
-/**
- * GSD Welcome Screen
- *
- * Rendered to stderr before the TUI takes over.
- * No box, no panels — logo with metadata alongside, dim hint below.
- */
-export interface WelcomeScreenOptions {
-    version: string;
-    modelName?: string;
-    provider?: string;
-}
-export declare function printWelcomeScreen(opts: WelcomeScreenOptions): void;

package/dist/welcome-screen.js

@@ -1,53 +0,0 @@
-/**
- * GSD Welcome Screen
- *
- * Rendered to stderr before the TUI takes over.
- * No box, no panels — logo with metadata alongside, dim hint below.
- */
-import os from 'node:os';
-import chalk from 'chalk';
-import { GSD_LOGO } from './logo.js';
-function getShortCwd() {
-    const cwd = process.cwd();
-    const home = os.homedir();
-    return cwd.startsWith(home) ? '~' + cwd.slice(home.length) : cwd;
-}
-export function printWelcomeScreen(opts) {
-    if (!process.stderr.isTTY)
-        return;
-    const { version, modelName, provider } = opts;
-    const shortCwd = getShortCwd();
-    // Info lines to sit alongside the logo (one per logo row)
-    const modelLine = [modelName, provider].filter(Boolean).join('  ·  ');
-    const INFO = [
-        `  ${chalk.bold('Get Shit Done')}  ${chalk.dim('v' + version)}`,
-        undefined,
-        modelLine ? `  ${chalk.dim(modelLine)}` : undefined,
-        `  ${chalk.dim(shortCwd)}`,
-        undefined,
-        undefined,
-    ];
-    const lines = [''];
-    for (let i = 0; i < GSD_LOGO.length; i++) {
-        lines.push(chalk.cyan(GSD_LOGO[i]) + (INFO[i] ?? ''));
-    }
-    // Tool status + hint — dim, aligned under the info text
-    const pad = ' '.repeat(28) + '  '; // aligns with the info text column
-    const toolParts = [];
-    if (process.env.BRAVE_API_KEY)
-        toolParts.push('Brave ✓');
-    if (process.env.BRAVE_ANSWERS_KEY)
-        toolParts.push('Answers ✓');
-    if (process.env.JINA_API_KEY)
-        toolParts.push('Jina ✓');
-    if (process.env.TAVILY_API_KEY)
-        toolParts.push('Tavily ✓');
-    if (process.env.CONTEXT7_API_KEY)
-        toolParts.push('Context7 ✓');
-    if (toolParts.length > 0) {
-        lines.push(chalk.dim(pad + ['Web search loaded', ...toolParts].join('  ·  ')));
-    }
-    lines.push(chalk.dim(pad + '/gsd to begin  ·  /gsd help for all commands'));
-    lines.push('');
-    process.stderr.write(lines.join('\n') + '\n');
-}