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

package/dist/resources/extensions/gsd/state/derive/from-db.js

@@ -12,6 +12,31 @@ import { countUnmappedActiveRequirements, formatCompletePhaseNextAction } from '
 import { logWarning } from '../../workflow-logger.js';
 import { buildDbUnavailableState, ensureExistingWorkflowDbOpen, getRequestedMilestoneLock, } from './db-open.js';
 const isStatusDone = isClosedStatus;
+function buildProgress(context) {
+    return {
+        milestones: context.milestoneProgress,
+        ...(context.sliceProgress ? { slices: context.sliceProgress } : {}),
+        ...(context.taskProgress ? { tasks: context.taskProgress } : {}),
+    };
+}
+function buildDerivedState(context, phase, nextAction, options = {}) {
+    return {
+        activeMilestone: context.activeMilestone,
+        activeSlice: context.activeSlice ?? null,
+        activeTask: context.activeTask ?? null,
+        phase,
+        recentDecisions: [],
+        blockers: options.blockers ?? [],
+        nextAction,
+        ...(options.lastCompletedMilestone !== undefined
+            ? { lastCompletedMilestone: options.lastCompletedMilestone }
+            : {}),
+        ...(options.includeActiveWorkspace ? { activeWorkspace: undefined } : {}),
+        registry: context.registry,
+        requirements: context.requirements,
+        progress: buildProgress(context),
+    };
+}
 function stripMilestonePrefix(title) {
     return title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '') || title;
 }
