gsd-pi 2.79.0 → 2.80.0-dev.0aaa4fc17

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

@@ -16,7 +16,7 @@ import { invalidateAllCaches } from "./cache.js";
 import { startAutoDetached } from "./auto.js";
 import { clearLock } from "./crash-recovery.js";
 import { assessInterruptedSession, formatInterruptedSessionRunningMessage, formatInterruptedSessionSummary, } from "./interrupted-session.js";
-import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
+import { listUnitRuntimeRecords, clearUnitRuntimeRecord, isInFlightRuntimePhase } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
 import { gsdHome } from "./gsd-home.js";
 import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
@@ -44,6 +44,7 @@ import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
+import { getPendingGate, extractDepthVerificationMilestoneId } from "./bootstrap/write-gate.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -70,6 +71,19 @@ export function verifyExpectedArtifactForScope(scope, unitType, unitId) {
 export function resolveExpectedArtifactPathForScope(scope, unitType, unitId) {
     return resolveExpectedArtifactPath(unitType, unitId, scope.workspace.projectRoot);
 }
+async function runQuickTaskChoice(ctx, pi) {
+    if (!ctx.hasUI) {
+        ctx.ui.notify("Run /gsd quick <task> for small bounded work, or /gsd do <task> for natural-language routing.", "info");
+        return;
+    }
+    const task = (await ctx.ui.input("Quick task", "Describe the small task to run with /gsd quick"))?.trim();
+    if (!task) {
+        ctx.ui.notify("Quick task cancelled.", "info");
+        return;
+    }
+    const { handleQuick } = await import("./quick.js");
+    await handleQuick(task, ctx, pi);
+}
 /**
  * Scope-based overload of isGhostMilestone.
  * Binds basePath and milestoneId from the scope, ensuring path resolution
@@ -295,6 +309,14 @@ export async function checkDeepProjectSetupAfterTurn(_event, ctx, basePath) {
             return false;
         }
     }
+    // R2: a depth-verification gate is still pending — the LLM emitted the
+    // confirmation question (via ask_user_questions or plain chat) but the user
+    // has not approved yet. Returning false keeps the entry in the
+    // pendingDeepProjectSetupMap so the next user message can resume.
+    const pendingGateId = getPendingGate(entry.basePath);
+    if (pendingGateId) {
+        return false;
+    }
     return dispatchNextDeepProjectSetupStage(entry);
 }
 async function dispatchNextDeepProjectSetupStage(entry) {
@@ -368,6 +390,23 @@ export function checkAutoStartAfterDiscuss() {
     const roadmapFile = existsSync(roadmapFilePath) ? roadmapFilePath : null;
     if (!contextFile && !roadmapFile)
         return false; // neither artifact yet — keep waiting
+    // Gate 1a: a depth-verification gate is still pending for THIS milestone — the
+    // LLM emitted the confirmation question (via ask_user_questions or plain chat)
+    // but the user has not answered yet. Advancing now would skip the gate and
+    // race ahead with unverified context.
+    const basePathForGate = entry.scope.workspace.projectRoot;
+    const pendingGateId = getPendingGate(basePathForGate);
+    if (pendingGateId) {
+        const pendingMilestoneId = extractDepthVerificationMilestoneId(pendingGateId);
+        // Block advancement if the gate is for THIS milestone, OR if it's a
+        // project/requirements gate (no milestone id encoded) for the deep setup flow.
+        const isProjectGate = pendingGateId === "depth_verification_project_confirm" ||
+            pendingGateId === "depth_verification_requirements_confirm" ||
+            pendingGateId === "depth_verification_research_decision_confirm";
+        if (pendingMilestoneId === milestoneId || isProjectGate) {
+            return false;
+        }
+    }
     // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
     // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
     // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
@@ -489,6 +528,20 @@ export function checkAutoStartAfterDiscuss() {
             logWarning("guided", `manifest unlink failed: ${e.message}`);
         }
     }
+    // R3b: belt-and-suspenders for silent registration failure. The discuss flow
+    // finished and STATE.md exists, but the milestone may never have landed in
+    // the DB. Without this guard, the user sees "Milestone M001 ready." and then
+    // /gsd reports "No Active Milestone".
+    if (isDbAvailable()) {
+        const milestoneRow = getMilestone(milestoneId);
+        if (!milestoneRow) {
+            ctx.ui.notify(`Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
+                `PROJECT.md may have failed to register milestones. ` +
+                `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
+                `then re-run /gsd to recover.`, "error");
+            return false;
+        }
+    }
     pendingAutoStartMap.delete(basePath);
     ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
     startAutoDetached(ctx, pi, basePath, false, { step });
@@ -1429,8 +1482,8 @@ function selfHealRuntimeRecords(basePath, ctx) {
                 cleared++;
                 continue;
             }
-            // Clear records stuck in dispatched or timeout phase (process died mid-unit)
-            if (phase === "dispatched" || phase === "timeout") {
+            // Clear records stuck in an in-flight phase (process died mid-unit).
+            if (isInFlightRuntimePhase(phase)) {
                 clearUnitRuntimeRecord(basePath, unitType, unitId);
                 cleared++;
             }
@@ -1655,6 +1708,20 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             return;
         }
     }
+    if (interrupted.classification !== "recoverable") {
+        try {
+            const { autoImportMarkdownHierarchyIfDbMismatch } = await import("./migration-auto-check.js");
+            const result = await autoImportMarkdownHierarchyIfDbMismatch(basePath);
+            if (result.action === "imported") {
+                ctx.ui.notify(`Recovered migrated planning state into gsd.db (${result.reason}): ${result.afterDb.milestones} milestone(s), ${result.afterDb.slices} slice(s), ${result.afterDb.tasks} task(s).`, "info");
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`GSD could not auto-import existing planning state into gsd.db: ${message}`, "warning");
+            logWarning("guided", `planning state auto-import failed: ${message}`, { file: "guided-flow.ts" });
+        }
+    }
     // Always derive from the project root — the assessment may have derived
     // state from a worktree path that was cleaned up in the stale branch above.
     const state = await deriveState(basePath);
@@ -1676,8 +1743,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     // standard wizard below.
     {
         const prefs = loadEffectiveGSDPreferences(basePath)?.preferences;
-        const { hasPendingDeepStage } = await import("./auto-dispatch.js");
-        if (hasPendingDeepStage(prefs, basePath)) {
+        const { shouldRunDeepProjectSetup } = await import("./auto-dispatch.js");
+        if (shouldRunDeepProjectSetup(state, prefs, basePath)) {
             await startDeepProjectSetupForeground(ctx, pi, basePath, stepMode);
             return;
         }
@@ -1740,16 +1807,24 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 title: "GSD — Get Shit Done",
                 summary: ["No active milestone."],
                 actions: [
+                    {
+                        id: "quick_task",
+                        label: "Quick task",
+                        description: "For small bounded work, run /gsd quick <task> or /gsd do <task>.",
+                        recommended: true,
+                    },
                     {
                         id: "new_milestone",
                         label: "Create next milestone",
-                        description: "Define what to build next.",
-                        recommended: true,
+                        description: "Define a larger body of work with planning artifacts.",
                     },
                 ],
                 notYetMessage: "Run /gsd when ready.",
             });
-            if (choice === "new_milestone") {
+            if (choice === "quick_task") {
+                await runQuickTaskChoice(ctx, pi);
+            }
+            else if (choice === "new_milestone") {
                 setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
                 await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
@@ -1769,11 +1844,16 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             title: `GSD — ${milestoneId}: ${milestoneTitle}`,
             summary: ["All milestones complete."],
             actions: [
+                {
+                    id: "quick_task",
+                    label: "Quick task",
+                    description: "Do a small bounded task without opening a milestone.",
+                    recommended: true,
+                },
                 {
                     id: "new_milestone",
                     label: "Start new milestone",
                     description: "Define and plan the next milestone.",
-                    recommended: true,
                 },
                 {
                     id: "status",
@@ -1783,7 +1863,10 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             ],
             notYetMessage: "Run /gsd when ready.",
         });
-        if (choice === "new_milestone") {
+        if (choice === "quick_task") {
+            await runQuickTaskChoice(ctx, pi);
+        }
+        else if (choice === "new_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
@@ -1876,13 +1959,18 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
             const hasContext = !!(contextFile && await loadFile(contextFile));
             const actions = [
+                {
+                    id: "quick_task",
+                    label: "Quick task instead",
+                    description: "Use this when the work is small and should not become a milestone.",
+                    recommended: true,
+                },
                 {
                     id: "plan",
                     label: "Create roadmap",
                     description: hasContext
                         ? "Context captured. Decompose into slices with a boundary map."
                         : "Decompose the milestone into slices with a boundary map.",
-                    recommended: true,
                 },
                 ...(!hasContext ? [{
                         id: "discuss",
@@ -1906,7 +1994,10 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 actions,
                 notYetMessage: "Run /gsd when ready.",
             });
-            if (choice === "plan") {
+            if (choice === "quick_task") {
+                await runQuickTaskChoice(ctx, pi);
+            }
+            else if (choice === "plan") {
                 setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
                 await dispatchWorkflow(pi, await buildPlanMilestonePrompt(milestoneId, milestoneTitle, basePath), "gsd-run", ctx, "plan-milestone");
             }

package/dist/resources/extensions/gsd/legacy-telemetry.js

@@ -0,0 +1,70 @@
+// Project/App: GSD-2
+// File Purpose: Runtime counters for telemetry-gated legacy compatibility paths.
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { logWarning } from "./workflow-logger.js";
+const COUNTERS = [
+    "legacy.markdownFallbackUsed",
+    "legacy.workflowEngineUsed",
+    "legacy.uokFallbackUsed",
+    "legacy.mcpAliasUsed",
+    "legacy.componentFormatUsed",
+    "legacy.providerDefaultUsed",
+];
+const values = Object.fromEntries(COUNTERS.map((counter) => [counter, 0]));
+const warnedCounters = new Set();
+const DIAGNOSTICS = {
+    "legacy.markdownFallbackUsed": "Deprecated markdown state fallback used; migrate projects to DB-authoritative state before removing markdown derivation.",
+    "legacy.workflowEngineUsed": "Deprecated workflow engine path used; prefer auto-milestone workflow templates before removing legacy engines.",
+    "legacy.uokFallbackUsed": "Deprecated UOK fallback path used; resolve UOK kernel blockers before removing parity fallback wrappers.",
+    "legacy.mcpAliasUsed": "Deprecated MCP alias tool used; update callers to the canonical gsd_* tool name before alias removal.",
+    "legacy.componentFormatUsed": "Deprecated component format loaded; migrate skills/agents to component.yaml before removing legacy loaders.",
+    "legacy.providerDefaultUsed": "Provider-specific default fallback used without an explicit available model; configure provider-aware model preferences before removing defaults.",
+};
+process.once("beforeExit", persistLegacyTelemetry);
+export function incrementLegacyTelemetry(counter, amount = 1) {
+    if (!Number.isFinite(amount) || amount <= 0)
+        return;
+    values[counter] += amount;
+    emitLegacyDiagnostic(counter);
+    persistLegacyTelemetry();
+}
+export function getLegacyTelemetry() {
+    return { ...values };
+}
+export function resetLegacyTelemetry() {
+    for (const counter of COUNTERS) {
+        values[counter] = 0;
+    }
+    warnedCounters.clear();
+}
+export function listLegacyTelemetryCounters() {
+    return [...COUNTERS];
+}
+export function getLegacyTelemetryReport() {
+    return {
+        ts: new Date().toISOString(),
+        counters: getLegacyTelemetry(),
+    };
+}
+export function persistLegacyTelemetrySnapshot() {
+    persistLegacyTelemetry();
+}
+function emitLegacyDiagnostic(counter) {
+    if (warnedCounters.has(counter))
+        return;
+    warnedCounters.add(counter);
+    logWarning("migration", DIAGNOSTICS[counter], { counter });
+}
+function persistLegacyTelemetry() {
+    const outputPath = process.env.GSD_LEGACY_TELEMETRY_FILE?.trim();
+    if (!outputPath)
+        return;
+    try {
+        mkdirSync(dirname(outputPath), { recursive: true });
+        writeFileSync(outputPath, `${JSON.stringify(getLegacyTelemetryReport(), null, 2)}\n`, "utf-8");
+    }
+    catch {
+        // Legacy cleanup telemetry must never block runtime paths.
+    }
+}

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Markdown projection renderer for GSD workflow database rows.
 // GSD Markdown Renderer — DB → Markdown file generation
 //
 // Transforms DB state into correct markdown files on disk.

package/dist/resources/extensions/gsd/migrate/command.js

@@ -15,6 +15,43 @@ import { fileURLToPath } from "node:url";
 import { showNextAction } from "../../shared/tui.js";
 import { validatePlanningDirectory, parsePlanningDirectory, transformToGSD, generatePreview, writeGSDDirectory, } from "./index.js";
 import { homedir } from "node:os";
+import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
+import { clearEngineHierarchy, transaction } from "../gsd-db.js";
+import { migrateFromMarkdown } from "../md-importer.js";
+import { invalidateStateCache } from "../state.js";
+function assertMigrationImportMatchesPreview(imported, preview) {
+    const mismatches = [];
+    if (imported.hierarchy.milestones !== preview.milestoneCount) {
+        mismatches.push(`milestones ${imported.hierarchy.milestones}/${preview.milestoneCount}`);
+    }
+    if (imported.hierarchy.slices !== preview.totalSlices) {
+        mismatches.push(`slices ${imported.hierarchy.slices}/${preview.totalSlices}`);
+    }
+    if (imported.hierarchy.tasks !== preview.totalTasks) {
+        mismatches.push(`tasks ${imported.hierarchy.tasks}/${preview.totalTasks}`);
+    }
+    if (imported.requirements !== preview.requirements.total) {
+        mismatches.push(`requirements ${imported.requirements}/${preview.requirements.total}`);
+    }
+    if (mismatches.length > 0) {
+        throw new Error(`migration DB import verification failed: ${mismatches.join(", ")}`);
+    }
+}
+export async function importWrittenMigrationToDb(basePath, preview) {
+    const opened = await ensureDbOpen(basePath);
+    if (!opened) {
+        throw new Error(`failed to open or create the GSD database at ${basePath}`);
+    }
+    const counts = transaction(() => {
+        clearEngineHierarchy();
+        const imported = migrateFromMarkdown(basePath);
+        if (preview)
+            assertMigrationImportMatchesPreview(imported, preview);
+        return imported;
+    });
+    invalidateStateCache();
+    return counts;
+}
 /** Format preview stats for embedding in the review prompt. */
 function formatPreviewStats(preview) {
     const lines = [
@@ -126,12 +163,14 @@ export async function handleMigrate(args, ctx, pi) {
     ctx.ui.notify("Writing .gsd directory…", "info");
     const result = await writeGSDDirectory(project, process.cwd());
     const gsdPath = gsdRoot(process.cwd());
-    ctx.ui.notify(`✓ Migration complete — ${result.paths.length} file(s) written to .gsd/`, "info");
+    const imported = await importWrittenMigrationToDb(process.cwd(), preview);
+    ctx.ui.notify(`✓ Migration complete — ${result.paths.length} file(s) written to .gsd/ and ${imported.hierarchy.milestones}M/${imported.hierarchy.slices}S/${imported.hierarchy.tasks}T imported to the database`, "info");
     // ── Post-write review offer ────────────────────────────────────────────────
     const reviewChoice = await showNextAction(ctx, {
         title: "Migration written",
         summary: [
             `${result.paths.length} files written to .gsd/`,
+            `${imported.hierarchy.milestones} milestone(s), ${imported.hierarchy.slices} slice(s), and ${imported.hierarchy.tasks} task(s) imported to gsd.db`,
             "",
             "The agent can now review the migrated output against GSD-2 standards —",
             "checking structure, content quality, deriveState() round-trip, and",

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -0,0 +1,87 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
+import { clearEngineHierarchy, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, transaction, } from "./gsd-db.js";
+import { migrateHierarchyToDb } from "./md-importer.js";
+import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
+import { milestonesDir, resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
+import { invalidateStateCache } from "./state.js";
+function zeroCounts() {
+    return { milestones: 0, slices: 0, tasks: 0 };
+}
+function sameCounts(a, b) {
+    return a.milestones === b.milestones && a.slices === b.slices && a.tasks === b.tasks;
+}
+export function countMarkdownHierarchy(basePath) {
+    const root = milestonesDir(basePath);
+    if (!existsSync(root))
+        return zeroCounts();
+    const counts = zeroCounts();
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !/^M\d+/.test(entry.name))
+            continue;
+        counts.milestones++;
+        const roadmapPath = resolveMilestoneFile(basePath, entry.name, "ROADMAP");
+        if (!roadmapPath || !existsSync(roadmapPath))
+            continue;
+        const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
+        counts.slices += roadmap.slices.length;
+        for (const slice of roadmap.slices) {
+            const planPath = resolveSliceFile(basePath, entry.name, slice.id, "PLAN");
+            if (!planPath || !existsSync(planPath))
+                continue;
+            const plan = parsePlan(readFileSync(planPath, "utf-8"));
+            counts.tasks += plan.tasks.length;
+        }
+    }
+    return counts;
+}
+export function countDbHierarchy() {
+    if (!isDbAvailable())
+        return zeroCounts();
+    const counts = zeroCounts();
+    const milestones = getAllMilestones();
+    counts.milestones = milestones.length;
+    for (const milestone of milestones) {
+        const slices = getMilestoneSlices(milestone.id);
+        counts.slices += slices.length;
+        for (const slice of slices) {
+            counts.tasks += getSliceTasks(milestone.id, slice.id).length;
+        }
+    }
+    return counts;
+}
+export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
+    const markdown = countMarkdownHierarchy(basePath);
+    if (sameCounts(markdown, zeroCounts())) {
+        return {
+            action: "none",
+            reason: "no-markdown",
+            markdown,
+            beforeDb: zeroCounts(),
+            afterDb: zeroCounts(),
+        };
+    }
+    const opened = await ensureDbOpen(basePath);
+    if (!opened || !isDbAvailable()) {
+        throw new Error(`failed to open or create the GSD database at ${basePath}`);
+    }
+    const beforeDb = countDbHierarchy();
+    if (sameCounts(markdown, beforeDb)) {
+        return { action: "none", reason: "in-sync", markdown, beforeDb, afterDb: beforeDb };
+    }
+    const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
+    const imported = transaction(() => {
+        clearEngineHierarchy();
+        return migrateHierarchyToDb(basePath);
+    });
+    invalidateStateCache();
+    const afterDb = {
+        milestones: imported.milestones,
+        slices: imported.slices,
+        tasks: imported.tasks,
+    };
+    if (!sameCounts(markdown, afterDb)) {
+        throw new Error(`migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`);
+    }
+    return { action: "imported", reason, markdown, beforeDb, afterDb };
+}

package/dist/resources/extensions/gsd/model-router.js

@@ -1,9 +1,9 @@
-// GSD Extension — Dynamic Model Router
-// Maps complexity tiers to models, enforcing downgrade-only semantics.
-// The user's configured model is always the ceiling.
+// Project/App: GSD-2
+// File Purpose: Routes work to appropriate models while preserving configured ceilings.
 import { tierOrdinal } from "./complexity-classifier.js";
 import { getProviderCapabilities } from "@gsd/pi-ai";
 import { getToolCompatibility } from "@gsd/pi-coding-agent";
+import { incrementLegacyTelemetry } from "./legacy-telemetry.js";
 // ─── Known Model Tiers ───────────────────────────────────────────────────────
 // Maps known model IDs to their capability tier. Used when tier_models is not
 // explicitly configured to pick the best available model for each tier.
@@ -474,13 +474,16 @@ export function resolveModelForTier(tier, availableModelIds, routingConfigOrCros
         : crossProvider ?? routingConfig.cross_provider !== false;
     // No available models known — return canonical fallback
     if (availableModelIds.length === 0) {
+        incrementLegacyTelemetry("legacy.providerDefaultUsed");
         return canonicalModelForTier(tier);
     }
     // Cross-provider tier search
     const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider);
-    return resolved
-        ? normalizeResolvedTierModelId(resolved, tier, routingConfig)
-        : canonicalModelForTier(tier);
+    if (resolved) {
+        return normalizeResolvedTierModelId(resolved, tier, routingConfig);
+    }
+    incrementLegacyTelemetry("legacy.providerDefaultUsed");
+    return canonicalModelForTier(tier);
 }
 // ─── Internal ────────────────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/notification-widget.js

@@ -21,14 +21,32 @@ export function buildNotificationWidgetLines() {
     return chip ? [`  ${chip}`] : [];
 }
 const REFRESH_INTERVAL_MS = 30_000;
+let notificationWidgetCleanup;
 export function initNotificationWidget(ctx) {
+    notificationWidgetCleanup?.();
+    notificationWidgetCleanup = undefined;
     if (!ctx.hasUI)
-        return;
+        return () => { };
     const push = () => {
         const chip = buildNotificationChip();
         ctx.ui.setStatus(STATUS_KEY, chip.length > 0 ? chip : undefined);
     };
     push();
-    onNotificationStoreChange(push);
-    setInterval(push, REFRESH_INTERVAL_MS).unref?.();
+    const unsubscribe = onNotificationStoreChange(push);
+    const interval = setInterval(push, REFRESH_INTERVAL_MS);
+    interval.unref?.();
+    const cleanup = () => {
+        unsubscribe();
+        clearInterval(interval);
+        if (notificationWidgetCleanup === cleanup) {
+            ctx.ui.setStatus(STATUS_KEY, undefined);
+            notificationWidgetCleanup = undefined;
+        }
+    };
+    notificationWidgetCleanup = cleanup;
+    return cleanup;
+}
+export function _resetNotificationWidgetForTests() {
+    notificationWidgetCleanup?.();
+    notificationWidgetCleanup = undefined;
 }

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

@@ -177,8 +177,12 @@ export function resolveDir(parentDir, idPrefix) {
         const exact = entries.find(e => e.isDirectory() && e.name === idPrefix);
         if (exact)
             return exact.name;
+        const idLower = idPrefix.toLowerCase();
+        const exactCaseInsensitive = entries.find(e => e.isDirectory() && e.name.toLowerCase() === idLower);
+        if (exactCaseInsensitive)
+            return exactCaseInsensitive.name;
         // Prefix match for legacy descriptor dirs: M001-SOMETHING
-        const prefixed = entries.find(e => e.isDirectory() && e.name.startsWith(idPrefix + "-"));
+        const prefixed = entries.find(e => e.isDirectory() && e.name.toLowerCase().startsWith(idLower + "-"));
         return prefixed ? prefixed.name : null;
     }
     catch {

package/dist/resources/extensions/gsd/planning-path-scope.js

@@ -0,0 +1,26 @@
+import { isAbsolute, relative, resolve } from "node:path";
+import { normalizePlannedFileReference } from "./files.js";
+function isInsideBase(basePath, candidate) {
+    const base = resolve(basePath);
+    const abs = resolve(candidate);
+    const rel = relative(base, abs);
+    return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
+}
+/**
+ * Planning IO fields are execution contracts. Absolute paths are only safe when
+ * they stay inside the active working directory; in worktree mode, an absolute
+ * path to the original checkout makes executors edit the wrong tree.
+ */
+export function validatePlanningPathScope(basePath, fields) {
+    for (const { field, values } of fields) {
+        for (const raw of values) {
+            const candidate = normalizePlannedFileReference(raw);
+            if (!isAbsolute(candidate))
+                continue;
+            if (isInsideBase(basePath, candidate))
+                continue;
+            return `${field} contains absolute path outside working directory: ${candidate}. Use a path relative to ${basePath}.`;
+        }
+    }
+    return null;
+}

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Post-execution validation checks for completed GSD task output.
 /**
  * Post-Execution Checks — Validate task output after execution completes.
  *
@@ -96,12 +98,25 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
         if (existsSync(directPath)) {
             return { exists: true, resolvedPath: directPath };
         }
-        // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
-        // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
-        // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
-        // path is missing — otherwise a stray `./missing.css.ts` could shadow a
-        // genuinely missing `./missing.css` import.
-        if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+        // Known concrete extensions that should NOT fall through to code-shadow
+        // probing when missing. This preserves the "missing.css must stay missing"
+        // guarantee while still allowing dotted module stems like ./route.server
+        // to resolve as ./route.server.ts.
+        const nonFallbackExtensions = new Set([
+            ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+            ".json", ".css", ".scss", ".sass", ".less", ".styl",
+            ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".bmp",
+            ".woff", ".woff2", ".ttf", ".otf", ".eot",
+        ]);
+        const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
+        const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
+        if (explicitExt !== "" &&
+            !runtimeFallbackExtensions.has(explicitExt) &&
+            !nonFallbackExtensions.has(explicitExt) &&
+            !dottedStemFallbackExtensions.has(explicitExt)) {
+            return { exists: false, resolvedPath: null };
+        }
+        if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
             return { exists: false, resolvedPath: null };
         }
     }
@@ -163,6 +178,12 @@ export function checkImportResolution(taskRow, _priorTasks, basePath) {
         }
         const imports = extractRelativeImports(source);
         for (const { importPath, lineNum } of imports) {
+            // React Router generated +types modules may not exist on disk during
+            // post-exec checks (generated during framework build). Don't block task
+            // completion on these imports.
+            if (/^\.{1,2}\/\+types\//.test(importPath)) {
+                continue;
+            }
             const resolution = resolveImportPath(importPath, file, basePath);
             if (!resolution.exists) {
                 results.push({