@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.738160b9

package/dist/resources/extensions/gsd/knowledge-backfill.js

@@ -24,8 +24,8 @@ import { logWarning } from "./workflow-logger.js";
  * - Idempotent (per-row): each migrated memory carries
  *   `structured_fields.sourceKnowledgeId = "<P|L>NNN"`. Rows whose ID is
  *   already present in the memory store are skipped.
- * - Best-effort: never throws. Logs and returns 0 on failure so a broken
- *   backfill cannot block agent startup.
+ * - Best-effort: never throws. Failed memory inserts are logged and skipped;
+ *   setup/read failures log and return 0 so backfill cannot block startup.
  * - Rules (K###) are intentionally skipped — they remain manually maintained
  *   in `KNOWLEDGE.md` per ADR-013.
  *
@@ -56,15 +56,22 @@ export function backfillKnowledgeToMemories(basePath) {
             const matchPattern = `%"sourceKnowledgeId":"${synth.id}"%`;
             if (checkExisting.get({ ":pattern": matchPattern }))
                 continue;
-            const id = createMemory({
-                category: synth.category,
-                content: synth.content,
-                scope: synth.scope,
-                confidence: 0.85,
-                structuredFields: synth.structuredFields,
-            });
-            if (id)
-                written += 1;
+            try {
+                const id = createMemory({
+                    category: synth.category,
+                    content: synth.content,
+                    scope: synth.scope,
+                    confidence: 0.85,
+                    structuredFields: synth.structuredFields,
+                });
+                if (id)
+                    written += 1;
+            }
+            catch (rowErr) {
+                const message = rowErr instanceof Error ? rowErr.message : String(rowErr);
+                logWarning("knowledge-backfill", `KNOWLEDGE.md -> memories backfill skipped ${synth.id}: ${message}`);
+                continue;
+            }
         }
         return written;
     }

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-backfill.js

@@ -33,8 +33,8 @@ import { logWarning } from "./workflow-logger.js";
  *   decision is checked individually; only decisions whose id is already
  *   present in the memory store are skipped. A user-authored memory with
  *   their own `sourceDecisionId` does NOT abort the backfill.
- * - Best-effort: never throws. Logs and returns 0 on failure so a broken
- *   backfill cannot block agent startup.
+ * - Best-effort: never throws. Failed memory inserts are logged and skipped;
+ *   setup/read failures log and return 0 so backfill cannot block startup.
  * - Full migration (ADR-013 Stage 2a): both active and superseded rows are
  *   migrated. `structured_fields.superseded_by` preserves the supersedes
  *   chain so the DECISIONS.md projection regen can source from memories
@@ -117,25 +117,32 @@ export function backfillDecisionsToMemories() {
                 continue;
             }
             const content = synthesizeDecisionMemoryContent(row);
-            const id = createMemory({
-                category: "architecture",
-                content,
-                scope: row.scope || "project",
-                confidence: 0.85,
-                structuredFields: {
-                    sourceDecisionId: row.id,
-                    when_context: row.when_context,
-                    scope: row.scope,
-                    decision: row.decision,
-                    choice: row.choice,
-                    rationale: row.rationale,
-                    made_by: row.made_by,
-                    revisable: row.revisable,
-                    superseded_by: row.superseded_by,
-                },
-            });
-            if (id)
-                written += 1;
+            try {
+                const id = createMemory({
+                    category: "architecture",
+                    content,
+                    scope: row.scope || "project",
+                    confidence: 0.85,
+                    structuredFields: {
+                        sourceDecisionId: row.id,
+                        when_context: row.when_context,
+                        scope: row.scope,
+                        decision: row.decision,
+                        choice: row.choice,
+                        rationale: row.rationale,
+                        made_by: row.made_by,
+                        revisable: row.revisable,
+                        superseded_by: row.superseded_by,
+                    },
+                });
+                if (id)
+                    written += 1;
+            }
+            catch (rowErr) {
+                const message = rowErr instanceof Error ? rowErr.message : String(rowErr);
+                logWarning("memory-backfill", `decisions->memories backfill skipped ${row.id}: ${message}`);
+                continue;
+            }
         }
         if (healed > 0) {
             logWarning("memory-backfill", `decisions->memories drift healed: ${healed} row${healed === 1 ? "" : "s"} updated superseded_by`);

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/metrics.js

@@ -17,7 +17,7 @@ import { join } from "node:path";
 import { openSync, closeSync, unlinkSync, statSync, writeFileSync } from "node:fs";
 import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
-import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
+import { loadJsonFile, loadJsonFileOrNull, saveJsonFileCompact } from "./json-persistence.js";
 import { parseUnitId } from "./unit-id.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -636,7 +636,7 @@ export function pruneMetricsLedger(base, keepCount) {
         return 0;
     const removed = disk.units.length - keepCount;
     disk.units = keepNewestUnits(disk.units, keepCount);
-    saveJsonFile(metricsPath(base), disk);
+    saveJsonFileCompact(metricsPath(base), disk);
     // Keep the in-memory ledger in sync if it is loaded for this session.
     if (ledger) {
         ledger.units = keepNewestUnits(ledger.units, keepCount);
@@ -799,7 +799,7 @@ function saveLedger(base, data) {
                 : dataUnits;
             merged.sort(compareUnitsByTime);
             data.units = keepNewestUnits(merged);
-            saveJsonFile(path, data);
+            saveJsonFileCompact(path, data);
         }
         finally {
             releaseLock(lockPath);
@@ -813,6 +813,6 @@ function saveLedger(base, data) {
         // read-merge-write sequence without mutual exclusion.
         logWarning("fs", "saveLedger: lock not acquired — falling back to direct write (no merge)");
         data.units = keepNewestUnits(data.units);
-        saveJsonFile(path, data);
+        saveJsonFileCompact(path, data);
     }
 }

package/dist/resources/extensions/gsd/migrate-external.js

@@ -110,6 +110,7 @@ export function migrateToExternalState(basePath) {
         }
         // Copy contents to external dir, skipping worktrees/
         const entries = readdirSync(migratingPath, { withFileTypes: true });
+        const copyFailures = [];
         for (const entry of entries) {
             if (entry.name === "worktrees")
                 continue; // worktrees stay local
@@ -123,10 +124,18 @@ export function migrateToExternalState(basePath) {
                     cpSync(src, dst, { force: true });
                 }
             }
-            catch {
-                // Non-fatal: continue with other files
+            catch (copyErr) {
+                copyFailures.push(`${entry.name}: ${getErrorMessage(copyErr)}`);
             }
         }
+        if (copyFailures.length > 0) {
+            try {
+                rmSync(localGsd, { force: true });
+            }
+            catch { /* may not exist */ }
+            renameSync(migratingPath, localGsd);
+            return { migrated: false, error: `Migration copy failed: ${copyFailures.join("; ")}` };
+        }
         // Create symlink .gsd -> external path
         symlinkSync(externalPath, localGsd, "junction");
         // Verify the symlink resolves correctly before removing the backup (#1377).

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;