@@ -125,103 +150,60 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
 function handleNoActiveMilestone(registry, requirements, milestoneProgress) {
     const pendingEntries = registry.filter(e => e.status === 'pending');
     const parkedEntries = registry.filter(e => e.status === 'parked');
+    const context = {
+        activeMilestone: null,
+        registry,
+        requirements,
+        milestoneProgress,
+    };
     if (pendingEntries.length > 0) {
         const blockerDetails = pendingEntries
             .filter(e => e.dependsOn && e.dependsOn.length > 0)
             .map(e => `${e.id} is waiting on unmet deps: ${e.dependsOn.join(', ')}`);
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'blocked',
-            recentDecisions: [], blockers: blockerDetails.length > 0
+        return buildDerivedState(context, 'blocked', 'Resolve milestone dependencies before proceeding.', {
+            blockers: blockerDetails.length > 0
                 ? blockerDetails
                 : ['All remaining milestones are dep-blocked but no deps listed — check CONTEXT.md files'],
-            nextAction: 'Resolve milestone dependencies before proceeding.',
-            registry, requirements,
-            progress: { milestones: milestoneProgress },
-        };
+        });
     }
     if (parkedEntries.length > 0) {
         const parkedIds = parkedEntries.map(e => e.id).join(', ');
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'pre-planning',
-            recentDecisions: [], blockers: [],
-            nextAction: `All remaining milestones are parked (${parkedIds}). Run /gsd unpark <id> or create a new milestone.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress },
-        };
+        return buildDerivedState(context, 'pre-planning', `All remaining milestones are parked (${parkedIds}). Run /gsd unpark <id> or create a new milestone.`);
     }
     if (registry.length === 0) {
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'pre-planning',
-            recentDecisions: [], blockers: [],
-            nextAction: 'No milestones found. Run /gsd to create one.',
-            registry: [], requirements,
-            progress: { milestones: { done: 0, total: 0 } },
-        };
+        return buildDerivedState({ ...context, registry: [], milestoneProgress: { done: 0, total: 0 } }, 'pre-planning', 'No milestones found. Run /gsd to create one.');
     }
     const lastEntry = registry[registry.length - 1];
     const unmappedActive = countUnmappedActiveRequirements();
     const completionNote = formatCompletePhaseNextAction(unmappedActive);
-    return {
-        activeMilestone: null,
+    return buildDerivedState(context, 'complete', completionNote, {
         lastCompletedMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
-        activeSlice: null, activeTask: null,
-        phase: 'complete',
-        recentDecisions: [], blockers: [],
-        nextAction: completionNote,
-        registry, requirements,
-        progress: { milestones: milestoneProgress },
-    };
+    });
 }
 async function handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress) {
     const validation = getLatestAssessmentByScope(activeMilestone.id, "milestone-validation");
     const verdict = typeof validation?.status === "string" ? validation.status : undefined;
     const validationTerminal = verdict != null && verdict !== "";
+    const context = {
+        activeMilestone,
+        registry,
+        requirements,
+        milestoneProgress,
+        sliceProgress,
+    };
     if (!validationTerminal) {
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'validating-milestone',
-            recentDecisions: [], blockers: [],
-            nextAction: `Validate milestone ${activeMilestone.id} before completion.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(context, 'validating-milestone', `Validate milestone ${activeMilestone.id} before completion.`);
     }
     // All roadmap slices are done (enforced by caller) and verdict is
     // needs-remediation — remediation cannot progress without new slices.
     // Return blocked instead of re-dispatching validate-milestone (#4506).
     if (verdict === 'needs-attention') {
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'blocked',
-            recentDecisions: [],
-            blockers: [formatNeedsAttentionBlocker(activeMilestone.id)],
-            nextAction: `Resolve ${activeMilestone.id} validation attention before proceeding.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(context, 'blocked', `Resolve ${activeMilestone.id} validation attention before proceeding.`, { blockers: [formatNeedsAttentionBlocker(activeMilestone.id)] });
     }
     if (verdict === 'needs-remediation') {
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'blocked',
-            recentDecisions: [],
-            blockers: [formatNeedsRemediationBlocker(activeMilestone.id)],
-            nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(context, 'blocked', `Resolve ${activeMilestone.id} remediation before proceeding.`, { blockers: [formatNeedsRemediationBlocker(activeMilestone.id)] });
     }
-    return {
-        activeMilestone, activeSlice: null, activeTask: null,
-        phase: 'completing-milestone',
-        recentDecisions: [], blockers: [],
-        nextAction: `All slices complete in ${activeMilestone.id}. Write milestone summary.`,
-        registry, requirements,
-        progress: { milestones: milestoneProgress, slices: sliceProgress },
-    };
+    return buildDerivedState(context, 'completing-milestone', `All slices complete in ${activeMilestone.id}. Write milestone summary.`);
 }
 function resolveSliceDependencies(activeMilestoneSlices) {
     const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
@@ -271,13 +253,12 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         ? allMilestones.filter(m => m.id === milestoneLock)
         : allMilestones;
     if (milestones.length === 0) {
-        return {
-            activeMilestone: null, activeSlice: null, activeTask: null,
-            phase: 'pre-planning', recentDecisions: [], blockers: [],
-            nextAction: 'No milestones found. Run /gsd to create one.',
-            registry: [], requirements,
-            progress: { milestones: { done: 0, total: 0 } },
-        };
+        return buildDerivedState({
+            activeMilestone: null,
+            registry: [],
+            requirements,
+            milestoneProgress: { done: 0, total: 0 },
+        }, 'pre-planning', 'No milestones found. Run /gsd to create one.');
     }
     const { completeMilestoneIds, parkedMilestoneIds } = buildCompletenessSet(basePath, milestones);
     const registryContext = await buildRegistryAndFindActive(basePath, milestones, completeMilestoneIds, parkedMilestoneIds);
@@ -294,18 +275,20 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         const nextAction = activeMilestoneHasDraft
             ? `Discuss draft context for milestone ${activeMilestone.id}.`
             : `Plan milestone ${activeMilestone.id}.`;
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase, recentDecisions: [], blockers: [],
-            nextAction, registry, requirements,
-            progress: { milestones: milestoneProgress },
-        };
+        return buildDerivedState({ activeMilestone, registry, requirements, milestoneProgress }, phase, nextAction);
     }
     const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
     const sliceProgress = {
         done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
         total: activeMilestoneSlices.length,
     };
+    const sliceStateContext = {
+        activeMilestone,
+        registry,
+        requirements,
+        milestoneProgress,
+        sliceProgress,
+    };
     if (allSlicesDone) {
         return handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress);
     }
@@ -314,21 +297,9 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
         // If locked slice wasn't found, it returns null but logs warning, we need to return 'blocked'
         const sliceLock = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_SLICE_LOCK : undefined;
         if (sliceLock) {
-            return {
-                activeMilestone, activeSlice: null, activeTask: null,
-                phase: 'blocked', recentDecisions: [], blockers: [`GSD_SLICE_LOCK=${sliceLock} not found in active milestone slices`],
-                nextAction: 'Slice lock references a non-existent slice — check orchestrator dispatch.',
-                registry, requirements,
-                progress: { milestones: milestoneProgress, slices: sliceProgress },
-            };
+            return buildDerivedState(sliceStateContext, 'blocked', 'Slice lock references a non-existent slice — check orchestrator dispatch.', { blockers: [`GSD_SLICE_LOCK=${sliceLock} not found in active milestone slices`] });
         }
-        return {
-            activeMilestone, activeSlice: null, activeTask: null,
-            phase: 'blocked', recentDecisions: [], blockers: ['No slice eligible — check dependency ordering'],
-            nextAction: 'Resolve dependency blockers or plan next slice.',
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState(sliceStateContext, 'blocked', 'Resolve dependency blockers or plan next slice.', { blockers: ['No slice eligible — check dependency ordering'] });
     }
     const { activeSlice } = activeSliceContext;
     const activeSliceRow = activeSliceContext.activeSliceRow;
@@ -338,39 +309,30 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     // PLAN.md and preference flags are projections/configuration and are
     // deliberately not used to infer whether the slice itself is a sketch.
     if (activeSliceRow?.is_sketch === 1) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'refining', recentDecisions: [], blockers: [],
-            nextAction: `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress },
-        };
+        return buildDerivedState({ ...sliceStateContext, activeSlice }, 'refining', `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`);
     }
     const tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     const taskProgress = {
         done: tasks.filter(t => isStatusDone(t.status)).length,
         total: tasks.length,
     };
