gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/dist/resources/extensions/browser-tools/tests/capture-sharp-optional.test.cjs

@@ -0,0 +1,91 @@
+/**
+ * Regression tests for the optional sharp dependency in capture.ts.
+ *
+ * Behaviour:
+ *   - constrainScreenshot must fall back to returning the raw buffer
+ *     unchanged when sharp is unavailable, rather than throwing.
+ *   - When sharp IS available, oversized screenshots get resized.
+ *
+ * No source-grep. The test drives the real constrainScreenshot function
+ * after seeding the module-private `_sharp` cache via the test-only
+ * `__setSharpForTesting` export.
+ */
+
+const { describe, it, afterEach } = require("node:test");
+const assert = require("node:assert/strict");
+const jiti = require("jiti")(__filename, { interopDefault: true, debug: false });
+
+const { constrainScreenshot, __setSharpForTesting } = jiti("../capture.ts");
+
+describe("constrainScreenshot — sharp unavailable (null)", () => {
+	afterEach(() => {
+		// Clear the test override so later tests don't inherit a null sharp.
+		__setSharpForTesting(undefined);
+	});
+
+	it("returns the raw buffer unchanged when sharp is null", async () => {
+		__setSharpForTesting(null);
+
+		const rawBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); // PNG magic bytes
+		const result = await constrainScreenshot(null, rawBuffer, "image/png", 80);
+
+		assert.strictEqual(
+			result,
+			rawBuffer,
+			"constrainScreenshot must return the exact same buffer instance when sharp is null",
+		);
+	});
+
+	it("returns the raw buffer unchanged for JPEG input when sharp is null", async () => {
+		__setSharpForTesting(null);
+
+		const rawBuffer = Buffer.from([0xff, 0xd8, 0xff, 0xe0]); // JPEG magic bytes
+		const result = await constrainScreenshot(null, rawBuffer, "image/jpeg", 80);
+
+		assert.strictEqual(result, rawBuffer);
+	});
+});
+
+describe("constrainScreenshot — sharp available", () => {
+	afterEach(() => {
+		__setSharpForTesting(undefined);
+	});
+
+	it("passes through a small image unchanged (below cap)", async () => {
+		const sharp = require("sharp");
+		const small = await sharp({
+			create: {
+				width: 400,
+				height: 300,
+				channels: 3,
+				background: { r: 128, g: 128, b: 128 },
+			},
+		})
+			.jpeg({ quality: 80 })
+			.toBuffer();
+
+		const result = await constrainScreenshot(null, small, "image/jpeg", 80);
+		const meta = await sharp(result).metadata();
+		assert.equal(meta.width, 400, "small images must not be resized");
+		assert.equal(meta.height, 300);
+	});
+
+	it("resizes an oversized image to within 1568px", async () => {
+		const sharp = require("sharp");
+		const big = await sharp({
+			create: {
+				width: 3000,
+				height: 2000,
+				channels: 3,
+				background: { r: 128, g: 128, b: 128 },
+			},
+		})
+			.jpeg({ quality: 80 })
+			.toBuffer();
+
+		const result = await constrainScreenshot(null, big, "image/jpeg", 80);
+		const meta = await sharp(result).metadata();
+		assert.ok(meta.width <= 1568, `width ${meta.width} must be <= 1568`);
+		assert.ok(meta.height <= 1568, `height ${meta.height} must be <= 1568`);
+	});
+});

package/dist/resources/extensions/gsd/auto/loop.js

@@ -163,17 +163,6 @@ function resolveDispatchNodeKind(unitType, sidecarItem) {
     }
     return "unit";
 }
-async function enforceMinRequestInterval(s, prefs) {
-    const minInterval = prefs?.min_request_interval_ms ?? 0;
-    if (minInterval > 0 && s.lastRequestTimestamp > 0) {
-        const elapsed = Date.now() - s.lastRequestTimestamp;
-        if (elapsed < minInterval) {
-            const waitMs = minInterval - elapsed;
-            debugLog("autoLoop", { phase: "rate-limit-wait", waitMs });
-            await new Promise(r => setTimeout(r, waitMs));
-        }
-    }
-}
 async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem) {
     if (dispatchContract === "legacy-direct") {
         return runUnitPhase(ic, iterData, loopState, sidecarItem);
@@ -403,13 +392,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     break;
                 }
                 // ── Unit execution (shared with dev path) ──
-                await enforceMinRequestInterval(s, prefs);
                 const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState);
