gsd-pi 2.80.0-dev.2848d9009 → 2.80.0-dev.3065f7bfa

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";
@@ -51,6 +51,23 @@ export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesCon
 import { logWarning } from "./workflow-logger.js";
 import { deleteRuntimeKv } from "./db/runtime-kv.js";
 import { PAUSED_SESSION_KV_KEY } from "./interrupted-session.js";
+import { buildWorkflowDispatchContent } from "./workflow-protocol.js";
+import { isFullGsdToolSurfaceRequested, restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch } from "./bootstrap/register-hooks.js";
+function scheduleAutoStartAfterIdle(ctx, pi, basePath, verboseMode, options, launch = startAutoDetached) {
+    const waitForIdle = typeof ctx.waitForIdle === "function"
+        ? ctx.waitForIdle.bind(ctx)
+        : async () => { };
+    void waitForIdle()
+        .then(() => {
+        setTimeout(() => launch(ctx, pi, basePath, verboseMode, options), 0);
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Auto-start failed while waiting for the prior turn to settle: ${message}`, "error");
+        logWarning("guided", `auto-start idle wait failed: ${message}`);
+    });
+}
+export const _scheduleAutoStartAfterIdleForTest = scheduleAutoStartAfterIdle;
 // ─── Scope-based validator wrappers ──────────────────────────────────────────
 // These thin wrappers accept a MilestoneScope so callers that already hold a
 // pinned scope never have to re-derive (basePath, milestoneId) separately.
@@ -71,6 +88,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
@@ -312,7 +342,7 @@ async function dispatchNextDeepProjectSetupStage(entry) {
     const { DISPATCH_RULES, hasPendingDeepStage } = await import("./auto-dispatch.js");
     if (!hasPendingDeepStage(prefs, entry.basePath)) {
         pendingDeepProjectSetupMap.delete(entry.basePath);
-        startAutoDetached(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
+        scheduleAutoStartAfterIdle(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
         return true;
     }
     const state = await deriveState(entry.basePath);
@@ -346,14 +376,14 @@ async function dispatchNextDeepProjectSetupStage(entry) {
         }
         else if (hasPendingDeepStage(prefs, entry.basePath)) {
             pendingDeepProjectSetupMap.delete(entry.basePath);
-            startAutoDetached(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
+            scheduleAutoStartAfterIdle(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
             return true;
         }
         return false;
     }
     if (!USER_DRIVEN_DEEP_SETUP_UNITS.has(result.unitType)) {
         pendingDeepProjectSetupMap.delete(entry.basePath);
-        startAutoDetached(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
+        scheduleAutoStartAfterIdle(entry.ctx, entry.pi, entry.basePath, false, { step: entry.step });
         return true;
     }
     entry.currentUnitType = result.unitType;
@@ -531,7 +561,7 @@ export function checkAutoStartAfterDiscuss() {
     }
     pendingAutoStartMap.delete(basePath);
     ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
-    startAutoDetached(ctx, pi, basePath, false, { step });
+    scheduleAutoStartAfterIdle(ctx, pi, basePath, false, { step });
     return true;
 }
 /**
@@ -817,38 +847,55 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
             return;
         }
     }
-    // Scope tools for discuss flows (#2949).
+    // Scope tools for guided workflow turns (#2949, token-consumption savings).
     // Providers with grammar-based constrained decoding (xAI/Grok) return
     // "Grammar is too complex" when the combined tool schema is too large.
-    // Discuss flows only need a small subset of GSD tools — strip the heavy
-    // planning/execution/completion tools to keep the grammar within limits.
+    // Guided workflow turns only need the active unit's tool surface; strip
+    // unrelated GSD tools and broad non-GSD tools for this queued turn, then
+    // restore so the narrowed surface does not leak into future dispatches.
     let savedTools = null;
-    if (unitType?.startsWith("discuss-")) {
+    try {
         const currentTools = pi.getActiveTools();
-        savedTools = currentTools;
-        // Keep all non-GSD tools (builtins, other extensions) and only the
-        // GSD tools on the discuss allowlist.
-        const scopedTools = currentTools.filter((t) => !t.startsWith("gsd_") || DISCUSS_TOOLS_ALLOWLIST.includes(t));
-        pi.setActiveTools(scopedTools);
-        debugLog("discuss-tool-scoping", {
-            unitType,
-            before: currentTools.length,
-            after: scopedTools.length,
-            removed: currentTools.length - scopedTools.length,
-        });
-    }
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
-    const workflow = readFileSync(workflowPath, "utf-8");
-    pi.sendMessage({
-        customType,
-        content: `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${note}`,
-        display: false,
-    }, { triggerTurn: true });
-    // Restore full tool set after the message is queued. The LLM turn has
-    // already captured the scoped set — restoring prevents the narrowed
-    // tools from leaking into subsequent dispatches (#3628).
-    if (savedTools) {
-        pi.setActiveTools(savedTools);
+        savedTools = {
+            tools: currentTools,
+            visibleSkills: typeof pi.getVisibleSkills === "function" ? pi.getVisibleSkills() : undefined,
+            restoreVisibleSkills: typeof pi.setVisibleSkills === "function",
+        };
+        if (unitType?.startsWith("discuss-") && !isFullGsdToolSurfaceRequested()) {
+            // Keep all non-GSD tools (builtins, other extensions) and only the
+            // GSD tools on the discuss allowlist.
+            const scopedTools = currentTools.filter((t) => !t.startsWith("gsd_") || DISCUSS_TOOLS_ALLOWLIST.includes(t));
+            pi.setActiveTools(scopedTools);
+            const scopedState = scopeGsdWorkflowToolsForDispatch(pi, unitType);
+            savedTools = {
+                tools: currentTools,
+                visibleSkills: scopedState?.visibleSkills ?? savedTools.visibleSkills,
+                restoreVisibleSkills: scopedState?.restoreVisibleSkills ?? savedTools.restoreVisibleSkills,
+            };
+            debugLog("discuss-tool-scoping", {
+                unitType,
+                before: currentTools.length,
+                after: pi.getActiveTools().length,
+                removed: currentTools.length - pi.getActiveTools().length,
+            });
+        }
+        else {
+            savedTools = scopeGsdWorkflowToolsForDispatch(pi, unitType) ?? savedTools;
+        }
+        const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
+        const workflow = readFileSync(workflowPath, "utf-8");
+        pi.sendMessage({
+            customType,
+            content: buildWorkflowDispatchContent({ workflow, workflowPath, task: note }),
+            display: false,
+        }, { triggerTurn: true });
+    }
+    finally {
+        // Restore full tool set after the message is queued. The LLM turn has
+        // already captured the scoped set — restoring prevents the narrowed
+        // tools from leaking into subsequent dispatches (#3628). The finally
+        // block ensures restoration even if sendMessage throws.
+        restoreGsdWorkflowTools(pi, savedTools);
     }
 }
 function getStructuredQuestionsAvailability(pi, ctx) {
@@ -1469,8 +1516,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++;
             }
@@ -1695,6 +1742,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);
@@ -1795,7 +1856,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 notYetMessage: "Run /gsd when ready.",
             });
             if (choice === "quick_task") {
-                ctx.ui.notify("Run /gsd quick <task> for small bounded work, or /gsd do <task> for natural-language routing.", "info");
+                await runQuickTaskChoice(ctx, pi);
             }
             else if (choice === "new_milestone") {
                 setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
@@ -1837,7 +1898,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd when ready.",
         });
         if (choice === "quick_task") {
-            ctx.ui.notify("Run /gsd quick <task> for small bounded work, or /gsd do <task> for natural-language routing.", "info");
+            await runQuickTaskChoice(ctx, pi);
         }
         else if (choice === "new_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
@@ -1968,7 +2029,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 notYetMessage: "Run /gsd when ready.",
             });
             if (choice === "quick_task") {
-                ctx.ui.notify("Run /gsd quick <task> for small bounded work, or /gsd do <task> for natural-language routing.", "info");
+                await runQuickTaskChoice(ctx, pi);
             }
             else if (choice === "plan") {
                 setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });

package/dist/resources/extensions/gsd/memory-store.js

@@ -14,6 +14,27 @@ const CATEGORY_PRIORITY = {
     environment: 4,
     preference: 5,
 };
+// ─── Scoring Helpers ─────────────────────────────────────────────────────────
+/**
+ * Time-decay factor for memory relevance scoring.
+ * Returns 1.0 for never-hit or recently-hit memories, decaying linearly to
+ * 0.7 for memories not accessed in 90+ days. Floor at 0.7 keeps old-but-valid
+ * knowledge from being fully suppressed.
+ *
+ * Defensive parsing: invalid timestamp strings (NaN from Date.parse) are
+ * treated as "no decay" rather than propagating NaN into score arithmetic.
+ * Future timestamps (clock skew, manual DB edits) clamp to daysAgo=0 so the
+ * factor stays in the documented [0.7, 1.0] contract.
+ */
+export function memoryDecayFactor(lastHitAt) {
+    if (!lastHitAt)
+        return 1.0;
+    const ts = Date.parse(lastHitAt);
+    if (!Number.isFinite(ts))
+        return 1.0;
+    const daysAgo = Math.max(0, (Date.now() - ts) / 86_400_000);
+    return Math.max(0.7, 1.0 - 0.3 * Math.min(1.0, daysAgo / 90));
+}
 // ─── Row Mapping ────────────────────────────────────────────────────────────
 function rowToMemory(row) {
     return {
@@ -31,6 +52,7 @@ function rowToMemory(row) {
         scope: row['scope'] ?? 'project',
         tags: parseTags(row['tags']),
         structured_fields: parseStructuredFields(row['structured_fields']),
+        last_hit_at: row['last_hit_at'] ?? null,
     };
 }
 function parseStructuredFields(raw) {
@@ -114,15 +136,37 @@ export function queryMemoriesRanked(opts) {
         ? semanticSearch(adapter, opts.queryVector, activeClause, 50)
         : [];
     if (keywordHits.length === 0 && semanticHits.length === 0 && !trimmedQuery) {
-        // No query at all — fall back to the existing ranked-by-score listing.
-        return getActiveMemoriesRanked(k).map((memory) => ({
-            memory,
-            score: memory.confidence * (1 + memory.hit_count * 0.1),
-            keywordRank: null,
-            semanticRank: null,
-            confidenceBoost: memory.confidence * (1 + memory.hit_count * 0.1),
-            reason: 'ranked',
-        })).filter((hit) => passesFilters(hit.memory, opts));
+        // No query at all — return top-k by decay-aware ranked score.
+        //
+        // Build the candidate pool from a direct SQL query that honors the
+        // request's activeClause (i.e. include_superseded). Using
+        // getActiveMemoriesRanked here would silently drop superseded rows even
+        // when the caller explicitly opted in, and would slice by raw score
+        // before decay/filters had a chance to reorder.
+        const candidatePool = Math.min(Math.max(k * 5, 50), 500);
+        const rows = adapter
+            .prepare(`SELECT * FROM memories ${activeClause}
+         ORDER BY (confidence * (1.0 + hit_count * 0.1)) DESC
+         LIMIT :limit`)
+            .all({ ':limit': candidatePool });
+        const ranked = [];
+        for (const row of rows) {
+            const memory = rowToMemory(row);
+            if (!passesFilters(memory, opts))
+                continue;
+            const decay = memoryDecayFactor(memory.last_hit_at);
+            const score = memory.confidence * (1 + memory.hit_count * 0.1) * decay;
+            ranked.push({
+                memory,
+                score,
+                keywordRank: null,
+                semanticRank: null,
+                confidenceBoost: score,
+                reason: 'ranked',
+            });
+        }
+        ranked.sort((a, b) => b.score - a.score);
+        return ranked.slice(0, k);
     }
     // 3) Reciprocal rank fusion — each hit contributes 1/(rrfK + rank).
     const fused = new Map();
@@ -155,7 +199,7 @@ export function queryMemoriesRanked(opts) {
     for (const entry of fused.values()) {
         if (!passesFilters(entry.memory, opts))
             continue;
-        const boost = entry.memory.confidence * (1 + entry.memory.hit_count * 0.1);
+        const boost = entry.memory.confidence * (1 + entry.memory.hit_count * 0.1) * memoryDecayFactor(entry.memory.last_hit_at);
         const reason = entry.kwRank != null && entry.semRank != null
             ? 'both'
             : entry.kwRank != null
@@ -194,6 +238,7 @@ function passesFilters(memory, filters) {
     }
     return true;
 }
+let ftsWarningEmitted = false;
 function keywordSearch(adapter, rawQuery, activeClause, limit) {
     const ftsAvailable = isFtsAvailable(adapter);
     if (ftsAvailable) {
@@ -215,14 +260,26 @@ function keywordSearch(adapter, rawQuery, activeClause, limit) {
             // fall through to LIKE
         }
     }
-    // LIKE fallback — scans the candidate pool.
+    // LIKE fallback — scans a capped candidate pool.
+    if (!ftsWarningEmitted) {
+        ftsWarningEmitted = true;
+        logWarning('memory-store', 'FTS5 unavailable — using LIKE fallback scan (consider enabling FTS5)');
+    }
     const terms = rawQuery
         .toLowerCase()
         .split(/[^a-z0-9_]+/)
         .filter((t) => t.length >= 2);
     if (terms.length === 0)
         return [];
-    const rows = adapter.prepare(`SELECT * FROM memories ${activeClause}`).all();
+    const preScanCap = Math.min(limit * 20, 2000);
+    // ORDER BY confidence-weighted hit_count DESC so the cap keeps the most
+    // valuable candidates instead of the oldest-by-rowid (which would silently
+    // exclude recently-stored memories on tables larger than preScanCap).
+    const rows = adapter
+        .prepare(`SELECT * FROM memories ${activeClause}
+       ORDER BY (confidence * (1.0 + hit_count * 0.1)) DESC
+       LIMIT :preScanCap`)
+        .all({ ':preScanCap': preScanCap });
     const scored = [];
     for (const row of rows) {
         const memory = rowToMemory(row);

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/native-git-bridge.js

@@ -5,7 +5,7 @@
 // Both READ and WRITE operations are native — push operations remain as
 // execSync calls because git2 credential handling is too complex.
 import { execFileSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -1007,6 +1007,24 @@ export function nativeRmForce(basePath, paths) {
         gitFileExec(basePath, ["rm", "--force", "--", path], true);
     }
 }
+function runGitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint) {
+    if (createBranch) {
+        const branchRef = gitExec(basePath, ["show-ref", "--verify", `refs/heads/${branch}`], true);
+        if (branchRef) {
+            gitExec(basePath, ["worktree", "add", wtPath, branch]);
+            return;
+        }
+        gitExec(basePath, ["worktree", "add", "-b", branch, wtPath, startPoint ?? "HEAD"]);
+    }
+    else {
+        gitExec(basePath, ["worktree", "add", wtPath, branch]);
+    }
+}
+export function assertWorktreeMaterialized(wtPath) {
+    if (existsSync(join(wtPath, ".git")))
+        return;
+    throw new GSDError(GSD_GIT_ERROR, `git worktree add did not materialize a valid worktree at ${wtPath}: missing .git file`);
+}
 /**
  * Add a new git worktree.
  * Native: libgit2 worktree API.
@@ -1016,14 +1034,20 @@ export function nativeWorktreeAdd(basePath, wtPath, branch, createBranch, startP
     const native = loadNative();
     if (native) {
         native.gitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint);
-        return;
-    }
-    if (createBranch) {
-        gitExec(basePath, ["worktree", "add", "-b", branch, wtPath, startPoint ?? "HEAD"]);
-    }
-    else {
-        gitExec(basePath, ["worktree", "add", wtPath, branch]);
+        try {
+            assertWorktreeMaterialized(wtPath);
+            return;
+        }
+        catch {
+            rmSync(wtPath, { recursive: true, force: true });
+            gitExec(basePath, ["worktree", "prune"], true);
+            runGitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint);
+            assertWorktreeMaterialized(wtPath);
+            return;
+        }
     }
+    runGitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint);
+    assertWorktreeMaterialized(wtPath);
 }
 /**
  * Remove a git worktree.