gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.9bafd68

package/src/resources/extensions/gsd/tests/quick-branch-lifecycle.test.ts

@@ -0,0 +1,281 @@
+/**
+ * Tests for quick-task branch lifecycle:
+ * - Branch creation → merge-back → cleanup
+ * - Cross-session recovery via disk-persisted state
+ * - captureIntegrationBranch guard against quick-task branches
+ *
+ * Relates to #1269, #1293.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { createTestContext } from './test-helpers.ts';
+import { captureIntegrationBranch, getCurrentBranch } from "../worktree.ts";
+import { readIntegrationBranch, QUICK_BRANCH_RE } from "../git-service.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTestRepo(): string {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-quick-lifecycle-"));
+  run("git init -b main", repo);
+  run(`git config user.name "GSD Test"`, repo);
+  run(`git config user.email "test@gsd.dev"`, repo);
+  mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(repo, "README.md"), "init\n");
+  run("git add -A", repo);
+  run(`git commit -m "init"`, repo);
+  return repo;
+}
+
+async function main(): Promise<void> {
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // QUICK_BRANCH_RE
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== QUICK_BRANCH_RE: matches quick-task branches ===");
+
+  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
+  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
+  assertTrue(!QUICK_BRANCH_RE.test("main"), "rejects main");
+  assertTrue(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
+  assertTrue(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
+  assertTrue(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // captureIntegrationBranch: guard against quick-task branches
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== captureIntegrationBranch: skips quick-task branches ===");
+
+  {
+    const repo = createTestRepo();
+
+    // Create and checkout a quick-task branch
+    run("git checkout -b gsd/quick/1-fix-typo", repo);
+    assertEq(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
+
+    captureIntegrationBranch(repo, "M001");
+
+    assertEq(readIntegrationBranch(repo, "M001"), null,
+      "captureIntegrationBranch is a no-op on quick-task branches");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── Verify main is still recorded correctly ─────────────────────────
+
+  console.log("\n=== captureIntegrationBranch: records main correctly ===");
+
+  {
+    const repo = createTestRepo();
+
+    // Capture from main — should work normally
+    captureIntegrationBranch(repo, "M001");
+    assertEq(readIntegrationBranch(repo, "M001"), "main",
+      "main is recorded as integration branch");
+
+    // Switch to quick branch — capture should be no-op (doesn't overwrite main)
+    run("git checkout -b gsd/quick/1-fix-typo", repo);
+    captureIntegrationBranch(repo, "M001");
+    assertEq(readIntegrationBranch(repo, "M001"), "main",
+      "quick branch does not overwrite existing integration branch");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── Sequence: main → quick → back to main → capture ────────────────
+
+  console.log("\n=== captureIntegrationBranch: correct after quick branch round-trip ===");
+
+  {
+    const repo = createTestRepo();
+
+    // Simulate quick-task lifecycle: branch off, do work, return to main
+    run("git checkout -b gsd/quick/1-fix-typo", repo);
+    writeFileSync(join(repo, "fix.txt"), "fixed\n");
+    run("git add -A", repo);
+    run(`git commit -m "quick-fix"`, repo);
+    run("git checkout main", repo);
+    run("git merge --squash gsd/quick/1-fix-typo", repo);
+    run(`git commit -m "quick(Q1): fix-typo"`, repo);
+    run("git branch -D gsd/quick/1-fix-typo", repo);
+
+    // Now capture — should get main, not the deleted quick branch
+    captureIntegrationBranch(repo, "M002");
+    assertEq(readIntegrationBranch(repo, "M002"), "main",
+      "after quick round-trip, main is captured correctly");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // cleanupQuickBranch: in-memory path (same session)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== cleanupQuickBranch: merges back and cleans up (same session) ===");
+
+  {
+    const repo = createTestRepo();
+    const origCwd = process.cwd();
+
+    // Simulate what handleQuick does: create branch, set pending state
+    run("git checkout -b gsd/quick/1-fix-typo", repo);
+    writeFileSync(join(repo, "fix.txt"), "fixed\n");
+    run("git add -A", repo);
+    run(`git commit -m "quick-fix"`, repo);
+
+    // Write the disk state (simulating handleQuick's persistPendingReturn)
+    const returnState = {
+      basePath: repo,
+      originalBranch: "main",
+      quickBranch: "gsd/quick/1-fix-typo",
+      taskNum: 1,
+      slug: "fix-typo",
+      description: "fix typo",
+    };
+    const runtimeDir = join(repo, ".gsd", "runtime");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(join(runtimeDir, "quick-return.json"), JSON.stringify(returnState) + "\n");
+
+    // Switch cwd to repo so cleanupQuickBranch finds the disk state
+    process.chdir(repo);
+
+    // Import and call cleanupQuickBranch
+    // Use dynamic import to get a fresh module scope — the in-memory state
+    // won't be set, so it will fall through to disk recovery
+    const { cleanupQuickBranch } = await import("../quick.ts");
+    const result = cleanupQuickBranch();
+
+    assertTrue(result, "cleanupQuickBranch returns true");
+    assertEq(getCurrentBranch(repo), "main", "back on main after cleanup");
+
+    // Verify merge happened — fix.txt should exist on main
+    assertTrue(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
+
+    // Verify quick branch deleted
+    const branches = run("git branch", repo);
+    assertTrue(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
+
+    // Verify disk state cleaned up
+    assertTrue(!existsSync(join(runtimeDir, "quick-return.json")), "quick-return.json removed");
+
+    process.chdir(origCwd);
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // cleanupQuickBranch: cross-session recovery from disk
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== cleanupQuickBranch: recovers from disk state (cross-session) ===");
+
+  {
+    const repo = createTestRepo();
+    const origCwd = process.cwd();
+
+    // Simulate a crashed session: branch exists with work, disk state persisted,
+    // but in-memory state is gone (new process)
+    run("git checkout -b gsd/quick/2-add-docs", repo);
+    writeFileSync(join(repo, "docs.md"), "# Docs\n");
+    run("git add -A", repo);
+    run(`git commit -m "add-docs"`, repo);
+
+    // Write disk state manually (simulates what handleQuick would persist)
+    const runtimeDir = join(repo, ".gsd", "runtime");
+    mkdirSync(runtimeDir, { recursive: true });
+    writeFileSync(join(runtimeDir, "quick-return.json"), JSON.stringify({
+      basePath: repo,
+      originalBranch: "main",
+      quickBranch: "gsd/quick/2-add-docs",
+      taskNum: 2,
+      slug: "add-docs",
+      description: "add docs",
+    }) + "\n");
+
+    process.chdir(repo);
+
+    const { cleanupQuickBranch } = await import("../quick.ts");
+    const result = cleanupQuickBranch();
+
+    assertTrue(result, "cross-session recovery returns true");
+    assertEq(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
+    assertTrue(existsSync(join(repo, "docs.md")), "docs.md merged to main");
+    assertTrue(!existsSync(join(runtimeDir, "quick-return.json")), "disk state cleaned up");
+
+    process.chdir(origCwd);
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // cleanupQuickBranch: no-op when no pending state
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== cleanupQuickBranch: no-op without pending state ===");
+
+  {
+    const repo = createTestRepo();
+    const origCwd = process.cwd();
+    process.chdir(repo);
+
+    const { cleanupQuickBranch } = await import("../quick.ts");
+    const result = cleanupQuickBranch();
+
+    assertTrue(!result, "returns false when no pending state");
+    assertEq(getCurrentBranch(repo), "main", "stays on main");
+
+    process.chdir(origCwd);
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // End-to-end: quick branch does NOT contaminate integration branch
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== E2E: quick branch does not contaminate integration branch ===");
+
+  {
+    const repo = createTestRepo();
+
+    // 1. Record main as integration branch for M001
+    captureIntegrationBranch(repo, "M001");
+    assertEq(readIntegrationBranch(repo, "M001"), "main", "M001 integration = main");
+
+    // 2. Start a quick task (branch off)
+    run("git checkout -b gsd/quick/1-fix-typo", repo);
+
+    // 3. Try to capture integration branch for M002 while on quick branch
+    captureIntegrationBranch(repo, "M002");
+    assertEq(readIntegrationBranch(repo, "M002"), null,
+      "M002 integration NOT recorded from quick branch");
+
+    // 4. Return to main (simulate cleanupQuickBranch)
+    run("git checkout main", repo);
+
+    // 5. Now capture M002 from main — should work
+    captureIntegrationBranch(repo, "M002");
+    assertEq(readIntegrationBranch(repo, "M002"), "main",
+      "M002 integration = main after returning from quick branch");
+
+    // 6. Verify M001 still intact
+    assertEq(readIntegrationBranch(repo, "M001"), "main",
+      "M001 integration unchanged");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -0,0 +1,71 @@
+import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { externalGsdRoot, ensureGsdSymlink } from "../repo-identity.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+async function main(): Promise<void> {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-identity-"));
+  const stateDir = mkdtempSync(join(tmpdir(), "gsd-state-"));
+
+  try {
+    process.env.GSD_STATE_DIR = stateDir;
+
+    run("git init -b main", base);
+    run('git config user.name "Pi Test"', base);
+    run('git config user.email "pi@example.com"', base);
+    run('git remote add origin git@github.com:example/repo.git', base);
+    writeFileSync(join(base, "README.md"), "# Test Repo\n", "utf-8");
+    run("git add README.md", base);
+    run('git commit -m "chore: init"', base);
+
+    const worktreePath = join(base, ".gsd", "worktrees", "M001");
+    run(`git worktree add -b milestone/M001 ${worktreePath}`, base);
+
+    console.log("\n=== ensureGsdSymlink points worktree at main repo external state dir ===");
+    const expectedExternalState = externalGsdRoot(base);
+    const mainState = ensureGsdSymlink(base);
+    assertEq(mainState, realpathSync(join(base, ".gsd")), "ensureGsdSymlink(base) returns the current main repo .gsd target");
+    const worktreeState = ensureGsdSymlink(worktreePath);
+    assertEq(worktreeState, expectedExternalState, "worktree symlink target matches main repo external state dir");
+    assertTrue(existsSync(join(worktreePath, ".gsd")), "worktree .gsd exists");
+    assertTrue(lstatSync(join(worktreePath, ".gsd")).isSymbolicLink(), "worktree .gsd is a symlink");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), expectedExternalState, "worktree .gsd symlink resolves to main repo external state dir");
+
+    console.log("\n=== ensureGsdSymlink heals stale worktree symlinks ===");
+    const staleState = join(stateDir, "projects", "stale-worktree-state");
+    mkdirSync(staleState, { recursive: true });
+    rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });
+    symlinkSync(staleState, join(worktreePath, ".gsd"), "junction");
+    const healedState = ensureGsdSymlink(worktreePath);
+    assertEq(healedState, expectedExternalState, "stale worktree symlink is repaired to canonical external state dir");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), expectedExternalState, "healed worktree symlink resolves to canonical external state dir");
+
+    console.log("\n=== ensureGsdSymlink preserves worktree .gsd directories ===");
+    rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });
+    mkdirSync(join(worktreePath, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(worktreePath, ".gsd", "milestones", "stale.txt"), "stale\n", "utf-8");
+    const preservedDirState = ensureGsdSymlink(worktreePath);
+    assertEq(preservedDirState, join(worktreePath, ".gsd"), "worktree .gsd directory is left in place for sync-based refresh");
+    assertTrue(lstatSync(join(worktreePath, ".gsd")).isDirectory(), "worktree .gsd directory remains a directory");
+    assertTrue(existsSync(join(worktreePath, ".gsd", "milestones", "stale.txt")), "existing worktree .gsd directory contents remain available for sync logic");
+  } finally {
+    delete process.env.GSD_STATE_DIR;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+    report();
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/verification-gate.test.ts

@@ -261,6 +261,71 @@ test("verification-gate: each check has durationMs", () => {
   }
 });
 
+// ─── Infra Error Tagging Tests ───────────────────────────────────────────────
+
+test("verification-gate: spawnSync ETIMEDOUT → infraError: true on the check", () => {
+  const tmp = makeTempDir("vg-etimedout");
+  try {
+    // Use a short timeout against a long sleep to guarantee ETIMEDOUT
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      preferenceCommands: ["sleep 60"],
+      commandTimeoutMs: 200,
+    });
+    assert.equal(result.passed, false);
+    assert.equal(result.checks.length, 1);
+    assert.ok(result.checks[0].exitCode !== 0, "should have non-zero exit code");
+    assert.equal(result.checks[0].infraError, true, "ETIMEDOUT should be tagged as infraError");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+});
+
+test("verification-gate: real command failure does NOT have infraError", () => {
+  const tmp = makeTempDir("vg-real-fail");
+  try {
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      // Cross-platform: node with --eval flag and no shell-sensitive characters
+      preferenceCommands: ["node --eval \"process.exitCode=1\""],
+    });
+    assert.equal(result.passed, false);
+    assert.equal(result.checks.length, 1);
+    assert.equal(result.checks[0].exitCode, 1);
+    assert.equal(result.checks[0].infraError, undefined, "real failure should not be tagged as infraError");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+});
+
+test("verification-gate: mixed infra + real failure — only infra check is tagged", () => {
+  const tmp = makeTempDir("vg-mixed-infra");
+  try {
+    // Use a timeout that kills "sleep 60" but lets "node --eval" complete (~80ms).
+    // The gate applies the same timeout to each command sequentially.
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T01",
+      cwd: tmp,
+      preferenceCommands: ["sleep 60", "node --eval \"process.exitCode=2\""],
+      commandTimeoutMs: 500,
+    });
+    assert.equal(result.passed, false);
+    assert.equal(result.checks.length, 2);
+    // First check: ETIMEDOUT → infraError
+    assert.equal(result.checks[0].infraError, true, "timed-out command should be infraError");
+    // Second check: real exit 2 → no infraError
+    assert.equal(result.checks[1].exitCode, 2);
+    assert.equal(result.checks[1].infraError, undefined, "real failure should not be infraError");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+});
+
 // ─── Preference Validation Tests ─────────────────────────────────────────────
 
 test("verification-gate: validatePreferences accepts valid verification keys", () => {

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

@@ -56,6 +56,10 @@ export interface VerificationCheck {
   stderr: string;
   durationMs: number;
   blocking: boolean;     // true for preference/task-plan sources, false for package-json (advisory only)
+  /** True when the failure was a spawn/infra error (ETIMEDOUT, ENOENT, ENOMEM)
+   *  rather than the command itself failing. Infra errors are transient and
+   *  should not trigger auto-fix retries — the agent cannot fix the OS. */
+  infraError?: boolean;
 }
 
 /** A runtime error captured from bg-shell processes or browser console */