-                if (unitPhaseResult.action === "next") {
-                    const requestTimestamp = unitPhaseResult.data.requestDispatchedAt ?? unitPhaseResult.data.unitStartedAt;
-                    if (typeof requestTimestamp === "number")
-                        s.lastRequestTimestamp = requestTimestamp;
-                }
                 deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
@@ -572,13 +555,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     sidecarKind: sidecarItem.kind,
                 });
             }
-            await enforceMinRequestInterval(s, prefs);
             const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem);
-            if (unitPhaseResult.action === "next") {
-                const requestTimestamp = unitPhaseResult.data.requestDispatchedAt ?? unitPhaseResult.data.unitStartedAt;
-                if (typeof requestTimestamp === "number")
-                    s.lastRequestTimestamp = requestTimestamp;
-            }
             deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,

package/dist/resources/extensions/gsd/auto/phases.js

@@ -1365,7 +1365,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
                 // Fall through to next iteration where dispatch will re-derive
                 // and re-dispatch this unit.
-                return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
+                return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
             }
         }
     }
@@ -1418,7 +1418,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         s.checkpointSha = null;
     }
-    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
+    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -138,7 +138,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const capturedTurnGen = getCurrentTurnGeneration();
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
-    const requestDispatchedAt = Date.now();
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
     // ── Await agent_end with absolute timeout (H4 fix) ──
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
@@ -161,7 +160,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
         unitId,
         status: result.status,
     });
-    const finalResult = { ...result, requestDispatchedAt };
     // Discard trailing follow-up messages (e.g. async_job_result notifications)
     // from the completed unit. Without this, queued follow-ups trigger wasteful
     // LLM turns before the next session can start (#1642).
@@ -176,5 +174,5 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (e) {
         logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
     }
-    return finalResult;
+    return result;
 }

package/dist/resources/extensions/gsd/auto/session.js

