gsd-pi 2.82.0-dev.3709f22a5 → 2.82.0-dev.57fd453e4

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

@@ -689,6 +689,8 @@ export async function rerootCommandSession(cmdCtx, workspaceRoot) {
     }
 }
 export async function cleanupAfterLoopExit(ctx) {
+    const preserveStepSurface = s.preserveStepSurfaceAfterLoopExit;
+    const preservePausedSurface = s.paused;
     s.currentUnit = null;
     s.active = false;
     deactivateGSD();
@@ -712,19 +714,24 @@ export async function cleanupAfterLoopExit(ctx) {
     // A transient provider-error pause intentionally leaves the paused badge
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {
-        ctx.ui.setStatus("gsd-auto", undefined);
-        ctx.ui.setWidget("gsd-progress", undefined);
-        if (s.completionStopInProgress) {
-            s.completionStopInProgress = false;
+        if (preserveStepSurface) {
+            s.preserveStepSurfaceAfterLoopExit = false;
+        }
+        else {
+            ctx.ui.setStatus("gsd-auto", undefined);
+            ctx.ui.setWidget("gsd-progress", undefined);
+            if (s.completionStopInProgress) {
+                s.completionStopInProgress = false;
+            }
+            initHealthWidget(ctx);
         }
-        initHealthWidget(ctx);
     }
     // ADR-016 phase 3 (#5693): the stop-path basePath restore + chdir routes
     // through `Lifecycle.restoreToProjectRoot()`, the sole owner of both
     // `s.basePath` mutation and the paired `process.chdir` for auto-loop
     // transitions. The verb assigns `s.basePath` before any throwable work, so
     // a thrown error still leaves basePath restored.
-    if (s.originalBasePath) {
+    if (s.originalBasePath && !preserveStepSurface && !preservePausedSurface) {
         try {
             buildLifecycle().restoreToProjectRoot();
         }
@@ -732,7 +739,7 @@ export async function cleanupAfterLoopExit(ctx) {
             logWarning("engine", `restore project root failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
-    if (s.originalBasePath && s.cmdCtx) {
+    if (s.originalBasePath && s.cmdCtx && !preserveStepSurface && !preservePausedSurface) {
         const result = await rerootCommandSession(s.cmdCtx, s.originalBasePath);
         if (result.status === "cancelled") {
             logWarning("engine", "post-loop session re-root was cancelled", { file: "auto.ts", basePath: s.originalBasePath });
@@ -1325,7 +1332,6 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";

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

@@ -61,6 +61,11 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg) {
+    if (!isTransient(cls) || cls.kind === "rate-limit")
+        return false;
+    return !/retry failed after \d+ attempts:/i.test(rawErrorMsg);
+}
 function isBareClaudeCodeSessionSwitchAbortMarker(message) {
     if (!message)
         return false;
@@ -394,7 +399,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
         // but let rate-limit continue into model fallback logic below (#4373).
-        if (isTransient(cls) && cls.kind !== "rate-limit") {
+        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg)) {
             return;
         }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)

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

@@ -848,7 +848,7 @@ export function registerDbTools(pi) {
         name: "gsd_skip_slice",
         label: "Skip Slice",
         description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
-            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks (#4375). " +
+            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks. " +
             "The slice data is preserved for reference. The state machine treats skipped slices like completed ones for dependency satisfaction.",
         promptSnippet: "Skip a GSD slice (mark as skipped, auto-mode will advance past it)",
         promptGuidelines: [

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -625,7 +625,7 @@ function matchesAllowedGlob(absPath, basePath, globs) {
 function blockReason(unitType, mode, what) {
     return [
         `HARD BLOCK: unit "${unitType}" runs under tools-policy "${mode}" — ${what}.`,
-        `This is a mechanical gate enforced by manifest.tools (#4934). You MUST NOT proceed,`,
+        `This is a mechanical gate enforced by manifest.tools. You MUST NOT proceed,`,
         `retry the same call, or rationalize past this block. If you need to write user source,`,
         `the work belongs in execute-task, not in a planning unit.`,
     ].join(" ");

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -571,10 +571,15 @@ async function configureModels(ctx, prefs) {
     ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
-    if (availableModels.length > 0) {
+    const getAllWithDiscovered = ctx.modelRegistry.getAllWithDiscovered;
+    const availableProviders = new Set(availableModels.map((m) => m.provider));
+    const selectableModels = typeof getAllWithDiscovered === "function"
+        ? getAllWithDiscovered().filter((m) => availableProviders.has(m.provider))
+        : availableModels;
+    if (selectableModels.length > 0) {
         // Group models by provider, sorted alphabetically
         const byProvider = new Map();
-        for (const m of availableModels) {
+        for (const m of selectableModels) {
             let group = byProvider.get(m.provider);
             if (!group) {
                 group = [];

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

@@ -23,7 +23,8 @@
 import { emitJournalEvent, queryJournal, } from "./journal.js";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, } from "./db/auto-workers.js";
+import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, markWorkerStopping, } from "./db/auto-workers.js";
+import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
@@ -182,10 +183,21 @@ export function clearLock(basePath) {
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
-        const worker = findActiveWorkerForCurrentProcess(projectRoot);
-        if (!worker)
+        const staleWorker = findStaleWorkerForProject(projectRoot);
+        if (staleWorker) {
+            markWorkerCrashed(staleWorker.worker_id);
+            forceReleaseLeasesForWorker(staleWorker.worker_id);
+            deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
             return;
-        deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        }
+        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        if (worker)
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        const stale = findStaleWorkerForProject(projectRoot);
+        if (stale) {
+            markWorkerStopping(stale.worker_id);
+            deleteRuntimeKv("worker", stale.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort.

package/dist/resources/extensions/gsd/db/milestone-leases.js

@@ -193,6 +193,30 @@ export function releaseMilestoneLease(workerId, milestoneId, fencingToken) {
         return changes === 1;
     });
 }
+/**
+ * Force-release all held leases for a worker.
+ *
+ * Used by crash recovery once PID liveness has confirmed the worker is dead.
+ * No fencing token is required because this path is cleanup-only for a
+ * non-running process.
+ */
+export function forceReleaseLeasesForWorker(workerId) {
+    if (!isDbAvailable())
+        return 0;
+    const db = _getAdapter();
+    let changes = 0;
+    transaction(() => {
+        const result = db.prepare(`UPDATE milestone_leases
+       SET status = 'released'
+       WHERE worker_id = :worker_id
+         AND status = 'held'`).run({ ":worker_id": workerId });
+        changes =
+            typeof result.changes === "number"
+                ? result.changes
+                : 0;
+    });
+    return changes;
+}
 /**
  * Read current lease row for diagnostics. Returns null if no row exists.
  */

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

@@ -677,7 +677,7 @@ export function detectWorktreeOrphans(summary, anomalies) {
             type: "worktree-unmerged-exit",
             severity: "warning",
             summary: `${summary.exitsWithUnmergedWork} auto-exit(s) left milestone work unmerged`,
-            details: `Exit reasons: ${reasonBreakdown || "(none)"} · Producer-side signal for #4761-class orphans. Inspect .gsd/journal/*.jsonl with eventType:"auto-exit" for per-exit detail.`,
+            details: `Exit reasons: ${reasonBreakdown || "(none)"} · Producer-side signal for orphaned worktrees. Inspect .gsd/journal/*.jsonl with eventType:"auto-exit" for per-exit detail.`,
         });
     }
 }
@@ -884,7 +884,7 @@ function saveForensicReport(basePath, report, problemDescription) {
                 .map(([r, n]) => `${r}=${n}`).join(", ");
             sections.push(`  - Exit reasons: ${breakdown}`);
         }
-        sections.push(`- Canonical-root redirects (#4761 fix fired): ${t.canonicalRedirects}`);
+        sections.push(`- Canonical-root redirects: ${t.canonicalRedirects}`);
         // #4765 slice-cadence counters
         if (t.slicesMerged + t.sliceMergeConflicts + t.milestoneResquashes > 0) {
             sections.push(`- Slices merged: ${t.slicesMerged} · Slice merge conflicts: ${t.sliceMergeConflicts}`);
@@ -1033,7 +1033,7 @@ function formatReportForPrompt(report) {
         if (hasSignal) {
             sections.push("### Worktree Telemetry");
             sections.push(`- Created: ${t.worktreesCreated} · Merged: ${t.worktreesMerged} · Conflicts: ${t.mergeConflicts}`);
-            sections.push(`- Orphans: ${t.orphansDetected} · Unmerged exits: ${t.exitsWithUnmergedWork} · Redirects (#4761): ${t.canonicalRedirects}`);
+            sections.push(`- Orphans: ${t.orphansDetected} · Unmerged exits: ${t.exitsWithUnmergedWork} · Redirects: ${t.canonicalRedirects}`);
             if (t.orphansDetected > 0) {
                 const breakdown = Object.entries(t.orphansByReason)
                     .map(([r, n]) => `${r}=${n}`).join(", ");

package/dist/resources/extensions/gsd/git-service.js

@@ -237,6 +237,8 @@ export function readIntegrationBranch(basePath, milestoneId) {
         return null;
     }
 }
+/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
+export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 /**
  * Persist the integration branch for a milestone.
  *
@@ -247,9 +249,11 @@ export function readIntegrationBranch(basePath, milestoneId) {
  *
  * The file is committed immediately so the metadata is persisted in git.
  */
-/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
-export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 export function writeIntegrationBranch(basePath, milestoneId, branch) {
+    // Never persist milestone branches as integration targets.
+    // They are ephemeral execution branches and can cause self-diff corruption.
+    if (branch.startsWith("milestone/"))
+        return;
     // Don't record slice branches as the integration target
     if (SLICE_BRANCH_RE.test(branch))
         return;

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

@@ -54,18 +54,19 @@ const providerLoader = createSqliteProviderLoader({
     writeStderr: (message) => process.stderr.write(message),
 });
 export const SCHEMA_VERSION = 28;
-function initSchema(db, fileBacked) {
+function initSchema(db, fileBacked, dbPath) {
+    const conservativeFilePragmas = fileBacked && _isLikelyWslDrvFsPathForTest(dbPath);
     if (fileBacked)
-        db.exec("PRAGMA journal_mode=WAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA journal_mode=DELETE" : "PRAGMA journal_mode=WAL");
     if (fileBacked)
         db.exec("PRAGMA busy_timeout = 5000");
     if (fileBacked)
-        db.exec("PRAGMA synchronous = NORMAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA synchronous = FULL" : "PRAGMA synchronous = NORMAL");
     if (fileBacked)
         db.exec("PRAGMA auto_vacuum = INCREMENTAL");
     if (fileBacked)
         db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
-    if (fileBacked && process.platform !== "darwin")
+    if (fileBacked && !conservativeFilePragmas && process.platform !== "darwin")
         db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
     db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
@@ -99,6 +100,19 @@ function initSchema(db, fileBacked) {
     }
     migrateSchema(db);
 }
+export function _isLikelyWslDrvFsPathForTest(dbPath) {
+    if (!dbPath || process.platform !== "linux")
+        return false;
+    const drvFsPathPattern = /^\/mnt\/[a-z](?:\/|$)/i;
+    if (drvFsPathPattern.test(dbPath))
+        return true;
+    try {
+        return drvFsPathPattern.test(realpathSync(dbPath));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Create the FTS5 virtual table for memories plus the triggers that keep it
  * in sync with the base table. FTS5 may be unavailable on stripped-down
@@ -504,7 +518,7 @@ export function openDatabase(path) {
     const adapter = createDbAdapter(rawDb);
     const fileBacked = path !== ":memory:";
     try {
-        initSchema(adapter, fileBacked);
+        initSchema(adapter, fileBacked, path);
     }
     catch (err) {
         // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
@@ -512,7 +526,7 @@ export function openDatabase(path) {
         if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
             try {
                 adapter.exec("VACUUM");
-                initSchema(adapter, fileBacked);
+                initSchema(adapter, fileBacked, path);
                 process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
             }
             catch (retryErr) {

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -18,6 +18,7 @@ import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
+import { isFutureMilestoneStatus } from "./status-guards.js";
 // ─── Queue Entry Point ──────────────────────────────────────────────────────
 /**
  * Queue future milestones via conversational intake.
@@ -48,7 +49,7 @@ export async function showQueue(ctx, pi, basePath) {
         return;
     }
     // ── Count pending milestones ────────────────────────────────────────
-    const pendingMilestones = state.registry.filter(m => m.status === "pending" || m.status === "active");
+    const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status) || m.status === "active");
     const completeCount = state.registry.filter(m => m.status === "complete").length;
     const parkedCount = state.registry.filter(m => m.status === "parked").length;
     // ── If multiple pending milestones, show queue management hub ──────
@@ -140,7 +141,7 @@ export async function showQueueAdd(ctx, pi, basePath, state) {
     const activePart = state.activeMilestone
         ? `Currently executing: ${state.activeMilestone.id} — ${state.activeMilestone.title} (phase: ${state.phase}).`
         : "No milestone currently active.";
-    const pendingCount = state.registry.filter(m => m.status === "pending").length;
+    const pendingCount = state.registry.filter(m => isFutureMilestoneStatus(m.status)).length;
     const completeCount = state.registry.filter(m => m.status === "complete").length;
     const preamble = [
         `Queuing new work onto an existing GSD project.`,
@@ -223,7 +224,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
         }
         // For active/pending/parked milestones, include the roadmap if it exists
         // (shows what's planned but not yet built)
-        if (status === "active" || status === "pending" || status === "parked") {
+        if (status === "active" || isFutureMilestoneStatus(status) || status === "parked") {
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
             if (roadmapFile) {
                 const content = await loadFile(roadmapFile);

package/dist/resources/extensions/gsd/guided-flow.js

@@ -30,6 +30,7 @@ import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js"
 import { resolveUokFlags } from "./uok/flags.js";
 import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "./uok/plan-v2.js";
 import { detectProjectState, hasGsdBootstrapArtifacts } from "./detection.js";
+import { isFutureMilestoneStatus } from "./status-guards.js";
 import { showProjectInit, offerMigration } from "./init-wizard.js";
 import { validateDirectory } from "./validate-directory.js";
 import { showConfirm } from "../shared/tui.js";
@@ -811,6 +812,7 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType,
                     ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
                     : undefined,
             baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
+            activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
         });
         if (compatibilityError) {
             ctx.ui.notify(compatibilityError, "error");
@@ -1164,7 +1166,7 @@ export async function showDiscuss(ctx, pi, basePath) {
     // No active milestone (or corrupted milestone with undefined id) —
     // check for pending milestones to discuss instead
     if (!state.activeMilestone?.id) {
-        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
         if (pendingMilestones.length === 0) {
             ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
             return;
@@ -1269,7 +1271,7 @@ export async function showDiscuss(ctx, pi, basePath) {
     const pendingSlices = normSlices.filter(s => !s.done);
     if (pendingSlices.length === 0) {
         // All slices complete — but queued milestones may still need discussion (#3150)
-        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
         if (pendingMilestones.length > 0) {
             await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
             return;
@@ -1290,7 +1292,7 @@ export async function showDiscuss(ctx, pi, basePath) {
         // If all pending slices are discussed, check for queued milestones before exiting (#3150)
         const allDiscussed = pendingSlices.every(s => discussedMap.get(s.id));
         if (allDiscussed) {
-            const pendingMilestones = state.registry.filter(m => m.status === "pending");
+            const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
             if (pendingMilestones.length > 0) {
                 await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
                 return;
@@ -1321,7 +1323,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             };
         });
         // Offer access to queued milestones when any exist
-        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
         if (pendingMilestones.length > 0) {
             actions.push({
                 id: "discuss_queued_milestone",
@@ -1385,10 +1387,11 @@ async function showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones)
         const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
         const hasDraft = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
         const contextStatus = hasContext ? "context ✓" : hasDraft ? "draft context" : "no context yet";
+        const statusLabel = m.status === "planned" ? "planned" : "queued";
         return {
             id: m.id,
             label: `${m.id}: ${m.title}`,
-            description: `[queued] · ${contextStatus}`,
+            description: `[${statusLabel}] · ${contextStatus}`,
             recommended: i === 0,
         };
     });

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -14,7 +14,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, gsdProjectionRoot, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
 import { saveFile, clearParseCache } from "./files.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
@@ -24,7 +24,11 @@ import { clearPathCache } from "./paths.js";
  * E.g. "/project/.gsd/milestones/M001/M001-ROADMAP.md" → "milestones/M001/M001-ROADMAP.md"
  */
 function toArtifactPath(absPath, basePath) {
-    const root = gsdRoot(basePath);
+    const projectionRoot = gsdProjectionRoot(basePath);
+    const projectionRel = relative(projectionRoot, absPath);
+    const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
+        ? projectionRoot
+        : gsdRoot(basePath);
     const rel = relative(root, absPath);
     // Normalize to forward slashes for consistent DB keys
     return rel.replace(/\\/g, "/");
@@ -305,10 +309,9 @@ export async function renderPlanFromDb(basePath, milestoneId, sliceId) {
     if (tasks.length === 0) {
         throw new Error(`no tasks found for ${milestoneId}/${sliceId}`);
     }
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId);
-    const absPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN")
-        ?? join(slicePath, `${sliceId}-PLAN.md`);
+    const slicePath = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId);
+    mkdirSync(slicePath, { recursive: true });
+    const absPath = join(slicePath, `${sliceId}-PLAN.md`);
     const artifactPath = toArtifactPath(absPath, basePath);
     const sliceGates = getGateResults(milestoneId, sliceId, "slice");
     const content = renderSlicePlanMarkdown(slice, tasks, sliceGates);
@@ -329,8 +332,7 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     if (!task) {
         throw new Error(`task ${milestoneId}/${sliceId}/${taskId} not found`);
     }
-    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
+    const tasksDir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
     mkdirSync(tasksDir, { recursive: true });
     const absPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
     const artifactPath = toArtifactPath(absPath, basePath);

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

@@ -320,6 +320,10 @@ export function resolveGsdPathContract(workRoot, originalProjectRoot) {
         isWorktree,
     };
 }
+export function gsdProjectionRoot(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    return normalizeRealPath(contract.worktreeGsd ?? contract.projectGsd);
+}
 /**
  * Invalidate the gsdRoot cache.
  * Use ONLY at session-reset boundaries: workspace switch, process exit, or

package/dist/resources/extensions/gsd/queue-reorder-ui.js

@@ -24,6 +24,7 @@ export async function showQueueReorder(ctx, completed, pending) {
         const items = [...pending];
         let cursor = 0;
         let grabbed = false;
+        let scrollOffset = 0;
         let cachedLines;
         let validation;
         // Mutable deps map — tracks removals during this session
@@ -128,9 +129,11 @@ export async function showQueueReorder(ctx, completed, pending) {
                 return cachedLines;
             const ui = makeUI(theme, width);
             const lines = [];
+            const queueRows = [];
             const push = (...rows) => { for (const r of rows)
                 lines.push(...r); };
             const add = (s) => truncateToWidth(s, width);
+            let cursorQueueRow = 0;
             const headerText = grabbed ? "  Queue Reorder — Moving Item" : "  Queue Reorder";
             push(ui.bar(), ui.blank(), ui.header(headerText), ui.blank());
             // Completed milestones (dimmed)
@@ -153,13 +156,15 @@ export async function showQueueReorder(ctx, completed, pending) {
                 const num = i + 1;
                 const label = item.title && item.title !== item.id ? `${item.id}  ${item.title}` : item.id;
                 if (isCursor && grabbed) {
-                    lines.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
+                    cursorQueueRow = queueRows.length;
+                    queueRows.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
                 }
                 else if (isCursor) {
-                    lines.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
+                    cursorQueueRow = queueRows.length;
+                    queueRows.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
                 }
                 else {
-                    lines.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
+                    queueRows.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
                 }
                 // depends_on annotations
                 const deps = liveDeps.get(item.id) ?? [];
@@ -168,34 +173,35 @@ export async function showQueueReorder(ctx, completed, pending) {
                         continue;
                     const pairKey = `${item.id}:${dep}`;
                     if (violatedPairs.has(pairKey)) {
-                        lines.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
+                        queueRows.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
                     }
                     else if (redundantPairs.has(pairKey)) {
-                        lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
+                        queueRows.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
                     }
                     else {
-                        lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
+                        queueRows.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
                     }
                 }
                 // Missing deps
                 for (const v of validation.violations.filter(v => v.milestone === item.id && v.type === 'missing_dep')) {
-                    lines.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
+                    queueRows.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
                 }
             }
             // Removed deps feedback
+            const trailingLines = [];
             if (removedDeps.length > 0) {
-                push(ui.blank());
+                trailingLines.push(...ui.blank());
                 for (const r of removedDeps) {
-                    lines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
+                    trailingLines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
                 }
             }
             // Circular warning
             const circ = validation.violations.find(v => v.type === 'circular');
             if (circ) {
-                push(ui.blank());
-                lines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
+                trailingLines.push(...ui.blank());
+                trailingLines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
             }
-            push(ui.blank());
+            trailingLines.push(...ui.blank());
             // Hints — context-sensitive based on grab state
             const hints = [];
             if (grabbed) {
@@ -215,7 +221,18 @@ export async function showQueueReorder(ctx, completed, pending) {
                 hints.push("enter ok");
             }
             hints.push("esc");
-            push(ui.hints(hints), ui.bar());
+            trailingLines.push(...ui.hints(hints), ...ui.bar());
+            const maxOverlayRows = Math.max(10, process.stdout.rows ? Math.floor(process.stdout.rows * 0.8) : 24);
+            const availableQueueRows = Math.max(1, maxOverlayRows - lines.length - trailingLines.length);
+            const maxScroll = Math.max(0, queueRows.length - availableQueueRows);
+            if (cursorQueueRow < scrollOffset) {
+                scrollOffset = cursorQueueRow;
+            }
+            else if (cursorQueueRow >= scrollOffset + availableQueueRows) {
+                scrollOffset = cursorQueueRow - availableQueueRows + 1;
+            }
+            scrollOffset = Math.min(Math.max(scrollOffset, 0), maxScroll);
+            lines.push(...queueRows.slice(scrollOffset, scrollOffset + availableQueueRows), ...trailingLines);
             cachedLines = lines;
             return lines;
         }

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

@@ -1253,7 +1253,7 @@ export async function _deriveStateImpl(basePath, opts) {
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             t.done = true;
-            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
+            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
         }
     }
     const taskProgress = {

package/dist/resources/extensions/gsd/status-guards.js

@@ -26,3 +26,10 @@ export function isInactiveStatus(status) {
 export function isSkippedForDispatch(status) {
     return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
 }
+/**
+ * Returns true when a milestone is future/backlog work (not currently executing).
+ * Includes legacy/project-specific alias "planned" for compatibility.
+ */
+export function isFutureMilestoneStatus(status) {
+    return status === "pending" || status === "queued" || status === "planned";
+}

package/dist/resources/extensions/gsd/templates/plan.md

@@ -132,6 +132,7 @@
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
   - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
+  - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -57,6 +57,12 @@ skills_used:
 - {{howToVerifyThisTaskIsActuallyDone}}
 - {{commandToRun_OR_behaviorToCheck}}
 
+## Verify Rules
+
+- Use a real executable check, not prose.
+- If the check needs file-content assertions, write a `node:test` file and run it with `node --test` or a package test script.
+- Do not use inline `node -e` assertions for verification.
+
 ## Observability Impact
 
 <!-- OMIT THIS SECTION ENTIRELY for simple tasks that don't touch runtime boundaries,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -12,7 +12,7 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePlanningPathScope } from "../planning-path-scope.js";
 import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
-import { buildTaskFileName, gsdRoot, resolveTasksDir } from "../paths.js";
+import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -241,14 +241,12 @@ export async function handlePlanSlice(rawParams, basePath) {
         return { error: guardError };
     }
     try {
-        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+        const tasksDir = join(gsdProjectionRoot(basePath), "milestones", params.milestoneId, "slices", params.sliceId, "tasks");
         for (const taskId of omittedTaskIds) {
-            if (!tasksDir)
-                continue;
             const taskPlanPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
             if (existsSync(taskPlanPath))
                 rmSync(taskPlanPath, { force: true });
-            const artifactPath = relative(gsdRoot(basePath), taskPlanPath).replace(/\\/g, "/");
+            const artifactPath = relative(gsdProjectionRoot(basePath), taskPlanPath).replace(/\\/g, "/");
             deleteArtifactByPath(artifactPath);
         }
         const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);