gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/dist/resources/extensions/gsd/md-importer.js

@@ -5,9 +5,11 @@
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { upsertDecision, upsertRequirement, insertArtifact, openDatabase, transaction, _getAdapter, } from './gsd-db.js';
-import { resolveGsdRootFile, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
+import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, openDatabase, transaction, _getAdapter, } from './gsd-db.js';
+import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
+import { parseRoadmap, parsePlan } from './parsers-legacy.js';
+import { parseContextDependsOn } from './files.js';
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
 const VALID_MADE_BY = new Set(['human', 'agent', 'collaborative']);
 /**
@@ -403,6 +405,175 @@ function findFileByPrefixAndSuffix(dir, idPrefix, suffix) {
         return null;
     }
 }
+// ─── Hierarchy Migration (milestones/slices/tasks from roadmaps+plans) ────
+/**
+ * Walk .gsd/milestones/ dirs, parse roadmaps and plans, and populate
+ * the milestones/slices/tasks DB tables.
+ *
+ * - Milestone title: from roadmap H1 (e.g. "# M001: Title") or CONTEXT.md
+ * - Milestone status: 'complete' if SUMMARY exists, 'parked' if PARKED exists, else 'active'
+ * - Milestone depends_on: from CONTEXT.md frontmatter
+ * - Slice metadata: from parseRoadmap() — id, title, risk, depends, done, demo
+ * - Task metadata: from parsePlan() — id, title, done, estimate
+ *
+ * Uses INSERT OR IGNORE for idempotency. Insert order: milestones → slices → tasks.
+ * Ghost milestones (dirs with no CONTEXT, ROADMAP, or SUMMARY) are skipped.
+ *
+ * Returns count of inserted hierarchy items.
+ */
+export function migrateHierarchyToDb(basePath) {
+    const counts = { milestones: 0, slices: 0, tasks: 0 };
+    const milestoneIds = findMilestoneIds(basePath);
+    for (const milestoneId of milestoneIds) {
+        // Check for ghost milestones — skip dirs with no meaningful content
+        const roadmapPath = resolveMilestoneFile(basePath, milestoneId, 'ROADMAP');
+        const contextPath = resolveMilestoneFile(basePath, milestoneId, 'CONTEXT');
+        const summaryPath = resolveMilestoneFile(basePath, milestoneId, 'SUMMARY');
+        const parkedPath = resolveMilestoneFile(basePath, milestoneId, 'PARKED');
+        const hasRoadmap = roadmapPath !== null && existsSync(roadmapPath);
+        const hasContext = contextPath !== null && existsSync(contextPath);
+        const hasSummary = summaryPath !== null && existsSync(summaryPath);
+        const hasParked = parkedPath !== null && existsSync(parkedPath);
+        // Ghost milestone: no CONTEXT, ROADMAP, or SUMMARY → skip
+        if (!hasRoadmap && !hasContext && !hasSummary)
+            continue;
+        // Determine milestone status
+        let milestoneStatus = 'active';
+        if (hasSummary)
+            milestoneStatus = 'complete';
+        else if (hasParked)
+            milestoneStatus = 'parked';
+        // Determine milestone title from roadmap H1 or CONTEXT heading
+        let milestoneTitle = '';
+        let roadmapContent = null;
+        let roadmap = null;
+        if (hasRoadmap) {
+            roadmapContent = readFileSync(roadmapPath, 'utf-8');
+            roadmap = parseRoadmap(roadmapContent);
+            milestoneTitle = roadmap.title;
+        }
+        if (!milestoneTitle && hasContext) {
+            const contextContent = readFileSync(contextPath, 'utf-8');
+            const h1Match = contextContent.match(/^#\s+(.+)/m);
+            if (h1Match)
+                milestoneTitle = h1Match[1].trim();
+        }
+        // Determine depends_on from CONTEXT frontmatter
+        let dependsOn = [];
+        if (hasContext) {
+            const contextContent = readFileSync(contextPath, 'utf-8');
+            dependsOn = parseContextDependsOn(contextContent);
+        }
+        // Extract raw "## Boundary Map" section from roadmap markdown for planning column
+        let boundaryMapSection = '';
+        if (roadmapContent) {
+            const bmIdx = roadmapContent.indexOf('## Boundary Map');
+            if (bmIdx >= 0) {
+                const afterBm = roadmapContent.slice(bmIdx);
+                // Take content until next ## heading or EOF
+                const nextHeading = afterBm.indexOf('\n## ', 1);
+                boundaryMapSection = nextHeading >= 0 ? afterBm.slice(0, nextHeading).trim() : afterBm.trim();
+            }
+        }
+        // Insert milestone (FK parent — must come first)
+        insertMilestone({
+            id: milestoneId,
+            title: milestoneTitle,
+            status: milestoneStatus,
+            depends_on: dependsOn,
+            planning: {
+                vision: roadmap?.vision ?? '',
+                successCriteria: roadmap?.successCriteria ?? [],
+                boundaryMapMarkdown: boundaryMapSection,
+            },
+        });
+        counts.milestones++;
+        // Parse roadmap for slices
+        if (!roadmap)
+            continue;
+        for (const sliceEntry of roadmap.slices) {
+            // Per K002: use 'complete' not 'done'
+            const sliceStatus = sliceEntry.done ? 'complete' : 'pending';
+            // Parse slice plan early so goal is available for insertSlice planning column
+            const planPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'PLAN');
+            let plan = null;
+            if (planPath && existsSync(planPath)) {
+                const planContent = readFileSync(planPath, 'utf-8');
+                plan = parsePlan(planContent);
+            }
+            insertSlice({
+                id: sliceEntry.id,
+                milestoneId: milestoneId,
+                title: sliceEntry.title,
+                status: sliceStatus,
+                risk: sliceEntry.risk,
+                depends: sliceEntry.depends,
+                demo: sliceEntry.demo,
+                planning: {
+                    goal: plan?.goal ?? '',
+                },
+            });
+            counts.slices++;
+            // Insert tasks from parsed plan
+            if (!plan)
+                continue;
+            for (const taskEntry of plan.tasks) {
+                // Per K002: use 'complete' not 'done'
+                let taskStatus = taskEntry.done ? 'complete' : 'pending';
+                // Pre-migration consistency: if task is marked done in the plan but has
+                // no summary file on disk, import as 'pending' so it gets re-executed
+                // rather than silently importing bad state as the new DB authority.
+                if (taskStatus === 'complete') {
+                    const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
+                    if (tDir) {
+                        const summaryFile = join(tDir, `${taskEntry.id}-SUMMARY.md`);
+                        if (!existsSync(summaryFile)) {
+                            taskStatus = 'pending';
+                            process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id}/${taskEntry.id} marked done but missing summary — importing as pending\n`);
+                        }
+                    }
+                }
+                insertTask({
+                    id: taskEntry.id,
+                    sliceId: sliceEntry.id,
+                    milestoneId: milestoneId,
+                    title: taskEntry.title,
+                    status: taskStatus,
+                    planning: {
+                        files: taskEntry.files ?? [],
+                        verify: taskEntry.verify ?? '',
+                    },
+                });
+                counts.tasks++;
+            }
+            // Pre-migration consistency: if all tasks are done and the slice
+            // summary exists but the roadmap checkbox is unchecked, upgrade the
+            // slice to complete. This handles the common
+            // "all_tasks_done_roadmap_not_checked" inconsistency that the old
+            // doctor would have auto-fixed. Without a slice summary, the slice
+            // is in the "summarizing" phase, not complete.
+            if (!sliceEntry.done) {
+                const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
+                const hasSliceSummary = sliceSummaryPath !== null && existsSync(sliceSummaryPath);
+                const allTasksDone = plan.tasks.length > 0 && plan.tasks.every(t => {
+                    const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
+                    if (!tDir)
+                        return t.done;
+                    const summaryFile = join(tDir, `${t.id}-SUMMARY.md`);
+                    return t.done && existsSync(summaryFile);
+                });
+                if (allTasksDone && hasSliceSummary) {
+                    const adapter = _getAdapter();
+                    if (adapter) {
+                        adapter.prepare(`UPDATE slices SET status = 'complete' WHERE id = :sid AND milestone_id = :mid`).run({ ':sid': sliceEntry.id, ':mid': milestoneId });
+                        process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id} all tasks + slice summary complete — upgrading slice to complete\n`);
+                    }
+                }
+            }
+        }
+    }
+    return counts;
+}
 // ─── Orchestrator ──────────────────────────────────────────────────────────
 /**
  * Import all markdown artifacts from a .gsd/ directory into the database.
@@ -420,6 +591,7 @@ export function migrateFromMarkdown(gsdDir) {
     let decisions = 0;
     let requirements = 0;
     let artifacts = 0;
+    let hierarchy = { milestones: 0, slices: 0, tasks: 0 };
     transaction(() => {
         try {
             decisions = importDecisions(gsdDir);
@@ -439,7 +611,13 @@ export function migrateFromMarkdown(gsdDir) {
         catch (err) {
             process.stderr.write(`gsd-migrate: skipping artifacts import: ${err.message}\n`);
         }
+        try {
+            hierarchy = migrateHierarchyToDb(gsdDir);
+        }
+        catch (err) {
+            process.stderr.write(`gsd-migrate: skipping hierarchy migration: ${err.message}\n`);
+        }
     });
-    process.stderr.write(`gsd-migrate: imported ${decisions} decisions, ${requirements} requirements, ${artifacts} artifacts\n`);
-    return { decisions, requirements, artifacts };
+    process.stderr.write(`gsd-migrate: imported ${decisions} decisions, ${requirements} requirements, ${artifacts} artifacts, ${hierarchy.milestones}M/${hierarchy.slices}S/${hierarchy.tasks}T hierarchy\n`);
+    return { decisions, requirements, artifacts, hierarchy };
 }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -697,7 +697,16 @@ export function nativeMergeSquash(basePath, branch) {
         if (stderr.includes("local changes would be overwritten") ||
             stderr.includes("not possible because you have unmerged files") ||
             stderr.includes("overwritten by merge")) {
-            return { success: false, conflicts: ["__dirty_working_tree__"] };
+            // Extract filenames from git stderr so callers can report which files
+            // are dirty instead of generically blaming .gsd/ (#2151).
+            // Git lists them as tab-indented lines between the "would be overwritten"
+            // header and the "Please commit" footer.
+            const dirtyFiles = stderr
+                .split("\n")
+                .filter((line) => line.startsWith("\t"))
+                .map((line) => line.trim())
+                .filter(Boolean);
+            return { success: false, conflicts: ["__dirty_working_tree__"], dirtyFiles };
         }
         // Check for real content conflicts
         const conflictOutput = gitExec(basePath, ["diff", "--name-only", "--diff-filter=U"], true);

package/dist/resources/extensions/gsd/parallel-eligibility.js

@@ -5,35 +5,30 @@
  * dependency satisfaction and file overlap across slice plans.
  */
 import { deriveState } from "./state.js";