package/src/resources/extensions/gsd/verification-evidence.ts

@@ -11,7 +11,7 @@
 
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import type { VerificationResult } from "./types.ts";
+import type { VerificationResult } from "./types.js";
 
 // ─── JSON Evidence Artifact ──────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/verification-gate.ts

@@ -232,13 +232,20 @@ export interface RunVerificationGateOptions {
   commandTimeoutMs?: number;
 }
 
+/** Error codes from spawnSync that indicate infrastructure/OS-level failures
+ *  rather than the command itself failing. These are transient — the agent
+ *  cannot fix them, so they should not trigger auto-fix retries. */
+const INFRA_ERROR_CODES = new Set(["ETIMEDOUT", "ENOENT", "ENOMEM", "EMFILE", "ENFILE", "EAGAIN"]);
+
 /**
  * Run the verification gate: discover commands, execute each via spawnSync,
  * and return a structured result.
  *
  * - All commands run sequentially regardless of individual pass/fail.
- * - `passed` is true when every command exits 0 (or no commands are discovered).
+ * - `passed` is true when every blocking command exits 0 (or no commands are discovered).
  * - stdout/stderr per command are truncated to 10 KB.
+ * - Spawn/infra errors (ETIMEDOUT, ENOENT, etc.) are tagged with `infraError: true`
+ *   so the retry logic can distinguish "the OS couldn't run this" from "the tests failed".
  */
 export function runVerificationGate(options: RunVerificationGateOptions): VerificationResult {
   const timestamp = Date.now();
@@ -279,12 +286,26 @@ export function runVerificationGate(options: RunVerificationGateOptions): Verifi
     let stderr: string;
 
     if (result.error) {
-      // Command not found or spawn failure
+      // Spawn infrastructure failure — OS-level, not a test failure.
+      // Tag with infraError so the retry logic can skip auto-fix attempts.
+      const errCode = (result.error as NodeJS.ErrnoException).code;
+      const isInfra = !!errCode && INFRA_ERROR_CODES.has(errCode);
       exitCode = 127;
       stderr = truncate(
         (result.stderr || "") + "\n" + (result.error as Error).message,
         MAX_OUTPUT_BYTES,
       );
+
+      checks.push({
+        command,
+        exitCode,
+        stdout: truncate(result.stdout, MAX_OUTPUT_BYTES),
+        stderr,
+        durationMs,
+        blocking,
+        ...(isInfra ? { infraError: true } : {}),
+      });
+      continue;
     } else {
       // status is null when killed by signal — treat as failure
       exitCode = result.status ?? 1;

package/src/resources/extensions/gsd/worktree-command-bootstrap.ts

@@ -0,0 +1,46 @@
+import { importExtensionModule, type ExtensionAPI, type ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+const WORKTREE_SUBCOMMANDS = [
+  { cmd: "list", desc: "List existing worktrees" },
+  { cmd: "merge", desc: "Merge a worktree into a target branch" },
+  { cmd: "remove", desc: "Remove a worktree and its branch" },
+  { cmd: "switch", desc: "Switch into an existing worktree" },
+  { cmd: "create", desc: "Create and switch into a new worktree" },
+  { cmd: "return", desc: "Switch back to the main tree" },
+] as const;
+
+function getWorktreeCompletions(prefix: string) {
+  const parts = prefix.trim().split(/\s+/);
+  if (parts.length <= 1) {
+    const partial = parts[0] ?? "";
+    return WORKTREE_SUBCOMMANDS
+      .filter((option) => option.cmd.startsWith(partial))
+      .map((option) => ({
+        value: option.cmd,
+        label: option.cmd,
+        description: option.desc,
+      }));
+  }
+
+  if (parts[0] === "remove" && parts.length <= 2 && "all".startsWith(parts[1] ?? "")) {
+    return [{ value: "remove all", label: "all", description: "Remove all worktrees" }];
+  }
+
+  return null;
+}
+
+function registerLazyWorktreeAlias(pi: ExtensionAPI, name: "worktree" | "wt", description: string): void {
+  pi.registerCommand(name, {
+    description,
+    getArgumentCompletions: getWorktreeCompletions,
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const { handleWorktreeCommand } = await importExtensionModule<typeof import("./worktree-command.js")>(import.meta.url, "./worktree-command.js");
+      await handleWorktreeCommand(args, ctx, pi, name);
+    },
+  });
+}
+
+export function registerLazyWorktreeCommands(pi: ExtensionAPI): void {
+  registerLazyWorktreeAlias(pi, "worktree", "Git worktrees (also /wt): /worktree <name> | list | merge | remove");
+  registerLazyWorktreeAlias(pi, "wt", "Alias for /worktree");
+}

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

@@ -42,13 +42,25 @@ import { getErrorMessage } from "./error-utils.js";
  */
 let originalCwd: string | null = null;
 
+function ensureWorktreeStateInitialized(): void {
+  if (originalCwd) return;
+  const cwd = process.cwd();
+  const marker = `${sep}.gsd${sep}worktrees${sep}`;
+  const markerIdx = cwd.indexOf(marker);
+  if (markerIdx !== -1) {
+    originalCwd = cwd.slice(0, markerIdx);
+  }
+}
+
 /** Get the original project root if currently in a worktree, or null. */
 export function getWorktreeOriginalCwd(): string | null {
+  ensureWorktreeStateInitialized();
   return originalCwd;
 }
 
 /** Get the name of the active worktree, or null if not in one. */
 export function getActiveWorktreeName(): string | null {
+  ensureWorktreeStateInitialized();
   if (!originalCwd) return null;
   const cwd = process.cwd();
   const wtDir = join(gsdRoot(originalCwd), "worktrees");
@@ -104,12 +116,13 @@ function worktreeCompletions(prefix: string) {
   return [];
 }
 
-async function worktreeHandler(
+export async function handleWorktreeCommand(
   args: string,
   ctx: ExtensionCommandContext,
   pi: ExtensionAPI,
   alias: string,
 ): Promise<void> {
+  ensureWorktreeStateInitialized();
   const trimmed = (typeof args === "string" ? args : "").trim();
   const basePath = process.cwd();
 
@@ -233,21 +246,14 @@ export function registerWorktreeCommand(pi: ExtensionAPI): void {
   // Restore worktree state after /reload.
   // The module-level originalCwd resets to null when extensions are re-loaded,
   // but process.cwd() is still inside the worktree. Detect this and recover.
-  if (!originalCwd) {
-    const cwd = process.cwd();
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const markerIdx = cwd.indexOf(marker);
-    if (markerIdx !== -1) {
-      originalCwd = cwd.slice(0, markerIdx);
-    }
-  }
+  ensureWorktreeStateInitialized();
 
   pi.registerCommand("worktree", {
     description: "Git worktrees (also /wt): /worktree <name> | list | merge | remove",
     getArgumentCompletions: worktreeCompletions,
 
     async handler(args: string, ctx: ExtensionCommandContext) {
-      await worktreeHandler(args, ctx, pi, "worktree");
+      await handleWorktreeCommand(args, ctx, pi, "worktree");
     },
   });
 
@@ -256,7 +262,7 @@ export function registerWorktreeCommand(pi: ExtensionAPI): void {
     description: "Alias for /worktree",
     getArgumentCompletions: worktreeCompletions,
     async handler(args: string, ctx: ExtensionCommandContext) {
-      await worktreeHandler(args, ctx, pi, "wt");
+      await handleWorktreeCommand(args, ctx, pi, "wt");
     },
   });
 }

package/src/resources/extensions/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/src/resources/extensions/search-the-web/command-search-provider.ts

@@ -18,7 +18,7 @@ import {
   setSearchProviderPreference,
   resolveSearchProvider,
   type SearchProviderPreference,
-} from './provider.ts'
+} from './provider.js'
 
 const VALID_PREFERENCES: SearchProviderPreference[] = ['tavily', 'brave', 'ollama', 'auto']