gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode worktree lifecycle, merge, and cleanup management.
 /**
  * GSD Auto-Worktree -- lifecycle management for auto-mode worktrees.
  *
@@ -6,7 +8,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, rmSync, unlinkSync, statSync, lstatSync as lstatSyncFn, } from "node:fs";
-import { isAbsolute, join, sep as pathSep } from "node:path";
+import { isAbsolute, join, relative, sep as pathSep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
 import { execFileSync } from "node:child_process";
@@ -15,7 +17,8 @@ import { gsdRoot, resolveGsdPathContract } from "./paths.js";
 import { createWorktree, removeWorktree, resolveGitDir, worktreePath, isInsideWorktreesDir, } from "./worktree-manager.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { isGsdWorktreePath, normalizeWorktreePathForCompare, resolveWorktreeProjectRoot, } from "./worktree-root.js";
-import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
+import { MergeConflictError, createDraftPR, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
+import { buildPrEvidence } from "./pr-evidence.js";
 import { debugLog } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -203,6 +206,41 @@ function setActiveWorkspace(ws) {
 function getActiveWorkspace() {
     return activeWorkspace;
 }
+function gitPathspecForWorktreePath(basePath, targetPath) {
+    let base = basePath;
+    let target = targetPath;
+    try {
+        base = realpathSync.native(basePath);
+    }
+    catch {
+        /* keep original */
+        void base;
+    }
+    try {
+        target = realpathSync.native(targetPath);
+    }
+    catch {
+        /* keep original */
+        void target;
+    }
+    const rel = relative(base, target);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        return null;
+    return rel.replaceAll("\\", "/");
+}
+function gitRemoteExists(basePath, remote) {
+    try {
+        execFileSync("git", ["remote", "get-url", remote], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function clearProjectRootStateFiles(basePath, milestoneId) {
     const gsdDir = gsdRoot(basePath);
     // Phase C pt 2: auto.lock removed from this list — the file is gone
@@ -236,9 +274,12 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
     for (const dir of syncedDirs) {
         try {
             if (existsSync(dir)) {
+                const pathspec = gitPathspecForWorktreePath(basePath, dir);
+                if (!pathspec)
+                    continue;
                 // Only remove files that are untracked by git — tracked files are
                 // managed by the branch checkout and should not be deleted.
-                const untrackedOutput = execFileSync("git", ["ls-files", "--others", "--exclude-standard", dir], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+                const untrackedOutput = execFileSync("git", ["ls-files", "--others", "--exclude-standard", pathspec], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
                 if (untrackedOutput) {
                     for (const f of untrackedOutput.split("\n").filter(Boolean)) {
                         try {
@@ -1899,17 +1940,19 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     let pushed = false;
     if (prefs.auto_push === true && prefs.auto_pr !== true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
-        try {
-            execFileSync("git", ["push", remote, mainBranch], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
-            pushed = true;
-        }
-        catch (err) {
-            // Push failure is non-fatal
-            logWarning("worktree", `git push failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (gitRemoteExists(originalBasePath_, remote)) {
+            try {
+                execFileSync("git", ["push", remote, mainBranch], {
+                    cwd: originalBasePath_,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    encoding: "utf-8",
+                });
+                pushed = true;
+            }
+            catch (err) {
+                // Push failure is non-fatal
+                logWarning("worktree", `git push failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // 9b. Auto-create PR if enabled (#2302: no longer gated on pushed/auto_push)
@@ -1917,30 +1960,36 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     if (prefs.auto_pr === true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
         const prTarget = prefs.pr_target_branch ?? mainBranch;
-        try {
-            // Push the milestone branch to remote first
-            execFileSync("git", ["push", remote, milestoneBranch], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
-            // Create PR via gh CLI with explicit --head and --base (#2302)
-            execFileSync("gh", [
-                "pr", "create", "--draft",
-                "--base", prTarget,
-                "--head", milestoneBranch,
-                "--title", `Milestone ${milestoneId} complete`,
-                "--body", "Auto-created by GSD on milestone completion.",
-            ], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
-            prCreated = true;
-        }
-        catch (err) {
-            // PR creation failure is non-fatal — gh may not be installed or authenticated
-            logWarning("worktree", `PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (gitRemoteExists(originalBasePath_, remote)) {
+            try {
+                // Push the milestone branch to remote first
+                execFileSync("git", ["push", remote, milestoneBranch], {
+                    cwd: originalBasePath_,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    encoding: "utf-8",
+                });
+                const prEvidence = buildPrEvidence({
+                    milestoneId,
+                    milestoneTitle,
+                    changeType: "feat",
+                    summaries: completedSlices.map((slice) => `### ${slice.id}\n${slice.title}`),
+                    testsRun: ["Auto-created after milestone merge. Run `npm run verify:pr` before marking this draft ready."],
+                    rollbackNotes: ["Close the draft PR or revert the merge commit if review finds a behavior regression."],
+                    how: "Generated by git.auto_pr after the milestone branch was pushed and merged locally.",
+                });
+                const prUrl = createDraftPR(originalBasePath_, milestoneId, prEvidence.title, prEvidence.body, {
+                    head: milestoneBranch,
+                    base: prTarget,
+                });
+                if (!prUrl) {
+                    throw new Error("gh pr create returned no URL");
+                }
+                prCreated = true;
+            }
+            catch (err) {
+                // PR creation failure is non-fatal — gh may not be installed or authenticated
+                logWarning("worktree", `PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // 11. Guard removed — step 9b (#1792) now handles this with a smarter check:

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

@@ -31,7 +31,7 @@ import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-m
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
-import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
+import { preDispatchHealthGate, recordHealthSnapshot, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
@@ -43,7 +43,7 @@ import { isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
-import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
+import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, resolveProjectRoot, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
@@ -82,6 +82,7 @@ import { resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSess
 import { runAutoLoopWithUok } from "./uok/kernel.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { validateDirectory } from "./validate-directory.js";
+import { createAutoOrchestrator } from "./auto/orchestrator.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
@@ -224,8 +225,16 @@ function synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile
 export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unitId, sessionFile) {
     return synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile);
 }
+const DETACHED_AUTO_KEEPALIVE_INTERVAL_MS = 30_000;
+function withDetachedAutoKeepalive(run) {
+    const keepAlive = setInterval(() => { }, DETACHED_AUTO_KEEPALIVE_INTERVAL_MS);
+    return run.finally(() => {
+        clearInterval(keepAlive);
+    });
+}
+export const _withDetachedAutoKeepaliveForTest = withDetachedAutoKeepalive;
 export function startAutoDetached(ctx, pi, base, verboseMode, options) {
-    void startAuto(ctx, pi, base, verboseMode, options).catch((err) => {
+    void withDetachedAutoKeepalive(startAuto(ctx, pi, base, verboseMode, options)).catch((err) => {
         const message = getErrorMessage(err);
         ctx.ui.notify(`Auto-start failed: ${message}`, "error");
         logWarning("engine", `auto start error: ${message}`, { file: "auto.ts" });
@@ -904,6 +913,12 @@ export async function stopAuto(ctx, pi, reason) {
         // changes the user made between sessions (#4959 / CodeRabbit).
         if (pi)
             clearToolBaseline(pi);
+        try {
+            await s.orchestration?.stop(reason ?? "stop");
+        }
+        catch (err) {
+            debugLog("stop-orchestration-stop", { error: err instanceof Error ? err.message : String(err) });
+        }
         // Reset all session state in one call
         s.reset();
     }
@@ -953,6 +968,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             activeRunDir: s.activeRunDir,
             autoStartTime: s.autoStartTime,
             milestoneLock: s.sessionMilestoneLock ?? undefined,
+            pauseReason: _errorContext?.message,
         };
         setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, pausedMeta);
     }
@@ -992,6 +1008,12 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     // Unblock pending unitPromise so autoLoop exits cleanly (#1799)
     resolveAgentEnd({ messages: [] });
     _resetPendingResolve();
+    try {
+        await s.orchestration?.stop("pause");
+    }
+    catch (err) {
+        debugLog("pause-orchestration-stop", { error: err instanceof Error ? err.message : String(err) });
+    }
     s.active = false;
     s.paused = true;
     deactivateGSD();
@@ -1041,6 +1063,132 @@ function buildResolverDeps() {
 function buildResolver() {
     return new WorktreeResolver(s, buildResolverDeps());
 }
+/**
+ * Thin entry glue for the new Auto Orchestration module.
+ *
+ * This intentionally wires only dispatch + error notification today, with
+ * no behavior changes to the existing auto loop. It provides a concrete seam
+ * the next refactor steps can adopt incrementally.
+ */
+export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, runtimeBasePath = resolveProjectRoot(dispatchBasePath)) {
+    const flowId = `auto-orchestrator-${Date.now()}`;
+    let seq = 0;
+    const deps = {
+        dispatch: {
+            async decideNextUnit() {
+                const state = await deriveState(dispatchBasePath);
+                const active = state.activeMilestone;
+                if (!active)
+                    return null;
+                const prefs = loadEffectiveGSDPreferences(dispatchBasePath)?.preferences;
+                const action = await resolveDispatch({
+                    basePath: dispatchBasePath,
+                    mid: active.id,
+                    midTitle: active.title,
+                    state,
+                    prefs,
+                });
+                if (action.action !== "dispatch")
+                    return null;
+                return {
+                    unitType: action.unitType,
+                    unitId: action.unitId,
+                    reason: action.matchedRule ?? "dispatch",
+                    preconditions: [],
+                };
+            },
+        },
+        recovery: {
+            async classifyAndRecover(input) {
+                const reason = input.error instanceof Error ? input.error.message : String(input.error ?? "unknown auto error");
+                return { action: "escalate", reason };
+            },
+        },
+        worktree: {
+            async prepareForUnit() { },
+            async syncAfterUnit() { },
+            async cleanupOnStop() { },
+        },
+        health: {
+            async preAdvanceGate() {
+                const gate = await preDispatchHealthGate(dispatchBasePath);
+                return {
+                    allow: gate.proceed,
+                    reason: gate.reason,
+                };
+            },
+            async postAdvanceRecord(result) {
+                if (result.kind === "error") {
+                    recordHealthSnapshot(1, 0, 0, [{
+                            code: "orchestration-error",
+                            message: result.reason ?? "orchestration error",
+                            severity: "error",
+                            unitId: "orchestration",
+                        }], [], "orchestration");
+                }
+                else if (result.kind === "blocked") {
+                    recordHealthSnapshot(0, 1, 0, [{
+                            code: "orchestration-blocked",
+                            message: result.reason ?? "orchestration blocked",
+                            severity: "warning",
+                            unitId: "orchestration",
+                        }], [], "orchestration");
+                }
+            },
+        },
+        runtime: {
+            async ensureLockOwnership() {
+                const status = getSessionLockStatus(runtimeBasePath);
+                if (!status.valid || status.failureReason === "pid-mismatch") {
+                    throw new Error("session lock held by another process");
+                }
+            },
+            async journalTransition(event) {
+                const eventType = event.name === "start"
+                    ? "iteration-start"
+                    : event.name === "resume"
+                        ? "iteration-start"
+                        : event.name === "advance"
+                            ? "dispatch-match"
+                            : event.name === "advance-blocked"
+                                ? "guard-block"
+                                : event.name === "advance-stopped"
+                                    ? "dispatch-stop"
+                                    : event.name === "advance-error"
+                                        ? "iteration-end"
+                                        : event.name === "advance-paused" || event.name === "advance-retry"
+                                            ? "guard-block"
+                                            : event.name === "stop"
+                                                ? "terminal"
+                                                : "iteration-end";
+                _emitJournalEvent(runtimeBasePath, {
+                    ts: new Date().toISOString(),
+                    flowId,
+                    seq: ++seq,
+                    eventType,
+                    data: {
+                        source: "auto-orchestrator",
+                        name: event.name,
+                        reason: event.reason,
+                        unitType: event.unitType,
+                        unitId: event.unitId,
+                    },
+                });
+            },
+        },
+        notifications: {
+            async notifyLifecycle(event) {
+                if (event.name === "error") {
+                    ctx.ui.notify(event.detail ?? "auto orchestration error", "error");
+                }
+            },
+        },
+    };
+    return createAutoOrchestrator(deps);
+}
+function ensureOrchestrationModule(ctx, pi, basePath) {
+    s.orchestration = createWiredAutoOrchestrationModule(ctx, pi, basePath, lockBase());
+}
 /**
  * Build the LoopDeps object from auto.ts private scope.
  * This bundles all private functions that autoLoop needs without exporting them.
@@ -1398,6 +1546,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             // s.basePath may have been updated to a worktree path by enterMilestone.
             rebuildScope(s.basePath, s.currentMilestoneId);
         }
+        ensureOrchestrationModule(ctx, pi, s.basePath || base);
         registerSigtermHandler(lockBase());
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
@@ -1457,6 +1606,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             clearPausedSession("paused-session DB cleanup failed (resume activation)");
         }
         pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
+        try {
+            await s.orchestration?.resume();
+        }
+        catch (err) {
+            debugLog("resume-orchestration-resume", { error: err instanceof Error ? err.message : String(err) });
+        }
         startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
             ctx,
@@ -1482,6 +1637,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // Build scope after bootstrap has populated s.basePath / s.originalBasePath /
     // s.currentMilestoneId (including worktree setup inside bootstrapAutoSession).
     rebuildScope(s.basePath, s.currentMilestoneId);
+    ensureOrchestrationModule(ctx, pi, s.basePath || base);
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     registerAutoWorkerForSession(s);
     try {
@@ -1492,6 +1648,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: requestedStepMode ? "Step-mode started." : "Auto-mode started.", level: "progress" });
+    try {
+        await s.orchestration?.start({ basePath: s.basePath, trigger: "auto-loop" });
+    }
+    catch (err) {
+        debugLog("start-orchestration-start", { error: err instanceof Error ? err.message : String(err) });
+    }
     startAutoCommandPolling(s.basePath);
     // Dispatch the first unit
     await runAutoLoopWithUok({
@@ -1576,6 +1738,9 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.pendingQuickTasks = [];
     }
     s.basePath = targetBasePath;
+    if (!s.orchestration) {
+        ensureOrchestrationModule(ctx, pi, s.basePath);
+    }
     const hookUnitType = `hook/${hookName}`;
     const hookStartedAt = Date.now();
     s.currentUnit = {

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,10 +1,11 @@
+// GSD-2 + src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts - Handles provider and agent-end recovery for GSD auto-mode.
 import { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
-import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto/resolve.js";
+import { isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled } from "../auto/resolve.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
@@ -39,6 +40,19 @@ function resolveAgentEndBasePath() {
         return undefined;
     }
 }
+export function _buildAbortedPauseContext(lastMsg) {
+    const hasErrorMessage = Object.prototype.hasOwnProperty.call(lastMsg, "errorMessage") && !!lastMsg.errorMessage;
+    return {
+        message: hasErrorMessage ? String(lastMsg.errorMessage) : "Operation aborted",
+        category: "aborted",
+        isTransient: true,
+    };
+}
+export function isUserInitiatedAbortMessage(message) {
+    if (!message)
+        return false;
+    return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -134,7 +148,7 @@ export async function handleAgentEnd(pi, event, ctx) {
             }
             return;
         }
-        await pauseAuto(ctx, pi);
+        await pauseAuto(ctx, pi, _buildAbortedPauseContext(lastMsg));
         return;
     }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
@@ -142,6 +156,14 @@ export async function handleAgentEnd(pi, event, ctx) {
         // is in the assistant message text content. Fall back to content when
         // errorMessage looks uninformative.
         const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+        if (isUserInitiatedAbortMessage(rawErrorMsg)) {
+            resolveAgentEndCancelled({
+                message: rawErrorMsg,
+                category: "aborted",
+                isTransient: false,
+            });
+            return;
+        }
         const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
         // #3588: When errorMessage is uninformative, extract the real error from
         // the assistant message text content for display purposes only.

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Registers DB-backed GSD workflow tools and compatibility aliases.
 import { Type } from "@sinclair/typebox";
 import { Text } from "@gsd/pi-tui";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
@@ -5,6 +7,7 @@ import { ensureDbOpen } from "./dynamic-tools.js";
 import { loadWriteGateSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "./write-gate.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
+import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 async function loadWorkflowExecutors() {
     return import("../tools/workflow-tool-executors.js");
 }
@@ -14,11 +17,18 @@ async function loadWorkflowExecutors() {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- toolDef shape matches ToolDefinition but typing it fully requires generics
 function registerAlias(pi, toolDef, aliasName, canonicalName) {
+    const execute = typeof toolDef.execute === "function"
+        ? async (...args) => {
+            incrementLegacyTelemetry("legacy.mcpAliasUsed");
+            return toolDef.execute(...args);
+        }
+        : toolDef.execute;
     pi.registerTool({
         ...toolDef,
         name: aliasName,
         description: toolDef.description + ` (alias for ${canonicalName} — prefer the canonical name)`,
         promptGuidelines: [`Alias for ${canonicalName} — prefer the canonical name.`],
+        execute,
     });
 }
 function requirementRootWriteGuard(operation) {

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

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
-import { canonicalToolName, clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markApprovalGateVerified, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
+import { canonicalToolName, clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markApprovalGateVerified, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, shouldBlockWorktreeWrite, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
@@ -16,6 +16,7 @@ import { logWarning as safetyLogWarning } from "../workflow-logger.js";
 import { installNotifyInterceptor } from "./notify-interceptor.js";
 import { initNotificationStore } from "../notification-store.js";
 import { initNotificationWidget } from "../notification-widget.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { extractSubagentAgentClasses } from "./subagent-input.js";
 import { approvalGateIdForUnit, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
@@ -51,6 +52,14 @@ async function applyDisabledModelProviderPolicy(ctx) {
         // Non-fatal: keep default provider visibility if preferences cannot be loaded.
     }
 }
+export function resolveNotificationStoreBasePath(cwd = process.cwd()) {
+    return resolveWorktreeProjectRoot(cwd);
+}
+function initSessionNotifications(ctx) {
+    initNotificationStore(resolveNotificationStoreBasePath());
+    installNotifyInterceptor(ctx);
+    initNotificationWidget(ctx);
+}
 async function writeContextModeCompactionSnapshot(basePath) {
     try {
         const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -81,9 +90,7 @@ async function writeContextModeCompactionSnapshot(basePath) {
 }
 export function registerHooks(pi, ecosystemHandlers) {
     pi.on("session_start", async (_event, ctx) => {
-        initNotificationStore(process.cwd());
-        installNotifyInterceptor(ctx);
-        initNotificationWidget(ctx);
+        initSessionNotifications(ctx);
         if (!isAutoActive()) {
             const { initHealthWidget } = await import("../health-widget.js");
             initHealthWidget(ctx);
@@ -135,8 +142,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
     });
     pi.on("session_switch", async (_event, ctx) => {
-        initNotificationStore(process.cwd());
-        installNotifyInterceptor(ctx);
+        initSessionNotifications(ctx);
         resetWriteGateState(process.cwd());
         resetToolCallLoopGuard();
         await resetAskUserQuestionsTurnCache();
@@ -426,6 +432,16 @@ export function registerHooks(pi, ecosystemHandlers) {
                     return planningGuard;
             }
         }
+        // ── Worktree-isolation write gate (#5199) ────────────────────────────
+        // Block planning-write tools from landing code at the project root when
+        // git.isolation=worktree but auto-mode hasn't created the milestone
+        // worktree yet. Without this, writes silently orphan outside git history.
+        if (isToolCallEventType("write", event) || isToolCallEventType("edit", event)) {
+            const wtBasePath = resolveWorktreeProjectRoot(dash.basePath ?? discussionBasePath);
+            const wtGuard = shouldBlockWorktreeWrite(event.toolName, event.input.path, wtBasePath, isAutoActive(), dash.currentUnit?.type);
+            if (wtGuard.block)
+                return wtGuard;
+        }
         // ── Single-writer engine: block direct writes to STATE.md ──────────
         // Covers write, edit, and bash tools to prevent bypass vectors.
         if (isToolCallEventType("write", event)) {