@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.553dc518

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,
@@ -448,3 +449,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}-`));

package/src/resources/extensions/gsd/tool-contract.ts

@@ -85,6 +85,18 @@ export interface UnitWorkflowDispatchReadinessInput {
   activeTools?: string[];
 }
 
+export interface WorkflowDispatchModelContext {
+  provider?: string;
+  baseUrl?: string;
+}
+
+export interface UnitWorkflowDispatchReadinessForModelInput
+  extends Omit<UnitWorkflowDispatchReadinessInput, "provider" | "authMode" | "baseUrl"> {
+  model?: WorkflowDispatchModelContext | null;
+  fallbackModel?: WorkflowDispatchModelContext | null;
+  getProviderAuthMode?: (provider: string) => WorkflowCapabilityOptions["authMode"] | undefined;
+}
+
 export function compileUnitContextContract(unitType: string): UnitContextContractResult {
   const manifest = resolveManifest(unitType);
   if (!manifest) {
@@ -115,6 +127,23 @@ export function getUnitWorkflowDispatchReadinessError(
   );
 }
 
+export function getUnitWorkflowDispatchReadinessErrorForModel(
+  input: UnitWorkflowDispatchReadinessForModelInput,
+): string | null {
+  const provider = input.model?.provider ?? input.fallbackModel?.provider;
+  const baseUrl = input.model?.baseUrl ?? input.fallbackModel?.baseUrl;
+  return getUnitWorkflowDispatchReadinessError({
+    provider,
+    unitType: input.unitType,
+    projectRoot: input.projectRoot,
+    env: input.env,
+    surface: input.surface,
+    authMode: provider ? input.getProviderAuthMode?.(provider) : undefined,
+    baseUrl,
+    activeTools: input.activeTools,
+  });
+}
+
 export function compileUnitToolContract(unitType: string): ToolContractResult {
   const manifest = resolveManifest(unitType);
   const surfaceContract = getUnitToolSurfaceContract(unitType);

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

@@ -21,8 +21,8 @@
 // Not yet declared here (remaining ADR-033 steps): the manifest data
 // (`UNIT_MANIFESTS` stays in unit-context-manifest.ts, already type-enforced
 // against the registry's `UnitType`). Prompt-template association is declared
-// for direct one-template units; conditional/composite prompt selection stays
-// with the prompt builders until it has a richer registry shape.
+// for direct one-template units and verified conditional template sets;
+// composition logic stays with prompt builders.
 
 import type { CanonicalWorkflowToolName } from "@opengsd/contracts";
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../shared/browser-contract.js";
@@ -68,6 +68,11 @@ export interface UnitDescriptor {
    * verified prompt associations.
    */
   readonly promptTemplate?: string;
+  /**
+   * Prompt template ids a conditional or composite builder may choose from.
+   * Omitted unless every listed association is verified against the builder.
+   */
+  readonly promptTemplates?: readonly string[];
   /** `null` = the unit has no scoped gsd-tool contract. */
   readonly toolContract: UnitToolSurfaceContract | null;
 }
@@ -137,6 +142,7 @@ export const UNIT_REGISTRY = {
     kind: "primary",
     scopeClass: "standard",
     phaseChain: ["discuss", "planning"],
+    promptTemplates: ["discuss", "discuss-headless", "guided-discuss-milestone"],
     toolContract: {
       allowedGsdTools: [
         "gsd_summary_save",
@@ -526,3 +532,11 @@ export function getUnitPhaseChain(unitType: string): readonly GSDModelPhaseKey[]
 export function getUnitPromptTemplate(unitType: string): string | undefined {
   return getUnitDescriptor(unitType)?.promptTemplate;
 }
+
+/** Prompt template ids for any verified direct or conditional prompt builder. */
+export function getUnitPromptTemplates(unitType: string): readonly string[] {
+  const descriptor = getUnitDescriptor(unitType);
+  if (!descriptor) return [];
+  if (descriptor.promptTemplates) return descriptor.promptTemplates;
+  return descriptor.promptTemplate ? [descriptor.promptTemplate] : [];
+}

package/src/resources/extensions/gsd/unmerged-milestone-guard.ts

@@ -9,7 +9,7 @@ import {
   nativeDiffNumstat,
   nativeIsAncestor,
 } from "./native-git-bridge.js";
-import { autoWorktreeBranch } from "./auto-worktree.js";
+import { autoWorktreeBranch } from "./auto-worktree-branch-lifecycle.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones } from "./gsd-db.js";
 import { resolveMilestoneIntegrationBranch } from "./git-service.js";

package/src/resources/extensions/gsd/validation-block-guard.ts

@@ -3,7 +3,8 @@
 
 import { existsSync } from "node:fs";
 
-import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";

package/src/resources/extensions/gsd/workspace-git-preflight.ts

@@ -3,8 +3,8 @@
 
 import { existsSync, realpathSync } from "node:fs";
 
-import { getAutoWorktreePath } from "./auto-worktree.js";
-import { isSafeToAutoResolve } from "./auto-worktree.js";
+import { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import {
   listMergeStateBlockers,

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

@@ -13,7 +13,7 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, resolveGitHeadPath, nudgeGitBranchCache } from "./worktree.js";
-import { runWorktreePostCreateHook } from "./auto-worktree.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { showConfirm } from "../shared/tui.js";
 import { gsdRoot, milestonesDir, resolveGsdPathContract } from "./paths.js";
 import {

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

@@ -68,19 +68,21 @@ import {
   getCurrentBranch,
 } from "./worktree.js";
 import { nativeCheckoutBranch } from "./native-git-bridge.js";
-// ADR-016 phase 2 / C2 (#5625): worktree-manager helpers inlined from
-// `./auto-worktree.js`. These seven functions are not real seams — Lifecycle
-// is the only Module that calls them, and they live alongside the Module's
-// other primitives in `auto-worktree.ts`.
+// ADR-016 phase 2 / C2 (#5625): lifecycle uses focused auto-worktree
+// modules instead of the legacy compatibility barrel. Branch, entry/path,
+// creation, and teardown primitives are still implementation-level seams for
+// Lifecycle; tests vary them through `WorktreeLifecycleTestOverrides` below.
 import {
   autoWorktreeBranch,
-  createAutoWorktree,
-  enterAutoWorktree,
   enterBranchModeForMilestone,
-  getAutoWorktreePath,
+} from "./auto-worktree-branch-lifecycle.js";
+import { createAutoWorktree } from "./auto-worktree-creation.js";
+import {
+  enterAutoWorktree,
   isInAutoWorktree,
-  teardownAutoWorktree,
-} from "./auto-worktree.js";
+} from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
+import { teardownAutoWorktree } from "./auto-worktree-teardown.js";
 import { resolveRoadmapForMilestoneMerge } from "./milestone-merge-roadmap.js";
 import type { MilestoneMergeTransactionRunner } from "./milestone-merge-transaction.js";
 
@@ -353,7 +355,7 @@ export interface MergeContext {
   originalBasePath: string;
   /**
    * Current worktree path or project root when in branch mode. Used as the
-   * cwd anchor for `mergeMilestoneToMain` and the source for
+   * cwd anchor for the milestone merge transaction and the source for
    * `Projection.finalizeProjectionForMerge`.
    */
   worktreeBasePath: string;
@@ -381,7 +383,8 @@ export interface MergeStandaloneResult {
   pushed: boolean;
   /**
    * Commit message produced by the squash merge, if available. Forwarded
-   * from `mergeMilestoneToMain`. Only populated when `merged === true`.
+   * from the milestone merge transaction. Only populated when
+   * `merged === true`.
    */
   commitMessage?: string;
 }
@@ -1373,8 +1376,9 @@ function _mergeBranchModeImpl(
  * **CWD anchor**: anchors `process.cwd()` at `originalBasePath` before
  * non-worktree merge paths to mirror the single-loop guard against ENOENT
  * after teardown (de73fb43d). Worktree-mode merge paths keep the real
- * worktree as cwd because `mergeMilestoneToMain()` infers source worktree
- * state from `process.cwd()`. Best-effort; silent on failure.
+ * worktree as cwd because the default milestone merge transaction delegates
+ * to the legacy merge primitive, which infers source worktree state from
+ * `process.cwd()`. Best-effort; silent on failure.
  *
  * **Failure handling**: `MergeConflictError` and other unrecoverable errors
  * propagate to the caller. The caller is responsible for any state restore
@@ -1475,8 +1479,8 @@ export function mergeMilestoneStandalone(
 
   // Set cwd to the correct anchor before dispatching to mode implementations.
   // Worktree mode / in-worktree override must run from the live worktree so
-  // mergeMilestoneToMain can find worktree-local state; branch mode runs from
-  // the original project root. Best-effort for synthetic test paths.
+  // The default merge transaction can find worktree-local state; branch mode
+  // runs from the original project root. Best-effort for synthetic test paths.
   const targetCwd = mode === "worktree" || inWorktree
     ? worktreeBasePath
     : originalBasePath;

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

@@ -8,7 +8,8 @@
 
 import { readdirSync } from "node:fs";
 
-import { enterAutoWorktree, getAutoWorktreePath } from "./auto-worktree.js";
+import { enterAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { getIsolationMode } from "./preferences.js";
 import { allWorktreesDirs } from "./worktree-manager.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";