@@ -118,8 +118,6 @@ export class AutoSession {
     lastPromptCharCount;
     lastBaselineCharCount;
     pendingQuickTasks = [];
-    /** Timestamp of the last LLM request dispatch (ms since epoch). Used for proactive rate limiting. */
-    lastRequestTimestamp = 0;
     // ── Safety harness ───────────────────────────────────────────────────────
     /** SHA of the pre-unit git checkpoint ref. Cleared on success or rollback. */
     checkpointSha = null;
@@ -217,7 +215,6 @@ export class AutoSession {
         this.lastPromptCharCount = undefined;
         this.lastBaselineCharCount = undefined;
         this.pendingQuickTasks = [];
-        this.lastRequestTimestamp = 0;
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -7,7 +7,6 @@
  * globals or AutoContext dependency.
  */
 import { parseUnitId } from "./unit-id.js";
-import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
@@ -169,35 +168,8 @@ function getChangedFilesSinceBranch(basePath, targetBranch) {
     }
 }
 function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
-    // Primary: path-scoped log against .gsd/milestones/<id>. Fast and unbounded
-    // by depth when .gsd/ is tracked in git.
-    const scoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
-    ]);
-    if (!scoped.ok)
-        return scoped;
-    if (scoped.matched)
-        return scoped;
-    // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
-    // path-scoped scan matches no commits even though GSD-tagged commits
-    // referencing the milestone exist on the integration branch. Re-scan all
-    // of HEAD's history and rely on commitMatchesMilestone to bind by
-    // explicit milestone mention in the message body.
-    //
-    // Intentionally unbounded — symmetric with the primary scan, and avoids
-    // reintroducing the rolling-depth failure class removed in #4699 where
-    // milestone evidence aged out behind unrelated activity.
-    return scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD",
-    ]);
-}
-function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {
-        const logOutput = execFileSync("git", [...gitArgs], {
-            cwd: basePath,
-            stdio: ["ignore", "pipe", "pipe"],
-            encoding: "utf-8",
-        });
+        const logOutput = execFileSync("git", ["log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
         const records = logOutput
             .split("\x1e")
             .map((record) => record.trim())
@@ -241,24 +213,13 @@ function commitMatchesMilestone(message, milestoneId, files) {
     if (commitTrailerStartsWithMilestone(message, milestoneId))
         return true;
     // Meaningful execute-task commits currently store task scope as Sxx/Tyy
-    // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone when
-    // either the commit touched this milestone's artifacts, or — for projects
-    // where .gsd/ is gitignored/external (#5033) — the message explicitly
-    // names the milestone.
+    // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone only
+    // when the commit also touched this milestone's artifacts.
     if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
-        if (files.some((file) => isMilestoneArtifactPath(file, milestoneId)))
-            return true;
-        if (commitMessageMentionsMilestone(message, milestoneId))
-            return true;
+        return files.some((file) => isMilestoneArtifactPath(file, milestoneId));
     }
     return false;
 }
-function commitMessageMentionsMilestone(message, milestoneId) {
-    if (!MILESTONE_ID_RE.test(milestoneId))
-        return false;
-    const escapedMilestone = milestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`\\b${escapedMilestone}\\b`).test(message);
-}
 function commitTrailerStartsWithMilestone(message, milestoneId) {
     const escapedMilestone = milestoneId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const trailerPattern = new RegExp(`^GSD-(?:Task|Unit):\\s*${escapedMilestone}(?:$|[\\s/])`, "m");

package/dist/resources/extensions/gsd/auto-start.js

@@ -208,7 +208,7 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
         else {
             // Branch is NOT merged — preserve for safety, warn the user
             warnings.push(`Branch ${branch} exists for completed milestone ${milestoneId} but is NOT merged into ${mainBranch}. ` +
-                `This may contain unmerged work. Merge manually or run \`/gsd doctor fix\` to resolve.`);
+                `This may contain unmerged work. Merge manually or run \`/gsd health --fix\` to resolve.`);
             // #4764 telemetry
             try {
                 emitWorktreeOrphaned(basePath, milestoneId, {

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -139,6 +139,6 @@ export const DETERMINISTIC_POLICY_ERROR_STRINGS = [
 export function isDeterministicPolicyError(errorMsg) {
     if (!errorMsg)
         return false;
-    return DETERMINISTIC_POLICY_ERROR_RE.test(errorMsg)
-        || DETERMINISTIC_POLICY_ERROR_STRINGS.some(s => errorMsg.includes(s));
+    return (DETERMINISTIC_POLICY_ERROR_RE.test(errorMsg) ||
+        DETERMINISTIC_POLICY_ERROR_STRINGS.some(s => errorMsg.includes(s)));
 }

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

@@ -857,11 +857,6 @@ export function runWorktreePostCreateHook(sourceDir, worktreeDir, hookPath) {
 export function autoWorktreeBranch(milestoneId) {
     return `milestone/${milestoneId}`;
 }
-function normalizeLocalBranchRef(branch) {
-    return branch.startsWith("refs/heads/")
-        ? branch.slice("refs/heads/".length)
-        : branch;
-}
 // ─── Branch-mode Entry ─────────────────────────────────────────────────────
 /**
  * Enter branch isolation mode for a milestone.
@@ -1038,13 +1033,6 @@ function reconcilePlanCheckboxes(projectRoot, wtPath, milestoneId) {
     }
 }
 export function createAutoWorktree(basePath, milestoneId) {
-    // Check if repo has commits — git worktree requires a valid HEAD
-    try {
-        execFileSync("git", ["rev-parse", "--verify", "HEAD"], { cwd: basePath, stdio: "pipe" });
-    }
-    catch {
-        throw new GSDError(GSD_GIT_ERROR, `Cannot create worktree: repository has no commits yet. Worktree isolation requires at least one commit.`);
-    }
     const branch = autoWorktreeBranch(milestoneId);
     // Check if the milestone branch already exists — it survives auto-mode
     // stop/pause and contains committed work from prior sessions. If it exists,
@@ -1420,10 +1408,6 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         }
     }
     // 3. chdir to original base
-    // Note: previousCwd captures the cwd at this point — i.e. the worktree cwd
-    // entering the function. Subsequent throws restore to previousCwd, leaving
-    // the caller in worktree-cwd; callers (worktree-resolver) are responsible
-    // for any further cwd movement on the error path.
     const previousCwd = process.cwd();
     process.chdir(originalBasePath_);
     // 4. Resolve integration branch — prefer milestone metadata, then preferences,
@@ -1438,20 +1422,6 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         ? prefs.main_branch
         : undefined;
     const mainBranch = integrationBranch ?? validatedPrefBranch ?? nativeDetectMainBranch(originalBasePath_);
-    // Fail closed when the resolved integration branch is the milestone branch
-    // itself (#5024). Stale or corrupt metadata (e.g. integrationBranch recorded
-    // as "milestone/<MID>") would otherwise let the squash merge resolve to a
-    // self-merge: nothing-to-commit + empty self-diff in the post-merge safety
-    // check (#1792) collapse to a false success, and the worktree-resolver
-    // emits worktree-merged for work that never landed on a distinct
-    // integration branch.
-    if (normalizeLocalBranchRef(mainBranch) === milestoneBranch) {
-        process.chdir(previousCwd);
-        throw new GSDError(GSD_GIT_ERROR, `Resolved integration branch "${mainBranch}" is the same ref as milestone branch ` +
-            `"${milestoneBranch}" — refusing to self-merge. Integration branch metadata is invalid; ` +
-            `set a distinct main_branch in GSD preferences or repair the milestone integration record ` +
-            `before retrying milestone completion.`);
-    }
     // Remove transient project-root state files before any branch or merge
     // operation. Untracked milestone metadata can otherwise block squash merges.
     clearProjectRootStateFiles(originalBasePath_, milestoneId);

package/dist/resources/extensions/gsd/auto.js

@@ -80,12 +80,13 @@ import { runAutoLoopWithUok } from "./uok/kernel.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
+// ─── Session State ─────────────────────────────────────────────────────────
+import { AutoSession, } from "./auto/session.js";
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
-import { autoSession as s } from "./auto-runtime-state.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
-// The single shared `s` instance below is the only mutable AutoSession binding.
+// The single `s` instance below is the only mutable module-level binding.
 //
 // When adding features or fixing bugs:
 //   - New mutable state → add a property to AutoSession, not a module-level variable
@@ -94,6 +95,7 @@ import { autoSession as s } from "./auto-runtime-state.js";
 //
 // Tests in auto-session-encapsulation.test.ts enforce this invariant.
 // ─────────────────────────────────────────────────────────────────────────────
+const s = new AutoSession();
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 function captureProjectRootEnv(projectRoot) {
@@ -1406,21 +1408,10 @@ const widgetStateAccessors = {
  * Ensure directories, branches, and other prerequisites exist before
  * dispatching a unit. The LLM should never need to mkdir or git checkout.
  */
-export function ensurePreconditions(unitType, unitId, base, state) {
+function ensurePreconditions(unitType, unitId, base, state) {
     const { milestone: mid, slice: sid } = parseUnitId(unitId);
     const mDir = resolveMilestonePath(base, mid);
     if (!mDir) {
-        // Fix #4996: When dispatching a slice unit against an unrecognised milestone,
-        // only create the directory if the milestone has a DB row.
-        // Without this guard, forward-referenced unit IDs (e.g. from REQUIREMENTS.md)
-        // silently scaffold empty stub directories that later skew nextMilestoneId.
-        if (sid !== undefined) {
-            const hasDbRow = isDbAvailable() && getMilestone(mid) != null;
-            if (!hasDbRow) {
-                logWarning("engine", `ensurePreconditions: skipping mkdir for unrecognised milestone ${mid} referenced by slice unit ${unitId} — no DB row exists`, { file: "auto.ts" });
-                return;
-            }
-        }
         const newDir = join(milestonesDir(base), mid);
         mkdirSync(join(newDir, "slices"), { recursive: true });
     }

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -1,12 +1,11 @@
 import { Type } from "@sinclair/typebox";
 import { Text } from "@gsd/pi-tui";
+import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMilestoneIds } from "../guided-flow.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
-async function loadWorkflowExecutors() {
-    return import("../tools/workflow-tool-executors.js");
-}
+import { executeCompleteMilestone, executePlanMilestone, executePlanSlice, executeReplanSlice, executeReassessRoadmap, executeSaveGateResult, executeSliceComplete, executeSummarySave, executeTaskComplete, executeValidateMilestone, } from "../tools/workflow-tool-executors.js";
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -281,7 +280,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, requirementSaveTool, "gsd_save_requirement", "gsd_requirement_save");
     // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
     const summarySaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeSummarySave } = await loadWorkflowExecutors();
         return executeSummarySave(params, process.cwd());
     };
     const summarySaveTool = {
@@ -332,7 +330,6 @@ export function registerDbTools(pi) {
         try {
             // Claim a reserved ID if the guided-flow already previewed one to the user.
             // This guarantees the ID shown in the UI matches the one materialised on disk.
-            const { claimReservedId, findMilestoneIds, getReservedMilestoneIds, nextMilestoneId } = await import("../guided-flow.js");
             const reserved = claimReservedId();
             if (reserved) {
                 await ensureMilestoneDbRow(reserved);
@@ -411,7 +408,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
     // ─── gsd_plan_milestone (gsd_milestone_plan alias) ─────────────────────
     const planMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executePlanMilestone } = await loadWorkflowExecutors();
         return executePlanMilestone(params, process.cwd());
     };
     const planMilestoneTool = {
@@ -476,7 +472,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, planMilestoneTool, "gsd_milestone_plan", "gsd_plan_milestone");
     // ─── gsd_plan_slice (gsd_slice_plan alias) ─────────────────────────────
     const planSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executePlanSlice } = await loadWorkflowExecutors();
         return executePlanSlice(params, process.cwd());
     };
     const planSliceTool = {
@@ -590,7 +585,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, planTaskTool, "gsd_task_plan", "gsd_plan_task");
     // ─── gsd_task_complete (gsd_complete_task alias) ────────────────────────
     const taskCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeTaskComplete } = await loadWorkflowExecutors();
         return executeTaskComplete(params, process.cwd());
     };
     const taskCompleteTool = {
@@ -653,7 +647,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, taskCompleteTool, "gsd_complete_task", "gsd_task_complete");
     // ─── gsd_slice_complete (gsd_complete_slice alias) ─────────────────────
     const sliceCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeSliceComplete } = await loadWorkflowExecutors();
         return executeSliceComplete(params, process.cwd());
     };
     const sliceCompleteTool = {
@@ -818,7 +811,6 @@ export function registerDbTools(pi) {
     });
     // ─── gsd_complete_milestone ────────────────────────────────────────────
     const milestoneCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeCompleteMilestone } = await loadWorkflowExecutors();
         return executeCompleteMilestone(params, process.cwd());
     };
     const milestoneCompleteTool = {
@@ -859,7 +851,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneCompleteTool, "gsd_milestone_complete", "gsd_complete_milestone");
     // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
     const milestoneValidateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeValidateMilestone } = await loadWorkflowExecutors();
         return executeValidateMilestone(params, process.cwd());
     };
     const milestoneValidateTool = {
@@ -892,7 +883,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneValidateTool, "gsd_milestone_validate", "gsd_validate_milestone");
     // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
     const replanSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeReplanSlice } = await loadWorkflowExecutors();
         return executeReplanSlice(params, process.cwd());
     };
     const replanSliceTool = {
@@ -935,7 +925,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, replanSliceTool, "gsd_slice_replan", "gsd_replan_slice");
     // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
     const reassessRoadmapExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeReassessRoadmap } = await loadWorkflowExecutors();
         return executeReassessRoadmap(params, process.cwd());
     };
     const reassessRoadmapTool = {
@@ -1168,7 +1157,6 @@ export function registerDbTools(pi) {
     registerAlias(pi, reopenMilestoneTool, "gsd_reopen_milestone", "gsd_milestone_reopen");
     // ─── gsd_save_gate_result ──────────────────────────────────────────────
     const saveGateResultExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const { executeSaveGateResult } = await loadWorkflowExecutors();
         return executeSaveGateResult(params, process.cwd());
     };
     const saveGateResultTool = {

package/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -3,6 +3,11 @@
 // Exposes the `gsd_exec` tool over MCP. Opt-in: disabled unless
 // `context_mode.enabled: true` is set in preferences.
 import { Type } from "@sinclair/typebox";
+import { executeGsdExec } from "../tools/exec-tool.js";
+import { executeExecSearch } from "../tools/exec-search-tool.js";
+import { executeResume } from "../tools/resume-tool.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { logWarning } from "../workflow-logger.js";
 export function registerExecTools(pi) {
     pi.registerTool({
         name: "gsd_exec",
@@ -30,11 +35,6 @@ export function registerExecTools(pi) {
             })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const [{ executeGsdExec }, { loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
-                import("../tools/exec-tool.js"),
-                import("../preferences.js"),
-                import("../workflow-logger.js"),
-            ]);
             let prefs = null;
             try {
                 prefs = loadEffectiveGSDPreferences();
@@ -67,7 +67,6 @@ export function registerExecTools(pi) {
             limit: Type.Optional(Type.Number({ description: "Max results (default 20, cap 200)", minimum: 1, maximum: 200 })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const { executeExecSearch } = await import("../tools/exec-search-tool.js");
             return executeExecSearch(params, {
                 baseDir: process.cwd(),
             });
@@ -86,7 +85,6 @@ export function registerExecTools(pi) {
         ],
         parameters: Type.Object({}),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const { executeResume } = await import("../tools/resume-tool.js");
             return executeResume(params, {
                 baseDir: process.cwd(),
             });

package/dist/resources/extensions/gsd/bootstrap/query-tools.js

@@ -1,6 +1,8 @@
 // GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
 import { Type } from "@sinclair/typebox";
 import { ensureDbOpen } from "./dynamic-tools.js";
+import { executeMilestoneStatus } from "../tools/workflow-tool-executors.js";
+import { checkpointDatabase } from "../gsd-db.js";
 export function registerQueryTools(pi) {
     pi.registerTool({
         name: "gsd_milestone_status",
@@ -23,7 +25,6 @@ export function registerQueryTools(pi) {
                     details: { operation: "milestone_status", error: "db_unavailable" },
                 };
             }
-            const { executeMilestoneStatus } = await import("../tools/workflow-tool-executors.js");
             return executeMilestoneStatus(params);
         },
     });
@@ -48,7 +49,6 @@ export function registerQueryTools(pi) {
                     details: { operation: "checkpoint_db", error: "db_unavailable" },
                 };
             }
-            const { checkpointDatabase } = await import("../gsd-db.js");
             checkpointDatabase();
             return {
                 content: [{ type: "text", text: "WAL checkpoint complete. gsd.db is now up to date and safe to stage with git add." }],

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -1,6 +1,7 @@
 // GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
 import { registerExitCommand } from "../exit-command.js";
-import { registerLazyWorktreeCommands } from "../worktree-command-bootstrap.js";
+import { registerWorktreeCommand } from "../worktree-command.js";
+import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerExecTools } from "./exec-tools.js";
@@ -63,7 +64,7 @@ function installEpipeGuard() {
 export function registerGsdExtension(pi) {
     // Note: registerGSDCommand is called by index.ts before this function,
     // so we intentionally skip it here to avoid double-registration.
-    registerLazyWorktreeCommands(pi);
+    registerWorktreeCommand(pi);
     registerExitCommand(pi);
     // Wire the Layer 2 event emitter bridge so deeply-nested GSD code can emit
     // extension events (git lifecycle, verify, budget, milestone, unit) without
@@ -101,9 +102,7 @@ export function registerGsdExtension(pi) {
         ["cmux-events", () => initCmuxEventListeners(pi.events)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {
-                void import("../ecosystem/loader.js")
-                    .then(({ loadEcosystemExtensions }) => loadEcosystemExtensions(pi, ecosystemHandlers))
-                    .catch((err) => {
+                void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {
                     logWarning("ecosystem", `loader failed: ${err instanceof Error ? err.message : String(err)}`);
                 });
             }],