@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -10,6 +10,7 @@ import {
   compileUnitContextContract,
   compileUnitToolContract,
   getUnitWorkflowDispatchReadinessError,
+  getUnitWorkflowDispatchReadinessErrorForModel,
 } from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
@@ -111,6 +112,25 @@ test("Tool Contract derives dispatch readiness from Unit workflow tools", () =>
   assert.equal(error, null);
 });
 
+test("Tool Contract derives dispatch readiness from selected model context", () => {
+  const authLookups: string[] = [];
+  const error = getUnitWorkflowDispatchReadinessErrorForModel({
+    model: { provider: "claude-code" },
+    fallbackModel: { provider: "openai-codex", baseUrl: "local://claude-code" },
+    getProviderAuthMode(provider) {
+      authLookups.push(provider);
+      return provider === "claude-code" ? "externalCli" : "oauth";
+    },
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+  });
+
+  assert.equal(error, null);
+  assert.deepEqual(authLookups, ["claude-code"]);
+});
+
 test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
   const result = compileUnitContextContract("execute-task");
 

package/src/resources/extensions/gsd/tests/skill-discovery.test.ts

@@ -109,3 +109,49 @@ test("appendDiscoveredSkillsFallback does not duplicate skills already in the pr
     location: "/tmp/already-loaded/SKILL.md",
   }]), prompt);
 });
+
+test("snapshotSkills({cwd}) detects skills added to the project .agents/skills/ mid-session", async () => {
+  await withTempSkillHome(async (home) => {
+    // Use a project dir under the temp home so cwd is isolated.
+    const projectDir = join(home, "myproject");
+    const projectSkills = join(projectDir, ".agents", "skills");
+    snapshotSkills({ cwd: projectDir });
+
+    // Add a skill to the project skills dir after the snapshot.
+    writeDiskSkill(projectSkills, "project-disk-skill", "Project skill added mid-session.");
+    const detected = detectNewSkills();
+
+    assert.deepEqual(detected.map(skill => skill.name), ["project-disk-skill"]);
+    assert.equal(detected[0].location, join(projectSkills, "project-disk-skill", "SKILL.md"));
+  });
+});
+
+test("snapshotSkills({cwd}) detects skills added to the project .claude/skills/ mid-session", async () => {
+  await withTempSkillHome(async (home) => {
+    const projectDir = join(home, "claude-project");
+    const claudeSkills = join(projectDir, ".claude", "skills");
+    snapshotSkills({ cwd: projectDir });
+
+    writeDiskSkill(claudeSkills, "claude-project-skill", "Claude-format skill added mid-session.");
+    const detected = detectNewSkills();
+
+    assert.deepEqual(detected.map(skill => skill.name), ["claude-project-skill"]);
+  });
+});
+
+test("snapshotSkills({cwd}) treats skills already in the project dir as baseline, not newly discovered", async () => {
+  await withTempSkillHome(async (home) => {
+    // projectDir is intentionally NOT process.cwd(): mirrors auto-mode passing a
+    // base path that differs from cwd (e.g. after chdir into a worktree). The
+    // baseline must scan the passed cwd's dirs, so a skill present *before* the
+    // snapshot is part of the baseline and is never reported as newly discovered.
+    // Regresses the fix where snapshotCurrentSkillNames fell back to process.cwd().
+    const projectDir = join(home, "preexisting-project");
+    const projectSkills = join(projectDir, ".agents", "skills");
+    writeDiskSkill(projectSkills, "preexisting-project-skill");
+
+    snapshotSkills({ cwd: projectDir });
+
+    assert.deepEqual(detectNewSkills(), []);
+  });
+});

package/src/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -12,11 +12,9 @@ import { join, sep } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  mergeMilestoneToMain,
-} from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/stash-pop-gsd-conflict.test.ts

@@ -14,7 +14,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/stash-queued-context-files.test.ts

@@ -28,7 +28,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { mergeMilestoneToMain } from "../auto-worktree-merge.ts";
 import { _resetServiceCache } from "../worktree.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 

package/src/resources/extensions/gsd/tests/steer-worktree-path.test.ts