+    const taskStateContext = {
+        ...sliceStateContext,
+        activeSlice,
+        taskProgress,
+    };
     const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
     if (!activeTaskRow && tasks.length > 0) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'summarizing', recentDecisions: [], blockers: [],
-            nextAction: `All tasks done in ${activeSlice.id}. Write slice summary and complete slice.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+        return buildDerivedState(taskStateContext, 'summarizing', `All tasks done in ${activeSlice.id}. Write slice summary and complete slice.`);
     }
     if (!activeTaskRow) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'planning', recentDecisions: [], blockers: [],
-            nextAction: `Slice ${activeSlice.id} has no DB tasks. Plan slice tasks before execution.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+        return buildDerivedState(taskStateContext, 'planning', `Slice ${activeSlice.id} has no DB tasks. Plan slice tasks before execution.`);
     }
     const activeTask = { id: activeTaskRow.id, title: activeTaskRow.title };
+    const activeTaskStateContext = {
+        ...taskStateContext,
+        activeTask,
+    };
     // ── Quality gate evaluation check ──────────────────────────────────
     // Pause before execution only when gates owned by the `gate-evaluate`
     // turn (Q3/Q4) are still pending. Q8 is also `scope:"slice"` but is
@@ -380,27 +342,16 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     // Slices with zero gate rows (pre-feature or simple) skip straight through.
     const pendingGateCount = getPendingGateCountForTurn(activeMilestone.id, activeSlice.id, "gate-evaluate");
     if (pendingGateCount > 0) {
-        return {
-            activeMilestone, activeSlice, activeTask: null,
-            phase: 'evaluating-gates', recentDecisions: [], blockers: [],
-            nextAction: `Evaluate ${pendingGateCount} quality gate(s) for ${activeSlice.id} before execution.`,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+        return buildDerivedState(taskStateContext, 'evaluating-gates', `Evaluate ${pendingGateCount} quality gate(s) for ${activeSlice.id} before execution.`);
     }
     const blockerTaskId = await detectBlockers(basePath, activeMilestone.id, activeSlice.id, tasks);
     if (blockerTaskId) {
         const replanHistory = getReplanHistory(activeMilestone.id, activeSlice.id);
         if (replanHistory.length === 0) {
-            return {
-                activeMilestone, activeSlice, activeTask,
-                phase: 'replanning-slice', recentDecisions: [],
+            return buildDerivedState(activeTaskStateContext, 'replanning-slice', `Task ${blockerTaskId} reported blocker_discovered. Replan slice ${activeSlice.id} before continuing.`, {
                 blockers: [`Task ${blockerTaskId} discovered a blocker requiring slice replan`],
-                nextAction: `Task ${blockerTaskId} reported blocker_discovered. Replan slice ${activeSlice.id} before continuing.`,
-                activeWorkspace: undefined,
-                registry, requirements,
-                progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-            };
+                includeActiveWorkspace: true,
+            });
         }
     }
     // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
@@ -415,38 +366,22 @@ export async function deriveStateFromDb(basePath, artifactReadRoot = basePath) {
     // and the user's prior resolution never lands.
     const escalatingTaskId = detectPendingEscalation(tasks, basePath);
     if (escalatingTaskId) {
-        return {
-            activeMilestone, activeSlice, activeTask,
-            phase: 'escalating-task', recentDecisions: [],
+        return buildDerivedState(activeTaskStateContext, 'escalating-task', `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`, {
             blockers: [`Task ${escalatingTaskId} requires a user decision before the loop can proceed`],
-            nextAction: `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`,
-            activeWorkspace: undefined,
-            registry, requirements,
-            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-        };
+            includeActiveWorkspace: true,
+        });
     }
     if (!blockerTaskId) {
         const isTriggered = checkReplanTrigger(basePath, activeMilestone.id, activeSlice.id);
         if (isTriggered) {
             const replanHistory = getReplanHistory(activeMilestone.id, activeSlice.id);
             if (replanHistory.length === 0) {
-                return {
-                    activeMilestone, activeSlice, activeTask,
-                    phase: 'replanning-slice', recentDecisions: [],
+                return buildDerivedState(activeTaskStateContext, 'replanning-slice', `Triage replan triggered for slice ${activeSlice.id}. Replan before continuing.`, {
                     blockers: ['Triage replan trigger detected — slice replan required'],
-                    nextAction: `Triage replan triggered for slice ${activeSlice.id}. Replan before continuing.`,
-                    activeWorkspace: undefined,
-                    registry, requirements,
-                    progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-                };
+                    includeActiveWorkspace: true,
+                });
             }
         }
     }
-    return {
-        activeMilestone, activeSlice, activeTask,
-        phase: 'executing', recentDecisions: [], blockers: [],
-        nextAction: `Execute ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}.`,
-        registry, requirements,
-        progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
-    };
+    return buildDerivedState(activeTaskStateContext, 'executing', `Execute ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}.`);
 }

package/dist/resources/extensions/gsd/tool-contract.js

@@ -26,6 +26,20 @@ export function getUnitWorkflowDispatchReadinessError(input) {
         activeTools: input.activeTools,
     });
 }
