@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.72e3af2a

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

@@ -12,7 +12,7 @@ import { loadFile } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveMilestoneFile, resolveGsdRootFile, relGsdRootFile, } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, } from "./paths.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
@@ -20,6 +20,9 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
 import { isFutureMilestoneStatus } from "./status-guards.js";
+const QUEUE_ARTIFACT_EXCERPT_MAX_CHARS = 20_000;
+const QUEUE_EXISTING_MILESTONES_CONTEXT_MAX_CHARS = 120_000;
+const QUEUE_CONTEXT_SECTION_SEPARATOR = "\n\n---\n\n";
 // ─── Queue Entry Point ──────────────────────────────────────────────────────
 /**
  * Queue future milestones via conversational intake.
@@ -215,7 +218,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
         if (contextFile) {
             const content = await loadFile(contextFile);
             if (content) {
-                parts.push(`\n**Context:**\n${content.trim()}`);
+                parts.push(`\n**Context:**\n${summarizeArtifactForQueue(content, relMilestoneFile(basePath, mid, "CONTEXT"))}`);
             }
         }
         else {
@@ -224,7 +227,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             if (draftFile) {
                 const draftContent = await loadFile(draftFile);
                 if (draftContent) {
-                    parts.push(`\n**Draft context available:**\n${draftContent.trim()}`);
+                    parts.push(`\n**Draft context available:**\n${summarizeArtifactForQueue(draftContent, relMilestoneFile(basePath, mid, "CONTEXT-DRAFT"))}`);
                 }
             }
         }
@@ -235,7 +238,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             if (roadmapFile) {
                 const content = await loadFile(roadmapFile);
                 if (content) {
-                    parts.push(`\n**Roadmap:**\n${content.trim()}`);
+                    parts.push(`\n**Roadmap:**\n${summarizeArtifactForQueue(content, relMilestoneFile(basePath, mid, "ROADMAP"))}`);
                 }
             }
         }
@@ -249,7 +252,65 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             sections.push(`### Previous Queue Entries\nSource: \`${relGsdRootFile("QUEUE")}\`\n\n${queueContent.trim()}`);
         }
     }
-    return sections.join("\n\n---\n\n");
+    return capExistingMilestonesContext(sections);
+}
+function summarizeArtifactForQueue(content, sourcePath, cap = QUEUE_ARTIFACT_EXCERPT_MAX_CHARS) {
+    const trimmed = content.trim();
+    if (trimmed.length <= cap) {
+        return `Source: \`${sourcePath}\`\n\n${trimmed}`;
+    }
+    const excerpt = trimmed.slice(0, cap).trimEnd();
+    const omittedChars = trimmed.length - excerpt.length;
+    return [
+        `Source: \`${sourcePath}\``,
+        "",
+        excerpt,
+        "",
+        `[Truncated ${omittedChars} chars. Read \`${sourcePath}\` for full content.]`,
+    ].join("\n");
+}
+function capExistingMilestonesContext(sections, cap = QUEUE_EXISTING_MILESTONES_CONTEXT_MAX_CHARS) {
+    const fullContext = sections.join(QUEUE_CONTEXT_SECTION_SEPARATOR);
+    if (fullContext.length <= cap)
+        return fullContext;
+    const notice = `[Existing milestones context truncated to ${cap} chars. Read source paths in this prompt or the corresponding .gsd artifacts for full details.]`;
+    const noticeSuffix = `${QUEUE_CONTEXT_SECTION_SEPARATOR}${notice}`;
+    const selected = [];
+    for (const section of sections) {
+        const candidate = [...selected, section].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+        if (candidate.length <= cap) {
+            selected.push(section);
+            continue;
+        }
+        break;
+    }
+    if (selected.length === sections.length) {
+        return selected.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    }
+    const compactTail = sections.slice(selected.length).map(compactSectionForQueueBudget);
+    const hybrid = [...selected, ...compactTail].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    if (hybrid.length <= cap)
+        return hybrid;
+    const compact = sections.map(compactSectionForQueueBudget);
+    const compactContext = compact.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    if (compactContext.length <= cap)
+        return compactContext;
+    return `${compactContext.slice(0, Math.max(0, cap - notice.length - 2)).trimEnd()}\n\n${notice}`;
+}
+function compactSectionForQueueBudget(section) {
+    const lines = section.split("\n");
+    const compact = [];
+    if (lines[0])
+        compact.push(lines[0]);
+    const statusLine = lines.find(line => line.startsWith("**Status:**"));
+    if (statusLine)
+        compact.push(statusLine);
+    const sourceLines = lines.filter(line => line.startsWith("Source: `"));
+    if (sourceLines.length > 0) {
+        compact.push("", "**Sources:**", ...sourceLines);
+        compact.push("", "[Artifact excerpts omitted due to total queue/rethink context budget.]");
+    }
+    return compact.join("\n");
 }
 // ─── Internal Helpers ───────────────────────────────────────────────────────
 /**

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

@@ -1,29 +1,61 @@
 // Project/App: gsd-pi
 // File Purpose: Always-on ambient health signal rendered below the editor.
-import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
+import { execFile } from "node:child_process";
+import { runProviderChecks, runProviderChecksAsync, summariseProviderIssues } from "./doctor-providers.js";
 import { runEnvironmentChecks, runEnvironmentChecksAsync } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { nativeIsRepo, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeCommitSubject } from "./native-git-bridge.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
 import { projectRoot } from "./commands/context.js";
 import { buildHealthLines, detectHealthWidgetProjectState, } from "./health-widget-core.js";
 export const HEALTH_WIDGET_ACTIVE_HINTS = "  /gsd auto to run  ·  /gsd status to inspect  ·  /gsd report for snapshots  ·  /gsd notifications for history  ·  /gsd help";
+const LAST_COMMIT_LOOKUP_TIMEOUT_MS = 3_000;
+const REFRESH_INTERVAL_MS = 60_000;
+const PROJECT_STATE_CACHE_TTL_MS = REFRESH_INTERVAL_MS;
 // ── Data loader ────────────────────────────────────────────────────────────────
-// Last-commit lookup is subprocess-backed (native-git-bridge → git spawns),
-// so it is treated like the other expensive checks: skipped on first paint,
-// run only by the background refresh.
-function loadLastCommitInfo(basePath) {
+const projectStateCache = new Map();
+export function getCachedProjectState(basePath, force) {
+    const now = Date.now();
+    const cached = projectStateCache.get(basePath);
+    if (!force && cached && now - cached.computedAt <= PROJECT_STATE_CACHE_TTL_MS) {
+        return cached.state;
+    }
+    const state = detectHealthWidgetProjectState(basePath);
+    projectStateCache.set(basePath, { state, computedAt: now });
+    return state;
+}
+function runHealthWidgetGit(basePath, args) {
+    return new Promise((resolve) => {
+        const child = execFile("git", args, {
+            cwd: basePath,
+            timeout: LAST_COMMIT_LOOKUP_TIMEOUT_MS,
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        }, (err, stdout) => resolve(err ? null : String(stdout).trimEnd()));
+        child.on("error", () => resolve(null));
+    });
+}
+async function loadLastCommitInfoAsync(basePath) {
     try {
-        if (nativeIsRepo(basePath)) {
-            const branch = nativeGetCurrentBranch(basePath);
-            const epoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
-            if (epoch > 0) {
-                return { epoch, message: nativeCommitSubject(basePath, branch || "HEAD") || null };
-            }
+        if ((await runHealthWidgetGit(basePath, ["rev-parse", "--git-dir"])) === null) {
+            return { epoch: null, message: null };
         }
+        const branch = await runHealthWidgetGit(basePath, ["branch", "--show-current"]);
+        const ref = branch || "HEAD";
+        const raw = await runHealthWidgetGit(basePath, ["log", "-1", "--format=%ct%x00%s", ref]);
+        if (!raw)
+            return { epoch: null, message: null };
+        const separator = raw.indexOf("\0");
+        const epochText = separator >= 0 ? raw.slice(0, separator) : raw;
+        const epoch = parseInt(epochText.trim(), 10) || 0;
+        if (epoch <= 0)
+            return { epoch: null, message: null };
+        const message = separator >= 0 ? raw.slice(separator + 1).trim() : "";
+        return { epoch, message: message || null };
+    }
+    catch {
+        return { epoch: null, message: null };
     }
-    catch { /* non-fatal */ }
-    return { epoch: null, message: null };
 }
 function loadHealthWidgetData(basePath, options) {
     // `includeChecks` gates the expensive subprocess-backed checks (provider +
@@ -38,7 +70,7 @@ function loadHealthWidgetData(basePath, options) {
     let environmentWarningCount = 0;
     let lastCommitEpoch = null;
     let lastCommitMessage = null;
-    const projectState = detectHealthWidgetProjectState(basePath);
+    const projectState = getCachedProjectState(basePath, options?.forceProjectState);
     try {
         const prefs = loadEffectiveGSDPreferences();
         budgetCeiling = prefs?.preferences?.budget_ceiling;
@@ -66,12 +98,6 @@ function loadHealthWidgetData(basePath, options) {
         }
         catch { /* non-fatal */ }
     }
-    // ── Last commit info ── (git spawns — gated like the other expensive checks)
-    if (includeChecks) {
-        const commit = loadLastCommitInfo(basePath);
-        lastCommitEpoch = commit.epoch;
-        lastCommitMessage = commit.message;
-    }
     return {
         projectState,
         budgetCeiling,
@@ -85,17 +111,15 @@ function loadHealthWidgetData(basePath, options) {
     };
 }
 // Non-blocking variant used by the widget's background refresh: the cheap fields
-// come from the synchronous snapshot, then provider + environment checks are
-// layered in off the event-loop critical path (env checks run concurrently via
-// runEnvironmentChecksAsync). Keeps the always-on widget from stalling the UI on
-// its initial enrichment or its 60s refresh.
+// come from the synchronous snapshot, then provider, environment, and last-commit
+// checks are layered in off the event-loop critical path.
 async function loadHealthWidgetDataAsync(basePath) {
     const data = loadHealthWidgetData(basePath, { includeChecks: false });
     let providerIssue = data.providerIssue;
     let environmentErrorCount = 0;
     let environmentWarningCount = 0;
     try {
-        providerIssue = summariseProviderIssues(runProviderChecks());
+        providerIssue = summariseProviderIssues(await runProviderChecksAsync());
     }
     catch { /* non-fatal */ }
     try {
@@ -108,7 +132,7 @@ async function loadHealthWidgetDataAsync(basePath) {
         }
     }
     catch { /* non-fatal */ }
-    const commit = loadLastCommitInfo(basePath);
+    const commit = await loadLastCommitInfoAsync(basePath);
     return {
         ...data,
         providerIssue,
@@ -120,7 +144,6 @@ async function loadHealthWidgetDataAsync(basePath) {
     };
 }
 // ── Widget init ────────────────────────────────────────────────────────────────
-const REFRESH_INTERVAL_MS = 60_000;
 /**
  * Initialize the always-on gsd-health widget (belowEditor).
  * Call once from the extension entry point after context is available.
@@ -129,13 +152,16 @@ export function initHealthWidget(ctx) {
     if (!ctx.hasUI)
         return;
     const basePath = projectRoot();
+    // Re-init must reflect filesystem changes immediately; the TTL cache is for
+    // interval refreshes, not this one-off synchronous paint.
+    projectStateCache.delete(basePath);
     // String-array fallback — used in RPC mode (factory is a no-op there).
     // Skip the expensive provider/environment doctor checks here: this runs
     // synchronously on the interactive-startup path, where running them would
     // block first paint by ~0.9s (lsof/docker probes, otherwise run again
     // immediately by the factory below). The factory's async refresh fills in
     // real health once the screen is up.
-    const initialData = loadHealthWidgetData(basePath, { includeChecks: false });
+    const initialData = loadHealthWidgetData(basePath, { includeChecks: false, forceProjectState: true });
     ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
     // Factory-based widget for TUI mode — replaces the string-array above
     ctx.ui.setWidget("gsd-health", (_tui, _theme) => {

package/dist/resources/extensions/gsd/layout-policy.js

@@ -40,8 +40,10 @@ export function dbPath(basePath) {
  * Used by the renderer to derive the phase number from the DB's milestone_id.
  */
 export function milestoneIdToPhaseNum(milestoneId) {
-    // No $ anchor: accepts bare (M012) and team-suffixed (M012-abc123) IDs.
+    // No $ anchor: accepts bare (M012), team-suffixed (M012-abc123), and legacy numeric IDs.
     const m = milestoneId.match(/^M0*(\d+)/i);
+    if (!m && /^\d+$/.test(milestoneId))
+        return Number.parseInt(milestoneId, 10);
     return m ? Number.parseInt(m[1], 10) : 1;
 }
 /** Team-mode suffix from milestone ids like M001-abc123. */

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

@@ -12,7 +12,7 @@ import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from "node:
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
-import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, } from "./gsd-db.js";
+import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, gsdProjectionRoot, gsdRoot, buildMilestoneFileName, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
@@ -518,13 +518,8 @@ export async function renderRoadmapFromDb(basePath, milestoneId) {
  * @returns true if the roadmap was written, false on skip/error
  */
 export async function renderRoadmapCheckboxes(basePath, milestoneId) {
-    const slices = getMilestoneSlices(milestoneId);
-    if (slices.length === 0) {
-        process.stderr.write(`markdown-renderer: no slices found for milestone ${milestoneId}\n`);
-        return false;
-    }
-    await renderRoadmapFromDb(basePath, milestoneId);
-    return true;
+    const rendered = await renderRoadmapFromDb(basePath, milestoneId);
+    return !("skipped" in rendered);
 }
 /**
  * Project milestone-level artifacts (CONTEXT, RESEARCH, VALIDATION, etc.) from
@@ -604,11 +599,15 @@ function isAutoRecoveryPlaceholderPlan(content) {
  * projection (the 4S/0T-vs-5S/13T drift class). The artifacts table is an
  * output sink, never a render input.
  *
- * @returns true if the plan was written, false on skip/error
+ * @returns true if the plan was written, false when the DB slice has no tasks
+ * @throws when the DB connection is unavailable or the render write fails
  */
 export async function renderPlanCheckboxes(basePath, milestoneId, sliceId, outputPath) {
     const tasks = getSliceTasks(milestoneId, sliceId);
     if (tasks.length === 0) {
+        if (!isDbAvailable()) {
+            throw new Error(`database unavailable while rendering plan checkboxes for ${milestoneId}/${sliceId}`);
+        }
         process.stderr.write(`markdown-renderer: no tasks found for ${milestoneId}/${sliceId}\n`);
         return false;
     }

package/dist/resources/extensions/gsd/memory-consolidation-scanner.js

@@ -94,27 +94,48 @@ function getActiveDecisions() {
         return [];
     }
 }
-/**
- * True when a memory row has a `structured_fields` JSON payload containing
- * the given `markerKey: "value"` pair. Matches the LIKE pattern used by
- * `backfillDecisionsToMemories` so the scanner is consistent with the
- * backfill's idempotency check.
- */
-function memoryHasSourceMarker(markerKey, value) {
+function emptyMemorySourceMarkers() {
+    return { decisionIds: new Set(), knowledgeIds: new Set() };
+}
+function getMemorySourceMarkers() {
+    const markers = emptyMemorySourceMarkers();
     if (!isDbAvailable())
-        return false;
+        return markers;
     const adapter = _getAdapter();
     if (!adapter)
-        return false;
+        return markers;
     try {
-        const pattern = `%"${markerKey}":"${value}"%`;
-        const row = adapter
-            .prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1")
-            .get({ ":pattern": pattern });
-        return row !== undefined;
+        const rows = adapter
+            .prepare("SELECT structured_fields FROM memories WHERE structured_fields IS NOT NULL")
+            .all();
+        for (const row of rows) {
+            collectMemorySourceMarker(markers, row["structured_fields"]);
+        }
     }
     catch {
-        return false;
+        return markers;
+    }
+    return markers;
+}
+function collectMemorySourceMarker(markers, raw) {
+    if (typeof raw !== "string" || raw.length === 0)
+        return;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return;
+        const fields = parsed;
+        const decisionId = fields["sourceDecisionId"];
+        if (typeof decisionId === "string" && decisionId.length > 0) {
+            markers.decisionIds.add(decisionId);
+        }
+        const knowledgeId = fields["sourceKnowledgeId"];
+        if (typeof knowledgeId === "string" && knowledgeId.length > 0) {
+            markers.knowledgeIds.add(knowledgeId);
+        }
+    }
+    catch {
+        return;
     }
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -127,10 +148,14 @@ const SAMPLE_LIMIT = 5;
 export function scanConsolidationGaps(basePath) {
     // ── Decisions ────────────────────────────────────────────────────────
     const decisions = getActiveDecisions();
+    const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
+    const memorySourceMarkers = decisions.length > 0 || knowledgeRows.length > 0
+        ? getMemorySourceMarkers()
+        : emptyMemorySourceMarkers();
     const decisionSamples = [];
     let decisionMigrated = 0;
     for (const decision of decisions) {
-        if (memoryHasSourceMarker("sourceDecisionId", decision.id)) {
+        if (memorySourceMarkers.decisionIds.has(decision.id)) {
             decisionMigrated += 1;
             continue;
         }
@@ -142,16 +167,14 @@ export function scanConsolidationGaps(basePath) {
         }
     }
     // ── KNOWLEDGE.md ─────────────────────────────────────────────────────
-    const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
     const knowledgeByTable = { rules: 0, patterns: 0, lessons: 0 };
     const knowledgeSamples = [];
     let knowledgeMigrated = 0;
     for (const row of knowledgeRows) {
         knowledgeByTable[row.table] += 1;
-        // Phase 6 will introduce a `sourceKnowledgeId` marker as part of the
-        // KNOWLEDGE.md backfill. Until that path ships, this check returns
-        // false for every row, which is the honest state of the consolidation.
-        if (memoryHasSourceMarker("sourceKnowledgeId", row.id)) {
+        // KNOWLEDGE.md backfill writes `sourceKnowledgeId`; rows without that
+        // marker are still reported as consolidation gaps.
+        if (memorySourceMarkers.knowledgeIds.has(row.id)) {
             knowledgeMigrated += 1;
             continue;
         }

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

@@ -45,6 +45,27 @@ function scanHasExtraIdentities(a, b) {
         hasExtra(a.slices, b.slices) ||
         hasExtra(a.tasks, b.tasks));
 }
+function paddedMilestoneId(id) {
+    return /^\d+$/.test(id) ? `M${id.padStart(3, "0")}` : null;
+}
+function replaceSetPrefix(values, from, to) {
+    for (const value of [...values]) {
+        if (value !== from && !value.startsWith(`${from}/`))
+            continue;
+        values.delete(value);
+        values.add(`${to}${value.slice(from.length)}`);
+    }
+}
+function alignNumericMarkdownIdsWithDb(markdownScan, dbScan) {
+    for (const dbId of dbScan.milestones) {
+        const paddedId = paddedMilestoneId(dbId);
+        if (!paddedId || dbScan.milestones.has(paddedId) || !markdownScan.milestones.has(paddedId))
+            continue;
+        replaceSetPrefix(markdownScan.milestones, paddedId, dbId);
+        replaceSetPrefix(markdownScan.slices, paddedId, dbId);
+        replaceSetPrefix(markdownScan.tasks, paddedId, dbId);
+    }
+}
 /**
  * True when the DB holds any milestone/slice/task identity the markdown lacks —
  * i.e. a `/gsd recover --confirm` (markdown → DB) would DELETE authoritative DB
@@ -126,6 +147,7 @@ export async function checkMarkdownHierarchyAgainstDb(basePath) {
     refreshWorkflowDatabaseFromDisk();
     const dbScan = scanDbHierarchy();
     const beforeDb = dbScan.counts;
+    alignNumericMarkdownIdsWithDb(markdownScan, dbScan);
     // Discussion-phase scratch: a milestone dir with no ROADMAP and no DB row is
     // a pre-registration discussion artifact (CONTEXT/CONTEXT-DRAFT only — the
     // queued DB row is inserted only at discussion handoff). Treating it as

package/dist/resources/extensions/gsd/milestone-ids.js

@@ -123,7 +123,8 @@ export function clearReservedMilestoneIds() {
     reservedMilestoneIds.clear();
 }
 // ─── Discovery ──────────────────────────────────────────────────────────────
-function scanMilestoneIdsFromDir(dir) {
+function scanMilestoneIdsFromDir(basePath, dir) {
+    const legacyNumericIds = idsWithLegacyNumericDirs(basePath);
     return readdirSync(dir, { withFileTypes: true })
         .filter((d) => d.isDirectory())
         .map((d) => {
@@ -131,6 +132,12 @@ function scanMilestoneIdsFromDir(dir) {
         if (MILESTONE_ID_RE.test(d.name)) {
             return d.name;
         }
+        // Legacy recovery/imports may contain bare numeric milestone directories
+        // (for example `milestones/15/15-ROADMAP.md`). The DB can preserve that
+        // id, and rebuild renders it, so drift scans must see it too.
+        if (/^\d+$/.test(d.name)) {
+            return d.name;
+        }
         // Legacy layout: M001-abcdef-slug descriptor directories
         const legacyMatch = d.name.match(/^(M\d{3}(?:-[a-z0-9]{6})?)-/);
         if (legacyMatch) {
@@ -144,12 +151,35 @@ function scanMilestoneIdsFromDir(dir) {
             if (MILESTONE_ID_RE.test(fromSlug)) {
                 return fromSlug;
             }
+            const numericId = String(phaseNum);
+            if (legacyNumericIds.has(numericId)) {
+                return numericId;
+            }
             return `M${String(phaseNum).padStart(3, "0")}`;
         }
         return null;
     })
         .filter((id) => id !== null);
 }
+function idsWithLegacyNumericDirs(basePath) {
+    const legacyDir = join(gsdProjectionRoot(basePath), "milestones");
+    const ids = new Set();
+    try {
+        for (const entry of readdirSync(legacyDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && /^\d+$/.test(entry.name))
+                ids.add(entry.name);
+        }
+    }
+    catch (err) {
+        // A missing legacy directory is the common, benign case (nothing to
+        // consult). Only surface a real failure when the directory exists but
+        // could not be read.
+        if (existsSync(legacyDir)) {
+            logWarning("engine", `idsWithLegacyNumericDirs: ${legacyDir} exists but readdirSync failed — ${getErrorMessage(err)}`);
+        }
+    }
+    return ids;
+}
 /** Scan the milestones directory and return IDs sorted by queue order (or numeric fallback). */
 export function findMilestoneIds(basePath) {
     const root = gsdProjectionRoot(basePath);
@@ -163,7 +193,7 @@ export function findMilestoneIds(basePath) {
     const ids = new Set();
     for (const dir of dirs) {
         try {
-            for (const id of scanMilestoneIdsFromDir(dir))
+            for (const id of scanMilestoneIdsFromDir(basePath, dir))
                 ids.add(id);
         }
         catch (err) {

package/dist/resources/extensions/gsd/milestone-implementation-evidence.js

@@ -10,6 +10,8 @@ import { logWarning } from "./workflow-logger.js";
 import { resolveTasksDir } from "./paths.js";
 /** Large enough for unbounded milestone-history git log scans in big repos. */
 const GIT_LOG_MAX_BUFFER = 16 * 1024 * 1024;
+const LOG_FIELD_SEPARATOR = "\x1f";
+const LOG_RECORD_SEPARATOR = "\x1e";
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/`
  * files) in git history. The primary signal is the branch diff against the
@@ -179,7 +181,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Primary: path-scoped log against .gsd/milestones/<id>. Fast and unbounded
     // by depth when .gsd/ is tracked in git.
     const scoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
+        "log", "--full-diff", "--name-only", "--format=%x1e%H%x1f%B%x1f", "HEAD", "--", `.gsd/milestones/${milestoneId}`,
     ]);
     if (!scoped.ok)
         return scoped;
@@ -195,7 +197,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
     const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
-        "log", "--format=%H%x1f%B%x1e", "HEAD",
+        "log", "--name-only", "--format=%x1e%H%x1f%B%x1f", "HEAD",
     ]);
     if (!unscoped.ok)
         return scoped.matched ? scoped : unscoped;
@@ -280,8 +282,7 @@ function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId)
                 continue;
             if (commitMessageHasGsdTrailer(record.message))
                 continue;
-            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
-            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            const implementationFiles = record.files.map(normalizeRepoPath).filter(isImplementationPath);
             if (implementationFiles.length === 0)
                 continue;
             if (!implementationFiles.some((file) => hintSet.has(file)))
@@ -306,24 +307,28 @@ function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId)
     }
 }
 function getCommitRecords(basePath) {
-    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+    const logOutput = execFileSync("git", ["log", "--name-only", "--format=%x1e%H%x1f%P%x1f%cI%x1f%B%x1f", "HEAD"], {
         cwd: basePath,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
         maxBuffer: GIT_LOG_MAX_BUFFER,
     });
     return logOutput
-        .split("\x1e")
-        .map((record) => record.trim())
+        .split(LOG_RECORD_SEPARATOR)
         .filter(Boolean)
         .flatMap((record) => {
-        const parts = record.split("\x1f");
-        if (parts.length < 4)
+        const parts = record.split(LOG_FIELD_SEPARATOR);
+        if (parts.length < 5)
             return [];
-        const [hash, parents, committedAt, ...messageParts] = parts;
-        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+        const [hash, parents, committedAt] = parts;
+        const files = parseNameOnlyFiles(parts.at(-1) ?? "");
+        const message = parts.slice(3, -1).join(LOG_FIELD_SEPARATOR);
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message, files }];
     });
 }
+function parseNameOnlyFiles(rawFiles) {
+    return rawFiles.split(/\r?\n/).map((file) => file.trim()).filter(Boolean);
+}
 function isFullCommitSha(value) {
     return /^[0-9a-f]{40}$/i.test(value);
 }
@@ -336,23 +341,24 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             maxBuffer: GIT_LOG_MAX_BUFFER,
         });
         const records = logOutput
-            .split("\x1e")
-            .map((record) => record.trim())
+            .split(LOG_RECORD_SEPARATOR)
             .filter(Boolean)
             .flatMap((record) => {
-            const sep = record.indexOf("\x1f");
-            if (sep === -1)
+            const parts = record.split(LOG_FIELD_SEPARATOR);
+            if (parts.length < 3)
+                return [];
+            const hash = parts[0].trim();
+            if (!hash)
                 return [];
-            const hash = record.slice(0, sep).trim();
-            const message = record.slice(sep + 1);
-            return [{ hash, message }];
+            const files = parseNameOnlyFiles(parts.at(-1) ?? "");
+            const message = parts.slice(1, -1).join(LOG_FIELD_SEPARATOR);
+            return [{ message, files }];
         });
         const files = new Set();
         let matched = false;
-        for (const { hash, message } of records) {
+        for (const { message, files: commitFiles } of records) {
             if (!commitMessageHasGsdTrailer(message))
                 continue;
-            const commitFiles = getChangedFilesForCommit(basePath, hash);
             if (!commitMatchesMilestone(basePath, message, milestoneId, commitFiles))
                 continue;
             matched = true;