-import { parseRoadmap, parsePlan, loadFile } from "./files.js";
-import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 // ─── File Collection ─────────────────────────────────────────────────────────
 /**
  * Collect all `filesLikelyTouched` across every slice plan in a milestone.
  * Returns a deduplicated list of file paths.
  */
 async function collectTouchedFiles(basePath, milestoneId) {
-    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-    if (!roadmapPath)
-        return [];
-    const roadmapContent = await loadFile(roadmapPath);
-    if (!roadmapContent)
-        return [];
-    const roadmap = parseRoadmap(roadmapContent);
     const files = new Set();
-    for (const slice of roadmap.slices) {
-        const planPath = resolveSliceFile(basePath, milestoneId, slice.id, "PLAN");
-        if (!planPath)
-            continue;
-        const planContent = await loadFile(planPath);
-        if (!planContent)
-            continue;
-        const plan = parsePlan(planContent);
-        for (const f of plan.filesLikelyTouched) {
-            files.add(f);
+    if (isDbAvailable()) {
+        // DB path: query slices and their tasks for file lists
+        const slices = getMilestoneSlices(milestoneId);
+        for (const slice of slices) {
+            const tasks = getSliceTasks(milestoneId, slice.id);
+            for (const task of tasks) {
+                if (Array.isArray(task.files)) {
+                    for (const f of task.files) {
+                        files.add(f);
+                    }
+                }
+            }
         }
     }
+    // When DB unavailable, return empty file set — parallel eligibility cannot be determined
     return [...files];
 }
 // ─── Overlap Detection ──────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -266,6 +266,15 @@ export async function startParallel(basePath, milestoneIds, prefs) {
         return { started: [], errors: [{ mid: "all", error: "Cannot start parallel from within a parallel worker" }] };
     }
     const config = resolveParallelConfig(prefs);
+    // Release any leftover state from a previous session before reassigning
+    if (state) {
+        for (const w of state.workers.values()) {
+            w.cleanup?.();
+            w.cleanup = undefined;
+            w.process = null;
+        }
+        state.workers.clear();
+    }
     // Try to restore from a previous crash
     const restored = restoreState(basePath);
     if (restored && restored.workers.length > 0) {
@@ -483,6 +492,15 @@ export function spawnWorker(basePath, milestoneId) {
         startedAt: worker.startedAt,
         worktreePath: worker.worktreePath,
     });
+    // Store cleanup function to remove all listeners from the child process.
+    // This prevents listener accumulation when workers are respawned, since
+    // handler closures capture milestoneId and other data that would otherwise
+    // be retained indefinitely.
+    worker.cleanup = () => {
+        child.stdout?.removeAllListeners();
+        child.stderr?.removeAllListeners();
+        child.removeAllListeners();
+    };
     // Handle worker exit
     child.on("exit", (code) => {
         if (!state)
@@ -490,6 +508,9 @@ export function spawnWorker(basePath, milestoneId) {
         const w = state.workers.get(milestoneId);
         if (!w)
             return;
+        // Remove all stream listeners to release closure references
+        w.cleanup?.();
+        w.cleanup = undefined;
         w.process = null;
         if (w.state === "stopped")
             return; // graceful stop, already handled
@@ -667,6 +688,9 @@ export async function stopParallel(basePath, milestoneId) {
             catch { /* process may already be dead */ }
             await waitForWorkerExit(worker, 250);
         }
+        // Remove stream listeners before releasing the process handle
+        worker.cleanup?.();
+        worker.cleanup = undefined;
         // Update in-memory state
         worker.state = "stopped";
         worker.process = null;
@@ -733,6 +757,8 @@ export function refreshWorkerStatuses(basePath, options = {}) {
     for (const mid of staleIds) {
         const worker = state.workers.get(mid);
         if (worker) {
+            worker.cleanup?.();
+            worker.cleanup = undefined;
             worker.state = "error";
             worker.process = null;
         }
@@ -748,6 +774,8 @@ export function refreshWorkerStatuses(basePath, options = {}) {
         const diskStatus = statusMap.get(mid);
         if (!diskStatus) {
             if (!isPidAlive(worker.pid)) {
+                worker.cleanup?.();
+                worker.cleanup = undefined;
                 worker.state = worker.completedUnits > 0 ? "stopped" : "error";
                 worker.process = null;
             }
@@ -784,5 +812,15 @@ export function isBudgetExceeded() {
 // ─── Reset ─────────────────────────────────────────────────────────────────
 /** Reset orchestrator state. Called on clean shutdown. */
 export function resetOrchestrator() {
+    if (state) {
+        // Explicitly release all WorkerInfo references and run any pending
+        // cleanup callbacks so child process stream closures are freed.
+        for (const w of state.workers.values()) {
+            w.cleanup?.();
+            w.cleanup = undefined;
+            w.process = null;
+        }
+        state.workers.clear();
+    }
     state = null;
 }

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

@@ -0,0 +1,239 @@
+// GSD Extension - Legacy Parsers
+// parseRoadmap() and parsePlan() extracted from files.ts.
+// Used only by: md-importer.ts (migration), state.ts (pre-migration fallback),
+// markdown-renderer.ts (detectStaleRenders disk-vs-DB comparison),
+// commands-maintenance.ts (cold-path branch cleanup), and tests.
+//
+// NOT used in the dispatch loop or any hot-path runtime code.
+import { extractSection, parseBullets, extractBoldField, extractAllSections, registerCacheClearCallback } from './files.js';
+import { splitFrontmatter } from '../shared/frontmatter.js';
+import { nativeParseRoadmap, nativeParsePlanFile } from './native-parser-bridge.js';
+import { debugTime, debugCount } from './debug-logger.js';
+import { CACHE_MAX } from './constants.js';
+// Re-export parseRoadmapSlices so callers can import all legacy parsers from one module
+import { parseRoadmapSlices } from './roadmap-slices.js';
+export { parseRoadmapSlices };
+// ─── Parse Cache (local to this module) ───────────────────────────────────
+/** Fast composite key: length + first/mid/last 100 chars. The middle sample
+ *  prevents collisions when only a few characters change in the interior of
+ *  a file (e.g., a checkbox [ ] → [x] that doesn't alter length or endpoints). */
+function cacheKey(content) {
+    const len = content.length;
+    const head = content.slice(0, 100);
+    const midStart = Math.max(0, Math.floor(len / 2) - 50);
+    const mid = len > 200 ? content.slice(midStart, midStart + 100) : '';
+    const tail = len > 100 ? content.slice(-100) : '';
+    return `${len}:${head}:${mid}:${tail}`;
+}
+const _parseCache = new Map();
+function cachedParse(content, tag, parseFn) {
+    const key = tag + '|' + cacheKey(content);
+    if (_parseCache.has(key))
+        return _parseCache.get(key);
+    if (_parseCache.size >= CACHE_MAX)
+        _parseCache.clear();
+    const result = parseFn(content);
+    _parseCache.set(key, result);
+    return result;
+}
+/** Clear the legacy parser cache. Called by clearParseCache() in files.ts. */
+export function clearLegacyParseCache() {
+    _parseCache.clear();
+}
+// Register with files.ts so clearParseCache() also clears our cache
+registerCacheClearCallback(clearLegacyParseCache);
+// ─── Roadmap Parser ────────────────────────────────────────────────────────
+export function parseRoadmap(content) {
+    return cachedParse(content, 'roadmap', _parseRoadmapImpl);
+}
+function _parseRoadmapImpl(content) {
+    const stopTimer = debugTime("parse-roadmap");
+    // Try native parser first for better performance
+    const nativeResult = nativeParseRoadmap(content);
+    if (nativeResult) {
+        stopTimer({ native: true, slices: nativeResult.slices.length, boundaryEntries: nativeResult.boundaryMap.length });
+        debugCount("parseRoadmapCalls");
+        return nativeResult;
+    }
+    const lines = content.split('\n');
+    const h1 = lines.find(l => l.startsWith('# '));
+    const title = h1 ? h1.slice(2).trim() : '';
+    const vision = extractBoldField(content, 'Vision') || '';
+    const scSection = extractSection(content, 'Success Criteria', 2) ||
+        (() => {
+            const idx = content.indexOf('**Success Criteria:**');
+            if (idx === -1)
+                return '';
+            const rest = content.slice(idx);
+            const nextSection = rest.indexOf('\n---');
+            const block = rest.slice(0, nextSection === -1 ? undefined : nextSection);
+            const firstNewline = block.indexOf('\n');
+            return firstNewline === -1 ? '' : block.slice(firstNewline + 1);
+        })();
+    const successCriteria = scSection ? parseBullets(scSection) : [];
+    // Slices
+    const slices = parseRoadmapSlices(content);
+    // Boundary map
+    const boundaryMap = [];
+    const bmSection = extractSection(content, 'Boundary Map');
+    if (bmSection) {
+        const h3Sections = extractAllSections(bmSection, 3);
+        for (const [heading, sectionContent] of h3Sections) {
+            const arrowMatch = heading.match(/^(\S+)\s*→\s*(\S+)/);
+            if (!arrowMatch)
+                continue;
+            const fromSlice = arrowMatch[1];
+            const toSlice = arrowMatch[2];
+            let produces = '';
+            let consumes = '';
+            // Use indexOf-based parsing instead of [\s\S]*? regex to avoid
+            // catastrophic backtracking on content with code fences (#468).
+            const prodIdx = sectionContent.search(/^Produces:\s*$/m);
+            if (prodIdx !== -1) {
+                const afterProd = sectionContent.indexOf('\n', prodIdx);
+                if (afterProd !== -1) {
+                    const consIdx = sectionContent.search(/^Consumes/m);
+                    const endIdx = consIdx !== -1 && consIdx > afterProd ? consIdx : sectionContent.length;
+                    produces = sectionContent.slice(afterProd + 1, endIdx).trim();
+                }
+            }
+            const consLineMatch = sectionContent.match(/^Consumes[^:]*:\s*(.+)$/m);
+            if (consLineMatch) {
+                consumes = consLineMatch[1].trim();
+            }
+            if (!consumes) {
+                const consIdx = sectionContent.search(/^Consumes[^:]*:\s*$/m);
+                if (consIdx !== -1) {
+                    const afterCons = sectionContent.indexOf('\n', consIdx);
+                    if (afterCons !== -1) {
+                        consumes = sectionContent.slice(afterCons + 1).trim();
+                    }
+                }
+            }
+            boundaryMap.push({ fromSlice, toSlice, produces, consumes });
+        }
+    }
+    const result = { title, vision, successCriteria, slices, boundaryMap };
+    stopTimer({ native: false, slices: slices.length, boundaryEntries: boundaryMap.length });
+    debugCount("parseRoadmapCalls");
+    return result;
+}
+// ─── Slice Plan Parser ─────────────────────────────────────────────────────
+export function parsePlan(content) {
+    return cachedParse(content, 'plan', _parsePlanImpl);
+}
+function _parsePlanImpl(content) {
+    const stopTimer = debugTime("parse-plan");
+    const [, body] = splitFrontmatter(content);
+    // Try native parser first for better performance
+    const nativeResult = nativeParsePlanFile(body);
+    if (nativeResult) {
+        stopTimer({ native: true });
+        return {
+            id: nativeResult.id,
+            title: nativeResult.title,
+            goal: nativeResult.goal,
+            demo: nativeResult.demo,
+            mustHaves: nativeResult.mustHaves,
+            tasks: nativeResult.tasks.map(t => ({
+                id: t.id,
+                title: t.title,
+                description: t.description,
+                done: t.done,
+                estimate: t.estimate,
+                ...(t.files.length > 0 ? { files: t.files } : {}),
+                ...(t.verify ? { verify: t.verify } : {}),
+            })),
+            filesLikelyTouched: nativeResult.filesLikelyTouched,
+        };
+    }
+    const lines = body.split('\n');
+    const h1 = lines.find(l => l.startsWith('# '));
+    let id = '';
+    let title = '';
+    if (h1) {
+        const match = h1.match(/^#\s+(\w+):\s+(.+)/);
+        if (match) {
+            id = match[1];
+            title = match[2].trim();
+        }
+        else {
+            title = h1.slice(2).trim();
+        }
+    }
+    const goal = extractBoldField(body, 'Goal') || '';
+    const demo = extractBoldField(body, 'Demo') || '';
+    const mhSection = extractSection(body, 'Must-Haves');
+    const mustHaves = mhSection ? parseBullets(mhSection) : [];
+    const tasksSection = extractSection(body, 'Tasks');
+    const tasks = [];
+    if (tasksSection) {
+        const taskLines = tasksSection.split('\n');
+        let currentTask = null;
+        for (const line of taskLines) {
+            const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
+            // Heading-style: ### T01 -- Title, ### T01: Title, ### T01 — Title
+            const hdMatch = !cbMatch ? line.match(/^#{2,4}\s+([\w.]+)\s*(?:--|—|:)\s*(.+)/) : null;
+            if (cbMatch || hdMatch) {
+                if (currentTask)
+                    tasks.push(currentTask);
+                if (cbMatch) {
+                    const rest = cbMatch[4] || '';
+                    const estMatch = rest.match(/`est:([^`]+)`/);
+                    const estimate = estMatch ? estMatch[1] : '';
+                    currentTask = {
+                        id: cbMatch[2],
+                        title: cbMatch[3],
+                        description: '',
+                        done: cbMatch[1].toLowerCase() === 'x',
+                        estimate,
+                    };
+                }
+                else {
+                    const rest = hdMatch[2] || '';
+                    const titleEstMatch = rest.match(/^(.+?)\s*`est:([^`]+)`\s*$/);
+                    const title = titleEstMatch ? titleEstMatch[1].trim() : rest.trim();
+                    const estimate = titleEstMatch ? titleEstMatch[2] : '';
+                    currentTask = {
+                        id: hdMatch[1],
+                        title,
+                        description: '',
+                        done: false,
+                        estimate,
+                    };
+                }
+            }
+            else if (currentTask && line.match(/^\s*-\s+Files:\s*(.*)/)) {
+                const filesMatch = line.match(/^\s*-\s+Files:\s*(.*)/);
+                if (filesMatch) {
+                    currentTask.files = filesMatch[1]
+                        .split(',')
+                        .map(f => f.replace(/`/g, '').trim())
+                        .filter(f => f.length > 0);
+                }
+            }
+            else if (currentTask && line.match(/^\s*-\s+Verify:\s*(.*)/)) {
+                const verifyMatch = line.match(/^\s*-\s+Verify:\s*(.*)/);
+                if (verifyMatch) {
+                    currentTask.verify = verifyMatch[1].trim();
+                }
+            }
+            else if (currentTask && line.trim() && !line.startsWith('#')) {
+                const desc = line.trim();
+                if (desc) {
+                    currentTask.description = currentTask.description
+                        ? currentTask.description + ' ' + desc
+                        : desc;
+                }
+            }
+        }
+        if (currentTask)
+            tasks.push(currentTask);
+    }
+    const filesSection = extractSection(body, 'Files Likely Touched');
+    const filesLikelyTouched = filesSection ? parseBullets(filesSection) : [];
+    const result = { id, title, goal, demo, mustHaves, tasks, filesLikelyTouched };
+    stopTimer({ tasks: tasks.length });
+    debugCount("parsePlanCalls");
+    return result;
+}

package/dist/resources/extensions/gsd/preferences-types.js

@@ -68,6 +68,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "github",
     "service_tier",
     "forensics_dedup",
+    "show_token_cost",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -775,5 +775,14 @@ export function validatePreferences(preferences) {
             errors.push("github must be an object");
         }
     }
+    // ─── Show Token Cost ──────────────────────────────────────────────
+    if (preferences.show_token_cost !== undefined) {
+        if (typeof preferences.show_token_cost === "boolean") {
+            validated.show_token_cost = preferences.show_token_cost;
+        }
+        else {
+            errors.push("show_token_cost must be a boolean");
+        }
+    }
     return { preferences: validated, errors, warnings };
 }

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

@@ -266,6 +266,7 @@ function mergePreferences(base, override) {
             : undefined,
         service_tier: override.service_tier ?? base.service_tier,
         forensics_dedup: override.forensics_dedup ?? base.forensics_dedup,
+        show_token_cost: override.show_token_cost ?? base.show_token_cost,
     };
 }
 function mergeStringLists(base, override) {