+export function getUnitWorkflowDispatchReadinessErrorForModel(input) {
+    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) {
     const manifest = resolveManifest(unitType);
     const surfaceContract = getUnitToolSurfaceContract(unitType);

package/dist/resources/extensions/gsd/unit-registry.js

@@ -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 { BROWSER_CONTRACT_TOOL_NAMES } from "../shared/browser-contract.js";
 // ─── Shared tool-name constants (used by registry rows) ──────────────────
 export const RUN_UAT_WORKFLOW_TOOL_NAMES = [
@@ -84,6 +84,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplates: ["discuss", "discuss-headless", "guided-discuss-milestone"],
         toolContract: {
             allowedGsdTools: [
                 "gsd_summary_save",
@@ -444,3 +445,12 @@ export function getUnitPhaseChain(unitType) {
 export function getUnitPromptTemplate(unitType) {
     return getUnitDescriptor(unitType)?.promptTemplate;
 }
+/** Prompt template ids for any verified direct or conditional prompt builder. */
+export function getUnitPromptTemplates(unitType) {
+    const descriptor = getUnitDescriptor(unitType);
+    if (!descriptor)
+        return [];
+    if (descriptor.promptTemplates)
+        return descriptor.promptTemplates;
+    return descriptor.promptTemplate ? [descriptor.promptTemplate] : [];
+}

package/dist/resources/extensions/gsd/unmerged-milestone-guard.js

@@ -2,7 +2,7 @@
 // File Purpose: Block new workflow entry when completed milestone branches are still unmerged.
 import { execFileSync } from "node:child_process";
 import { nativeBranchExists, nativeDetectMainBranch, 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/dist/resources/extensions/gsd/validation-block-guard.js

@@ -1,7 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Shared command gate for validation-blocked milestones.
 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/dist/resources/extensions/gsd/workspace-git-preflight.js

@@ -1,8 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Unified workspace git preflight probe, heal, and readiness checks.
 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, probeGitConflictState, reconcileGitConflictsOnSignal, } from "./git-conflict-state.js";
 import { deriveState } from "./state.js";

package/dist/resources/extensions/gsd/worktree-command.js

@@ -11,7 +11,7 @@
  */
 import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, 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 { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, getWorktreeGSDDiff, getWorktreeCodeDiff, getWorktreeLog, worktreeBranchName, worktreePath, } from "./worktree-manager.js";

package/dist/resources/extensions/gsd/worktree-lifecycle.js

@@ -47,11 +47,15 @@ import { createWorkspace, scopeMilestone } from "./workspace.js";
 // adding type churn without enabling any test variation.
 import { autoCommitCurrentBranch, 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`.
-import { autoWorktreeBranch, createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, getAutoWorktreePath, isInAutoWorktree, teardownAutoWorktree, } from "./auto-worktree.js";
+// 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, enterBranchModeForMilestone, } from "./auto-worktree-branch-lifecycle.js";
+import { createAutoWorktree } from "./auto-worktree-creation.js";
+import { enterAutoWorktree, isInAutoWorktree, } 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";
 const recentWorktreeMergeFailures = new Map();
 const MERGE_FAILURE_DEDUPE_MS = 60_000;
@@ -874,8 +878,9 @@ function _mergeBranchModeImpl(deps, mctx) {
  * **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
@@ -963,8 +968,8 @@ export function mergeMilestoneStandalone(deps, mctx) {
     }
     // 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/dist/resources/extensions/gsd/worktree-reentry.js

@@ -6,7 +6,8 @@
 // back into the worktree. The worktree path is fully derivable from state, so we
 // resolve and chdir into it directly instead.
 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";