@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/git-service.ts

@@ -12,12 +12,13 @@
 
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import type { Dirent } from "node:fs";
 import { isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { logWarning } from "./workflow-logger.js";
-import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
+import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "./repository-registry.js";
 import { isGsdGitignored } from "./gitignore.js";
 
 
@@ -360,6 +361,7 @@ export interface PreMergeCheckResult {
  */
 export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
   ".gsd-worktrees/",
+  ".gsd-backups/**",
   ".gsd/activity/",
   ".gsd/audit/",
   ".gsd/forensics/",
@@ -1264,19 +1266,80 @@ export function handleTurnGitActionError(action: TurnGitActionMode, err: unknown
   };
 }
 
+export function isRepositoryDirty(repoRoot: string): boolean {
+  try {
+    return runGit(repoRoot, ["status", "--porcelain"]).length > 0;
+  } catch {
+    // Fallback preserves legacy behavior if explicit status probing fails.
+    return nativeHasChanges(repoRoot);
+  }
+}
+
 function collectRepositoryDirtyStatus(basePath: string): Record<string, boolean> {
   const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
   const registry = createRepositoryRegistryFromPreferences(basePath, preferences);
   const dirtyByRepository: Record<string, boolean> = {};
+  const registeredRoots = new Set(registry.repositories.map((repo) => resolve(repo.root)));
   for (const repo of registry.repositories) {
+    dirtyByRepository[repo.id] = isRepositoryDirty(repo.root);
+  }
+  for (const repoRoot of findUndeclaredNestedGitRepositories(registry.projectRoot, registeredRoots)) {
+    const dirty = isRepositoryDirty(repoRoot);
+    if (!dirty) continue;
+
+    const relPath = relative(registry.projectRoot, repoRoot).split(sep).join("/") || repoRoot;
+    const label = `${relPath} (undeclared)`;
+    dirtyByRepository[label] = true;
+    logWarning(
+      "engine",
+      `undeclared dirty nested git repo ${relPath}; declare it under workspace.repositories or commit manually`,
+      { file: "git-service.ts" },
+    );
+  }
+  return dirtyByRepository;
+}
+
+const UNDECLARED_NESTED_REPO_SCAN_MAX_DEPTH = 4;
+const UNDECLARED_NESTED_REPO_SKIP_DIRS = new Set([
+  ".git",
+  ".gsd",
+  ".gsd-worktrees",
+  "node_modules",
+  "dist",
+  "dist-test",
+]);
+
+function findUndeclaredNestedGitRepositories(projectRoot: string, registeredRoots: ReadonlySet<string>): string[] {
+  const found: string[] = [];
+
+  function visit(dir: string, depth: number): void {
+    if (depth >= UNDECLARED_NESTED_REPO_SCAN_MAX_DEPTH) return;
+
+    let entries: Dirent[];
     try {
-      dirtyByRepository[repo.id] = runGit(repo.root, ["status", "--porcelain"]).length > 0;
+      entries = readdirSync(dir, { withFileTypes: true });
     } catch {
-      // Fallback preserves legacy behavior if explicit status probing fails.
-      dirtyByRepository[repo.id] = nativeHasChanges(repo.root);
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (UNDECLARED_NESTED_REPO_SKIP_DIRS.has(entry.name)) continue;
+
+      const child = join(dir, entry.name);
+      const childRoot = resolve(child);
+      const hasGitDir = existsSync(join(child, ".git"));
+      const isRegistered = registeredRoots.has(childRoot);
+      if (hasGitDir && !isRegistered) {
+        found.push(childRoot);
+        continue;
+      }
+      visit(child, depth + 1);
     }
   }
-  return dirtyByRepository;
+
+  visit(projectRoot, 0);
+  return found;
 }
 
 function runPerRepositoryCommitAction(args: {
@@ -1293,7 +1356,7 @@ function runPerRepositoryCommitAction(args: {
 } {
   const preferences = loadEffectiveGSDPreferences(args.basePath)?.preferences;
   const registry = createRepositoryRegistryFromPreferences(args.basePath, preferences);
-  const repoIds = args.targetRepositories?.length ? args.targetRepositories : ["project"];
+  const repoIds = args.targetRepositories?.length ? args.targetRepositories : defaultRepositoryTargets(registry);
   const gitPrefs = preferences?.git ?? {};
   const commitMessages: Record<string, string> = {};
   const commitErrors: Record<string, string> = {};
@@ -1381,9 +1444,7 @@ export function runTurnGitAction(args: {
       };
     }
 
-    const primaryMessage =
-      repoCommitResult.commitMessages[args.targetRepositories?.[0] ?? "project"]
-      ?? Object.values(repoCommitResult.commitMessages)[0];
+    const primaryMessage = Object.values(repoCommitResult.commitMessages)[0];
     return {
       action: args.action,
       status: "ok",

package/src/resources/extensions/gsd/gitignore.ts

@@ -24,8 +24,9 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
  * With external state (symlink), these are a no-op in most cases,
  * but retained for backwards compatibility during migration.
  */
-const GSD_RUNTIME_PATTERNS = [
+export const GSD_RUNTIME_PATTERNS = [
   ".gsd-worktrees/",
+  ".gsd-backups/",
   ".gsd/activity/",
   ".gsd/audit/",
   ".gsd/forensics/",
@@ -51,6 +52,8 @@ const BASELINE_PATTERNS = [
   ".gsd",
   // Worktree container sibling — NOT covered by the ".gsd" pattern above.
   ".gsd-worktrees/",
+  // Flat-phase migration snapshots — NOT covered by the ".gsd" pattern above.
+  ".gsd-backups/",
   ".gsd-id",
   ".mcp.json",
   ".bg-shell/",

package/src/resources/extensions/gsd/guidance.ts

@@ -209,6 +209,8 @@ const DOCTOR_FIX_HINTS: Partial<Record<DoctorIssueCode, string>> = {
   state_file_stale: "Run `/gsd doctor fix` to rebuild the projection from the database.",
   state_file_missing: "Run `/gsd doctor fix` to rebuild the projection from the database.",
   projection_drift: "Run `/gsd doctor fix` to rebuild markdown projections from the database (DB is the source of truth).",
+  artifact_user_content_missing:
+    "Doctor cannot recreate user-authored content from the database. Re-run `/gsd discuss` for CONTEXT artifacts or `/gsd auto` for RESEARCH artifacts in that milestone.",
   uat_retry_exhausted: "Review the failing UAT criteria via `/gsd status`, fix the issue, then re-run `/gsd auto`.",
 };
 

package/src/resources/extensions/gsd/guided-flow-queue.ts

@@ -360,24 +360,31 @@ function capExistingMilestonesContext(
   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 compactSections = sections.map(compactSectionForQueueBudget);
-  const selected: string[] = [];
+  const noticeSuffix = `${QUEUE_CONTEXT_SECTION_SEPARATOR}${notice}`;
 
-  for (let i = 0; i < sections.length; i++) {
-    const withFullSection = [
-      ...selected,
-      sections[i],
-      ...compactSections.slice(i + 1),
-      notice,
-    ].join(QUEUE_CONTEXT_SECTION_SEPARATOR);
+  const selected: string[] = [];
+  for (const section of sections) {
+    const candidate = [...selected, section].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    if (candidate.length <= cap) {
+      selected.push(section);
+      continue;
+    }
+    break;
+  }
 
-    selected.push(withFullSection.length <= cap ? sections[i] : compactSections[i]);
+  if (selected.length === sections.length) {
+    return selected.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
   }
 
-  const capped = [...selected, notice].join(QUEUE_CONTEXT_SECTION_SEPARATOR);
-  if (capped.length <= cap) return capped;
+  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 `${capped.slice(0, Math.max(0, cap - notice.length - 2)).trimEnd()}\n\n${notice}`;
+  return `${compactContext.slice(0, Math.max(0, cap - notice.length - 2)).trimEnd()}\n\n${notice}`;
 }
 
 function compactSectionForQueueBudget(section: string): string {

package/src/resources/extensions/gsd/guided-flow.ts

@@ -42,7 +42,7 @@ import { gsdHome } from "./gsd-home.js";
 import {
   gsdRoot, milestonesDir, legacyMilestonesDir, resolveMilestoneFile,
   resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile,
-  relMilestoneFile, relSliceFile,
+  relMilestoneFile, relSliceFile, clearPathCache,
 } from "./paths.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
@@ -101,6 +101,7 @@ import {
   formatPriorContextBrief,
 } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
+import { countPlanMilestoneRoadmapSlices } from "./artifact-verification.js";
 import type { MilestoneScope } from "./workspace.js";
 import { clearPendingGate, extractDepthVerificationMilestoneId, getPendingGate } from "./bootstrap/write-gate.js";
 import {
@@ -164,7 +165,7 @@ export const _scheduleAutoStartAfterIdleForTest = scheduleAutoStartAfterIdle;
 // These thin wrappers accept a MilestoneScope so callers that already hold a
 // pinned scope never have to re-derive (basePath, milestoneId) separately.
 // The underlying implementations in auto-recovery.ts / auto-artifact-paths.ts /
-// state.ts are unchanged — only the call surface in guided-flow.ts is migrated.
+// state.ts remain the default for non-scope-specific units.
 
 /**
  * Scope-based overload of verifyExpectedArtifact.
@@ -176,9 +177,47 @@ export function verifyExpectedArtifactForScope(
   unitType: string,
   unitId: string,
 ): boolean {
+  if (
+    unitId === scope.milestoneId &&
+    (unitType === "discuss-milestone" || unitType === "plan-milestone")
+  ) {
+    // Layout-aware scope paths use resolveMilestoneFile; clear stale dir listings
+    // primed before discuss/plan wrote CONTEXT.md or ROADMAP.md (see checkAutoStartAfterDiscuss).
+    clearPathCache();
+  }
+  if (
+    unitId === scope.milestoneId &&
+    unitType === "discuss-milestone"
+  ) {
+    const path = resolveExpectedArtifactPathForScope(scope, unitType, unitId);
+    return path ? existsSync(path) : false;
+  }
+  if (unitId === scope.milestoneId && unitType === "plan-milestone") {
+    const path = resolveExpectedArtifactPathForScope(scope, unitType, unitId);
+    return verifyScopedPlanMilestoneArtifact(path, unitType, unitId);
+  }
   return verifyExpectedArtifact(unitType, unitId, scope.workspace.projectRoot);
 }
 
+function verifyScopedPlanMilestoneArtifact(
+  path: string | null,
+  unitType: string,
+  unitId: string,
+): boolean {
+  if (!path || !existsSync(path)) return false;
+  try {
+    const roadmapContent = readFileSync(path, "utf-8");
+    if (countPlanMilestoneRoadmapSlices(roadmapContent) === 0) {
+      logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${path}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+
 /**
  * Scope-based overload of resolveExpectedArtifactPath.
  * Returns the canonical absolute path (or null) using the scope's projectRoot.
@@ -188,6 +227,10 @@ export function resolveExpectedArtifactPathForScope(
   unitType: string,
   unitId: string,
 ): string | null {
+  if (unitId === scope.milestoneId) {
+    if (unitType === "discuss-milestone") return scope.contextFile();
+    if (unitType === "plan-milestone") return scope.roadmapFile();
+  }
   return resolveExpectedArtifactPath(unitType, unitId, scope.workspace.projectRoot);
 }
 

package/src/resources/extensions/gsd/json-persistence.ts

@@ -62,6 +62,26 @@ export function saveJsonFile<T>(filePath: string, data: T): void {
   }
 }
 
+/**
+ * Save a JSON file atomically using compact serialization.
+ *
+ * Intended for machine-only ledgers where pretty-printing has no consumer.
+ * Keeps the same write-tmp-rename safety and non-fatal error behavior as
+ * saveJsonFile.
+ */
+export function saveJsonFileCompact<T>(filePath: string, data: T): void {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    // Use randomized tmp suffix to prevent concurrent-write data loss
+    const tmp = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, JSON.stringify(data) + "\n", "utf-8");
+    renameSync(tmp, filePath);
+    // No cleanup needed — renameSync atomically removes tmp on success
+  } catch {
+    // Non-fatal — don't let persistence failures break operation
+  }
+}
+
 /**
  * Write a JSON file atomically (write to .tmp, then rename).
  * Creates parent directories as needed. Non-fatal on error.

package/src/resources/extensions/gsd/key-manager.ts

@@ -43,6 +43,7 @@ export const PROVIDER_REGISTRY: ProviderInfo[] = [
   // must be in the canonical registry so all consumers see the same catalog.
   // See: https://github.com/open-gsd/gsd-pi/issues/4541
   { id: "claude-code",      label: "Claude Code CLI",         category: "llm",                                   authMode: "externalCli" },
+  { id: "cursor-agent",     label: "Cursor Agent",            category: "llm", envVar: "CURSOR_API_KEY",         authMode: "externalCli" },
   { id: "openai",           label: "OpenAI",                  category: "llm", envVar: "OPENAI_API_KEY",         prefixes: ["sk-"],     dashboardUrl: "platform.openai.com/api-keys" },
   { id: "github-copilot",   label: "GitHub Copilot",          category: "llm", envVar: "GITHUB_TOKEN",           authMode: "browserOAuth" },
   { id: "openai-codex",     label: "ChatGPT Plus/Pro (Codex)",category: "llm",                                   authMode: "browserOAuth" },

package/src/resources/extensions/gsd/knowledge-backfill.ts

@@ -35,8 +35,8 @@ interface SynthesizedRow {
  * - 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.
  *
@@ -69,14 +69,20 @@ export function backfillKnowledgeToMemories(basePath: string): number {
       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/src/resources/extensions/gsd/layout-policy.ts

@@ -47,8 +47,9 @@ export function dbPath(basePath: string): string {
  * Used by the renderer to derive the phase number from the DB's milestone_id.
  */
 export function milestoneIdToPhaseNum(milestoneId: string): number {
-  // 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;
 }
 

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -20,6 +20,7 @@ import {
   getSliceScopedArtifacts,
   getMilestoneSlices,
   getSliceTasks,
+  getTasksBySliceIds,
   getTask,
   getSlice,
   insertArtifact,
@@ -136,6 +137,12 @@ function meaningfulSection(value: string | null | undefined): string {
   return trimmed;
 }
 
+function renderGateFindings(gate: GateRow): string {
+  const findings = gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`;
+  if (gate.verdict !== "flag") return findings;
+  return `> **Warning:** Verdict: flag - concerns recorded below\n\n${findings}`;
+}
+
 function pushIndented(lines: string[], value: string, indent = "  "): void {
   for (const line of value.split("\n")) {
     lines.push(`${indent}${line}`);
@@ -356,7 +363,7 @@ function renderTaskPlanMarkdown(task: TaskRow, taskGates: GateRow[] = []): strin
     if (gate && gate.verdict !== "omitted") {
       lines.push(`## ${label}`);
       lines.push("");
-      lines.push(gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`);
+      lines.push(renderGateFindings(gate));
       lines.push("");
     }
   }
@@ -390,7 +397,7 @@ function renderSlicePlanMarkdown(slice: SliceRow, tasks: TaskRow[], gates: GateR
   if (q3 && q3.verdict !== "omitted") {
     lines.push("## Threat Surface");
     lines.push("");
-    lines.push(q3.findings.trim() || `- **Verdict:** ${q3.verdict}\n- **Rationale:** ${q3.rationale}`);
+    lines.push(renderGateFindings(q3));
     lines.push("");
   }
 
@@ -398,7 +405,7 @@ function renderSlicePlanMarkdown(slice: SliceRow, tasks: TaskRow[], gates: GateR
   if (q4 && q4.verdict !== "omitted") {
     lines.push("## Requirement Impact");
     lines.push("");
-    lines.push(q4.findings.trim() || `- **Verdict:** ${q4.verdict}\n- **Rationale:** ${q4.rationale}`);
+    lines.push(renderGateFindings(q4));
     lines.push("");
   }
 
@@ -632,16 +639,8 @@ export async function renderRoadmapCheckboxes(
   basePath: string,
   milestoneId: string,
 ): Promise<boolean> {
-  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);
 }
 
 /**
@@ -884,6 +883,17 @@ export async function renderAllFromDb(basePath: string): Promise<RenderAllResult
   const result: RenderAllResult = { rendered: 0, skipped: 0, errors: [] };
   const milestones = getAllMilestones();
 
+  // Pre-fetch slices once per milestone and batch-load all tasks in one query
+  // family, avoiding an N+1 (previously one task query per slice).
+  const slicesByMilestone = new Map<string, SliceRow[]>();
+  const slicePairs: Array<{ milestoneId: string; sliceId: string }> = [];
+  for (const milestone of milestones) {
+    const slices = getMilestoneSlices(milestone.id);
+    slicesByMilestone.set(milestone.id, slices);
+    for (const slice of slices) slicePairs.push({ milestoneId: milestone.id, sliceId: slice.id });
+  }
+  const tasksBySlice = getTasksBySliceIds(slicePairs);
+
   for (const milestone of milestones) {
     // Render roadmap checkboxes
     try {
@@ -902,8 +912,8 @@ export async function renderAllFromDb(basePath: string): Promise<RenderAllResult
       result.errors.push(`milestone artifacts ${milestone.id}: ${(err as Error).message}`);
     }
 
-    // Iterate slices
-    const slices = getMilestoneSlices(milestone.id);
+    // Iterate slices (pre-fetched above)
+    const slices = slicesByMilestone.get(milestone.id) ?? [];
     for (const slice of slices) {
       // Preserve slice-scoped artifacts imported from disk, including real PLAN
       // fallback content when task rows cannot regenerate it.
@@ -939,8 +949,8 @@ export async function renderAllFromDb(basePath: string): Promise<RenderAllResult
         );
       }
 
-      // Iterate tasks
-      const tasks = getSliceTasks(milestone.id, slice.id);
+      // Iterate tasks (batched above)
+      const tasks = tasksBySlice.get(`${milestone.id}\0${slice.id}`) ?? [];
       for (const task of tasks) {
         try {
           const ok = await renderTaskSummary(

package/src/resources/extensions/gsd/memory-backfill.ts

@@ -49,8 +49,8 @@ type DecisionContentFields = Pick<DecisionRow, "decision" | "choice" | "rational
  *   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
@@ -146,24 +146,30 @@ export function backfillDecisionsToMemories(): number {
       }
 
       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) {

package/src/resources/extensions/gsd/metrics.ts

@@ -19,7 +19,7 @@ import { openSync, closeSync, unlinkSync, statSync, writeFileSync } from "node:f
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 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";
@@ -873,7 +873,7 @@ export function pruneMetricsLedger(base: string, keepCount: number): number {
   if (!disk || disk.units.length <= 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);
@@ -1041,7 +1041,7 @@ function saveLedger(base: string, data: MetricsLedger): void {
           : dataUnits;
       merged.sort(compareUnitsByTime);
       data.units = keepNewestUnits(merged);
-      saveJsonFile(path, data);
+      saveJsonFileCompact(path, data);
     } finally {
       releaseLock(lockPath);
     }
@@ -1053,6 +1053,6 @@ function saveLedger(base: string, data: MetricsLedger): void {
     // 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/src/resources/extensions/gsd/migrate-external.ts

@@ -118,6 +118,7 @@ export function migrateToExternalState(basePath: string): MigrationResult {
 
     // Copy contents to external dir, skipping worktrees/
     const entries = readdirSync(migratingPath, { withFileTypes: true });
+    const copyFailures: string[] = [];
     for (const entry of entries) {
       if (entry.name === "worktrees") continue; // worktrees stay local
 
@@ -130,10 +131,15 @@ export function migrateToExternalState(basePath: string): MigrationResult {
         } else {
           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");
@@ -231,7 +237,7 @@ function isLocalGsdExternalStateJunction(basePath: string, localGsd: string): bo
  * Recover from a failed migration (`.gsd.migrating` exists).
  * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist, or removes an
  * orphaned staging directory when `.gsd` is already a verified external state
- * junction with intact current state.
+ * junction, or an intact real directory, with intact current state.
  */
 export function recoverFailedMigration(basePath: string): boolean {
   const localGsd = join(basePath, ".gsd");
@@ -239,8 +245,15 @@ export function recoverFailedMigration(basePath: string): boolean {
 
   if (!existsSync(migratingPath)) return false;
   if (existsSync(localGsd)) {
-    if (!isLocalGsdExternalStateJunction(basePath, localGsd)) return false;
     if (!isCurrentGsdStateIntactForMigratingCleanup(basePath)) return false;
+    if (!isLocalGsdExternalStateJunction(basePath, localGsd)) {
+      try {
+        const stat = lstatSync(localGsd);
+        if (!stat.isDirectory()) return false;
+      } catch {
+        return false;
+      }
+    }
     try {
       rmSync(migratingPath, { recursive: true, force: true });
       return true;