@@ -8,7 +8,7 @@ import { mkdtempSync, mkdirSync, existsSync, readFileSync, rmSync, writeFileSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { appendOverride, loadActiveOverrides } from "../files.ts";
-import { getAutoWorktreePath } from "../auto-worktree.ts";
+import { getAutoWorktreePath } from "../auto-worktree-path-resolution.ts";
 
 describe("steer worktree path resolution (#3476)", () => {
   let projectRoot: string;

package/src/resources/extensions/gsd/tests/sync-worktree-skip-current.test.ts

@@ -8,7 +8,7 @@ import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 describe("syncWorktreeStateBack does not copy worktree milestone projections", () => {
   it("copies root diagnostics but leaves milestone markdown directories behind", () => {

package/src/resources/extensions/gsd/tests/system-flat-phase-layout.test.ts

@@ -0,0 +1,33 @@
+// gsd-pi — Regression tests: system.md documents the flat-phase layout, not legacy milestone/slice/task paths
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+test("system.md does not advertise legacy milestone/slice/task artifact paths", () => {
+  const prompt = readPrompt("system");
+  for (const legacy of [".gsd/milestones", "milestones/M001", "slices/S01", "tasks/T01-PLAN.md"]) {
+    assert.ok(
+      !prompt.includes(legacy),
+      `system.md must not reference the legacy path fragment "${legacy}" after flat-phase migration`,
+    );
+  }
+});
+
+test("system.md documents the flat-phase directory structure", () => {
+  const prompt = readPrompt("system");
+  assert.match(prompt, /phases\/\{MM\}-\{slug\}/, "system.md must document phases/{MM}-{slug}/ directories");
+  assert.match(prompt, /\{MM\}-\{SS\}-PLAN\.md/, "system.md must document {MM}-{SS}-PLAN.md slice plans");
+  assert.match(
+    prompt,
+    /do not expect `tasks\/T##-PLAN\.md`/,
+    "system.md must state task plan content lives inside the slice plan, not tasks/T##-PLAN.md",
+  );
+});

package/src/resources/extensions/gsd/tests/teardown-chdir-failure-clears-registry.test.ts

@@ -36,13 +36,13 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
+  getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/teardown-cleanup-parity.test.ts

@@ -22,7 +22,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { teardownAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 function git(args: string[], cwd: string): void {
   execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });

package/src/resources/extensions/gsd/tests/teardown-failure-clears-registry.test.ts

@@ -38,13 +38,13 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import {
-  createAutoWorktree,
-  teardownAutoWorktree,
-  getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
+  getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -7,6 +7,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   checkToolCallLoop,
+  configureToolCallLoopGuard,
   recordToolCallLoopMutation,
   resetToolCallLoopGuard,
   disableToolCallLoopGuard,
@@ -251,6 +252,99 @@ console.log('\n── Loop guard: mutation progress decays per-tool counts (#109
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Successful shell/exec progress decays per-tool counts (#1206)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: successful shell/exec progress decays per-tool counts (#1206) ──');
+
+{
+  // A local model debugging a UAT scenario runs many varied bg_shell /
+  // gsd_uat_exec calls (restart server, npm install, curl an endpoint). Each
+  // successful call is state progression, so Guard 2 must decay and never
+  // block the productive turn — even past the repeatable cap.
+  for (const execTool of ['bg_shell', 'gsd_uat_exec', 'bash', 'gsd_exec']) {
+    resetToolCallLoopGuard();
+
+    for (let i = 1; i <= 20; i++) {
+      const result = checkToolCallLoop(execTool, { command: `step ${i}` });
+      assert.ok(result.block === false, `${execTool} call ${i} after exec progress should be allowed`);
+      assert.deepStrictEqual(getToolCallCountForTool(execTool), 1, `${execTool} count should decay before call ${i}`);
+
+      // A successful (non-error) exec call records progress, like a file mutation.
+      recordToolCallLoopMutation(execTool);
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Failing exec loops still trip the per-tool cap (#783 vs #1206)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: failing exec loop (no progress recorded) still trips the cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // The improvisation loop from #783: the model retries a missing tool through
+  // varied bash commands. Those fail (non-zero exit → isError), so the caller
+  // never records progress and the per-tool cap must still trip.
+  for (let i = 1; i <= 15; i++) {
+    const result = checkToolCallLoop('bash', { command: `try-missing-tool ${i}` });
+    assert.ok(result.block === false, `failing bash call ${i} should be allowed up to the cap`);
+    // No recordToolCallLoopMutation — the command errored.
+  }
+  const blocked = checkToolCallLoop('bash', { command: 'try-missing-tool 16' });
+  assert.ok(blocked.block === true, '16th failing bash call should be blocked by the per-tool cap');
+  assert.ok(blocked.reason?.includes('repeated tool'), 'reason should identify the per-tool guard');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// bg_shell/async_bash false-success must not decay the per-tool cap (#783)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: bg_shell failed run/start does not decay the cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 1; i <= 15; i++) {
+    const result = checkToolCallLoop('bg_shell', { action: 'run', command: `try-missing-tool ${i}` });
+    assert.ok(result.block === false, `failing bg_shell run ${i} should be allowed up to the cap`);
+    recordToolCallLoopMutation('bg_shell', { action: 'run', exitCode: 1, timedOut: false });
+  }
+  const blocked = checkToolCallLoop('bg_shell', { action: 'run', command: 'try-missing-tool 16' });
+  assert.ok(blocked.block === true, '16th failing bg_shell run should be blocked by the per-tool cap');
+}
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 1; i <= 15; i++) {
+    checkToolCallLoop('bg_shell', { action: 'start', command: `bad-server ${i}` });
+    recordToolCallLoopMutation('bg_shell', {
+      action: 'start',
+      process: { alive: false, exitCode: 1 },
+    });
+  }
+  const blocked = checkToolCallLoop('bg_shell', { action: 'start', command: 'bad-server 16' });
+  assert.ok(blocked.block === true, '16th dead bg_shell start should be blocked by the per-tool cap');
+}
+
+console.log('\n── Loop guard: async_bash job registration does not decay the cap (#783) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('async_bash', { command: `try-missing-tool ${i}` });
+    assert.ok(result.block === false, `async_bash call ${i} should be allowed up to the cap`);
+    recordToolCallLoopMutation('async_bash');
+  }
+  const blocked = checkToolCallLoop('async_bash', { command: 'try-missing-tool 7' });
+  assert.ok(blocked.block === true, '7th async_bash call should be blocked by the per-tool cap');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Distinct read-only navigation calls are context gathering, not repeated-tool loops.
 // ═══════════════════════════════════════════════════════════════════════════
@@ -448,3 +542,105 @@ console.log('\n── Loop guard: browser exemption does not widen to other tool
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Configurable thresholds (#1198)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: master switch disables both guards (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ enabled: false });
+  resetToolCallLoopGuard();
+  // Neither identical-args nor per-tool cap should ever trip while disabled.
+  for (let i = 1; i <= 30; i++) {
+    const result = checkToolCallLoop('gsd_complete_milestone', { same: 'args' });
+    assert.ok(result.block === false, `disabled guard should allow call ${i}`);
+  }
+  // Restore defaults for subsequent tests.
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: repeated_tool disabled keeps identical-args protection (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ repeated_tool: { enabled: false } });
+  resetToolCallLoopGuard();
+  // Per-tool cap is off: many varied-arg calls are allowed.
+  for (let i = 1; i <= 20; i++) {
+    const result = checkToolCallLoop('gsd_exec', { cmd: `run-${i}` });
+    assert.ok(result.block === false, `repeated_tool disabled should allow varied call ${i}`);
+  }
+  // Identical-args guard is still active.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    assert.ok(checkToolCallLoop('gsd_exec', { cmd: 'same' }).block === false);
+  }
+  const blocked = checkToolCallLoop('gsd_exec', { cmd: 'same' });
+  assert.ok(blocked.block === true, 'identical-args guard should still trip when repeated_tool is off');
+  assert.ok(blocked.reason?.includes('identical args'));
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: raised caps allow more repeated calls (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ repeated_tool: { default_cap: 10 } });
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 10; i++) {
+    const result = checkToolCallLoop('gsd_complete_milestone', { arg: `v${i}` });
+    assert.ok(result.block === false, `raised-cap call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('gsd_complete_milestone', { arg: 'v11' });
+  assert.ok(blocked.block === true, '11th call should trip the raised cap of 10');
+  assert.ok(blocked.reason?.includes('cap 10'), 'block message should mention the active cap');
+  assert.ok(blocked.reason?.includes('tool_call_loop_guard'), 'block message should mention the config key');
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: user-added exempt tools bypass the per-tool cap (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ repeated_tool: { exempt_tools: ['ctx_execute'] } });
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 30; i++) {
+    const result = checkToolCallLoop('ctx_execute', { arg: `v${i}` });
+    assert.ok(result.block === false, `exempt tool call ${i} should be allowed`);
+  }
+  // Built-in exempt defaults are preserved alongside the user-added tool.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 30; i++) {
+    assert.ok(checkToolCallLoop('read', { path: `f${i}` }).block === false, 'built-in exempt read should remain exempt');
+  }
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: identical-args max is configurable (#1198) ──');
+
+{
+  configureToolCallLoopGuard({ identical_args: { max_consecutive_calls: 2 } });
+  resetToolCallLoopGuard();
+  assert.ok(checkToolCallLoop('web_search', { q: 'x' }).block === false, 'call 1 allowed');
+  assert.ok(checkToolCallLoop('web_search', { q: 'x' }).block === false, 'call 2 allowed');
+  const blocked = checkToolCallLoop('web_search', { q: 'x' });
+  assert.ok(blocked.block === true, '3rd identical call should trip lowered max of 2');
+  assert.ok(blocked.reason?.includes('max 2'), 'block message should mention active max');
+  configureToolCallLoopGuard(null);
+}
+
+console.log('\n── Loop guard: env overrides win over preferences (#1198) ──');
+
+{
+  process.env.GSD_TOOL_LOOP_REPEATED_DEFAULT_CAP = '2';
+  configureToolCallLoopGuard({ repeated_tool: { default_cap: 6 } });
+  resetToolCallLoopGuard();
+  assert.ok(checkToolCallLoop('gsd_complete_milestone', { a: '1' }).block === false, 'call 1 allowed');
+  assert.ok(checkToolCallLoop('gsd_complete_milestone', { a: '2' }).block === false, 'call 2 allowed');
+  const blocked = checkToolCallLoop('gsd_complete_milestone', { a: '3' });
+  assert.ok(blocked.block === true, 'env override cap of 2 should win over preference cap of 6');
+  delete process.env.GSD_TOOL_LOOP_REPEATED_DEFAULT_CAP;
+  configureToolCallLoopGuard(null);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Reset restores default guard state after configuration tests
+// ═══════════════════════════════════════════════════════════════════════════
+resetToolCallLoopGuard();

package/src/resources/extensions/gsd/tests/uat-stuck-loop-orphaned-worktree.test.ts

@@ -30,7 +30,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
+import { syncProjectRootToWorktree } from "../auto-worktree-sync.ts";
 import {
   createWorktree,
   removeWorktree,

package/src/resources/extensions/gsd/tests/unit-registry.test.ts

@@ -18,6 +18,7 @@ import {
   getUnitDescriptor,
   getUnitPhaseChain,
   getUnitPromptTemplate,
+  getUnitPromptTemplates,
 } from "../unit-registry.ts";
 import {
   AUTO_UNIT_SCOPED_TOOLS,
@@ -123,13 +124,16 @@ const EXPECTED_DIRECT_PROMPT_TEMPLATES: Record<string, string> = {
 };
 
 const EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES = [
-  "discuss-milestone",
   "discuss-slice",
   "execute-task-simple",
   "triage-captures",
   "quick-task",
 ];
 
+const EXPECTED_CONDITIONAL_PROMPT_TEMPLATES: Record<string, string[]> = {
+  "discuss-milestone": ["discuss", "discuss-headless", "guided-discuss-milestone"],
+};
+
 // ─── Derived-view parity ──────────────────────────────────────────────────
 
 test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
@@ -190,6 +194,27 @@ test("direct prompt-template associations live on the Unit Registry", () => {
   }
 });
 
+test("conditional prompt-template associations live on the Unit Registry without pretending to be direct", () => {
+  for (const [unitType, promptTemplates] of Object.entries(EXPECTED_CONDITIONAL_PROMPT_TEMPLATES)) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      undefined,
+      `${unitType} must not expose a single direct prompt template`,
+    );
+    assert.deepEqual(
+      getUnitPromptTemplates(unitType),
+      promptTemplates,
+      `prompt templates for ${unitType}`,
+    );
+    for (const promptTemplate of promptTemplates) {
+      assert.ok(
+        existsSync(join(process.cwd(), "src/resources/extensions/gsd/prompts", `${promptTemplate}.md`)),
+        `prompt template file must exist for ${unitType}: ${promptTemplate}`,
+      );
+    }
+  }
+});
+
 test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
   for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
     assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);

package/src/resources/extensions/gsd/tests/worktree-db-integration.test.ts

@@ -17,7 +17,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import { worktreePath } from "../worktree-manager.ts";
 import {
   copyWorktreeDb,

package/src/resources/extensions/gsd/tests/worktree-db-respawn-truncation.test.ts

@@ -17,7 +17,7 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { syncProjectRootToWorktree } from '../auto-worktree.ts';
+import { syncProjectRootToWorktree } from '../auto-worktree-sync.ts';
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -18,9 +18,7 @@ import {
   reconcileWorktreeDb,
   insertDecision,
 } from "../gsd-db.ts";
-import {
-  _shouldReconcileWorktreeDb,
-} from "../auto-worktree.ts";
+import { _shouldReconcileWorktreeDb } from "../auto-worktree-sync.ts";
 import { isInfrastructureError } from "../auto/infra-errors.ts";
 
 describe("#2823: reconcileWorktreeDb same-file guard", () => {

package/src/resources/extensions/gsd/tests/worktree-expected-warnings.test.ts

@@ -6,7 +6,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 
-import { _isExpectedWorktreeUnlinkError } from "../auto-worktree.ts";
+import { _isExpectedWorktreeUnlinkError } from "../auto-worktree-path-utils.ts";
 import { resolveGitDir } from "../worktree-manager.ts";
 
 describe("worktree expected-condition warning suppression (#3665)", () => {

package/src/resources/extensions/gsd/tests/worktree-git-pathspec.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { _gitPathspecForWorktreePath } from "../auto-worktree.ts";
+import { _gitPathspecForWorktreePath } from "../auto-worktree-path-utils.ts";
 
 function run(cmd: string, args: string[], cwd: string): string {
   return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -3,7 +3,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { _resolveAutoWorktreeStartPoint } from "../auto-worktree.ts";
+import { _resolveAutoWorktreeStartPoint } from "../auto-worktree-branch-lifecycle.ts";
 
 test("auto-worktree start point prefers milestone integration branch", () => {
   const startPoint = _resolveAutoWorktreeStartPoint(

package/src/resources/extensions/gsd/tests/worktree-preferences-sync.test.ts

@@ -26,7 +26,7 @@ import { tmpdir } from "node:os";
 import {
   syncGsdStateToWorktree,
   syncWorktreeStateBack,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-sync.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────
 

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

@@ -13,7 +13,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
-import { createAutoWorktree, _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree.ts";
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
+import { _resetAutoWorktreeOriginalBaseForTests } from "../auto-worktree-session-registry.ts";
 import { reenterActiveWorktreeIfNeeded } from "../worktree-reentry.ts";
 
 // Safe: all inputs below are hardcoded test strings, not user input.

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -27,8 +27,11 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { syncProjectRootToWorktree } from '../auto-worktree.ts';
-import { syncGsdStateToWorktree, syncWorktreeStateBack } from '../auto-worktree.ts';
+import {
+  syncGsdStateToWorktree,
+  syncProjectRootToWorktree,
+  syncWorktreeStateBack,
+} from '../auto-worktree-sync.ts';
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 

package/src/resources/extensions/gsd/tests/worktree-sync-overwrite-loop.test.ts

@@ -25,7 +25,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncProjectRootToWorktree } from "../auto-worktree.ts";
+import { syncProjectRootToWorktree } from "../auto-worktree-sync.ts";
 
 function createBase(name: string): string {
   const base = mkdtempSync(join(tmpdir(), `gsd-wt-1886-${name}-`));

package/src/resources/extensions/gsd/tests/worktree-sync-tasks.test.ts

@@ -18,7 +18,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `gsd-sync-test-${prefix}-`));