@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

package/src/resources/extensions/gsd/gsd-db.ts

@@ -25,7 +25,7 @@
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 import type { Decision, Requirement, GateRow, GateId, GateScope, GateStatus, GateVerdict } from "./types.js";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
 import type { GsdWorkspace, MilestoneScope } from "./workspace.js";
@@ -760,6 +760,28 @@ export function checkpointDatabase(): void {
   } catch (e) { logWarning("db", `WAL checkpoint failed: ${(e as Error).message}`); }
 }
 
+/**
+ * Copy the live database file to `.gsd/backups/<label>-<timestamp>.db` so a
+ * destructive operation (e.g. recover, which clears the hierarchy tables) is
+ * reversible. Checkpoints the WAL first so the snapshot is complete. Returns
+ * the backup path, or null if no DB is open or the copy failed.
+ */
+export function backupDatabaseSnapshot(label: string): string | null {
+  if (!currentPath) return null;
+  try {
+    checkpointDatabase();
+    const backupsDir = join(dirname(currentPath), "backups");
+    mkdirSync(backupsDir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const dest = join(backupsDir, `${label}-${stamp}.db`);
+    copyFileSync(currentPath, dest);
+    return dest;
+  } catch (e) {
+    logWarning("db", `database snapshot failed: ${(e as Error).message}`);
+    return null;
+  }
+}
+
 const _transactionRunner = createDbTransactionRunner();
 
 function createTransactionControls(db: DbAdapter) {
@@ -1260,14 +1282,14 @@ export function insertTask(t: {
       milestone_id, slice_id, id, title, status, one_liner, narrative,
       verification_result, duration, completed_at, blocker_discovered,
       deviations, known_issues, key_files, key_decisions, full_summary_md,
-      description, estimate, files, verify, inputs, expected_output, observability_impact, sequence
-      , target_repositories
+      description, estimate, files, verify, inputs, expected_output,
+      observability_impact, full_plan_md, target_repositories, sequence
     ) VALUES (
       :milestone_id, :slice_id, :id, :title, :status, :one_liner, :narrative,
       :verification_result, :duration, :completed_at, :blocker_discovered,
       :deviations, :known_issues, :key_files, :key_decisions, :full_summary_md,
-      :description, :estimate, :files, :verify, :inputs, :expected_output, :observability_impact, :sequence
-      , :target_repositories
+      :description, :estimate, :files, :verify, :inputs, :expected_output,
+      :observability_impact, :full_plan_md, :target_repositories, :sequence
     )
     ON CONFLICT(milestone_id, slice_id, id) DO UPDATE SET
       title = CASE WHEN NULLIF(:title, '') IS NOT NULL THEN :title ELSE tasks.title END,
@@ -1290,6 +1312,7 @@ export function insertTask(t: {
       inputs = CASE WHEN NULLIF(:inputs, '[]') IS NOT NULL THEN :inputs ELSE tasks.inputs END,
       expected_output = CASE WHEN NULLIF(:expected_output, '[]') IS NOT NULL THEN :expected_output ELSE tasks.expected_output END,
       observability_impact = CASE WHEN NULLIF(:observability_impact, '') IS NOT NULL THEN :observability_impact ELSE tasks.observability_impact END,
+      full_plan_md = CASE WHEN NULLIF(:full_plan_md, '') IS NOT NULL THEN :full_plan_md ELSE tasks.full_plan_md END,
       sequence = :sequence,
       target_repositories = CASE
         WHEN :raw_target_repositories IS NOT NULL THEN :target_repositories
@@ -1319,6 +1342,7 @@ export function insertTask(t: {
     ":inputs": JSON.stringify(t.planning?.inputs ?? []),
     ":expected_output": JSON.stringify(t.planning?.expectedOutput ?? []),
     ":observability_impact": t.planning?.observabilityImpact ?? "",
+    ":full_plan_md": t.planning?.fullPlanMd ?? "",
     ":sequence": t.sequence ?? 0,
     ":target_repositories": JSON.stringify(t.planning?.targetRepositories ?? []),
     ":raw_target_repositories":
@@ -1855,7 +1879,13 @@ export interface ReconcileResult {
   slices: number;
   tasks: number;
   memories: number;
+  replan_history: number;
+  assessments: number;
+  quality_gates: number;
+  slice_dependencies: number;
   verification_evidence: number;
+  gate_runs: number;
+  milestone_commit_attributions: number;
   conflicts: string[];
 }
 
@@ -1863,7 +1893,23 @@ export function reconcileWorktreeDb(
   mainDbPath: string,
   worktreeDbPath: string,
 ): ReconcileResult {
-  const zero: ReconcileResult = { decisions: 0, requirements: 0, artifacts: 0, milestones: 0, slices: 0, tasks: 0, memories: 0, verification_evidence: 0, conflicts: [] };
+  const zero: ReconcileResult = {
+    decisions: 0,
+    requirements: 0,
+    artifacts: 0,
+    milestones: 0,
+    slices: 0,
+    tasks: 0,
+    memories: 0,
+    replan_history: 0,
+    assessments: 0,
+    quality_gates: 0,
+    slice_dependencies: 0,
+    verification_evidence: 0,
+    gate_runs: 0,
+    milestone_commit_attributions: 0,
+    conflicts: [],
+  };
   if (!existsSync(worktreeDbPath)) return zero;
   // Guard: bail when both paths resolve to the same physical file.
   // ATTACHing a WAL-mode DB to itself corrupts the WAL (#2823).
@@ -1889,224 +1935,398 @@ export function reconcileWorktreeDb(
   try {
     adapter.exec(`ATTACH DATABASE '${worktreeDbPath}' AS wt`);
     try {
-      const wtInfo = adapter.prepare("PRAGMA wt.table_info('decisions')").all();
+      function countChanges(result: unknown): number {
+        return typeof result === "object" && result !== null ? ((result as { changes?: number }).changes ?? 0) : 0;
+      }
+
+      function wtTableInfo(tableName: string): Array<Record<string, unknown>> {
+        return adapter.prepare(`PRAGMA wt.table_info('${tableName}')`).all() as Array<Record<string, unknown>>;
+      }
+
+      const wtInfo = wtTableInfo("decisions");
+      const hasWtDecisions = wtInfo.length > 0;
       const hasMadeBy = wtInfo.some((col) => col["name"] === "made_by");
       // ADR-011: worktree may predate schema v16/v17. For missing columns we
       // fall through to the main DB's existing value (not a literal default)
       // so reconcile never silently clears state the main tree has recorded.
       const hasDecisionSource = wtInfo.some((col) => col["name"] === "source");
-      const wtMilestoneInfo = adapter.prepare("PRAGMA wt.table_info('milestones')").all();
+      const wtRequirementInfo = wtTableInfo("requirements");
+      const hasWtRequirements = wtRequirementInfo.length > 0;
+      const wtMilestoneInfo = wtTableInfo("milestones");
+      const hasWtMilestones = wtMilestoneInfo.length > 0;
       const hasMilestoneSequence = wtMilestoneInfo.some((col) => col["name"] === "sequence");
-      const wtSliceInfo = adapter.prepare("PRAGMA wt.table_info('slices')").all();
+      const wtSliceInfo = wtTableInfo("slices");
+      const hasWtSlices = wtSliceInfo.length > 0;
       const hasIsSketch = wtSliceInfo.some((col) => col["name"] === "is_sketch");
       const hasSketchScope = wtSliceInfo.some((col) => col["name"] === "sketch_scope");
       const hasSliceTargetRepositories = wtSliceInfo.some((col) => col["name"] === "target_repositories");
-      const wtTaskInfo = adapter.prepare("PRAGMA wt.table_info('tasks')").all();
+      const wtTaskInfo = wtTableInfo("tasks");
+      const hasWtTasks = wtTaskInfo.length > 0;
       const hasTaskTargetRepositories = wtTaskInfo.some((col) => col["name"] === "target_repositories");
       const hasBlockerSource = wtTaskInfo.some((col) => col["name"] === "blocker_source");
       const hasEscalationPending = wtTaskInfo.some((col) => col["name"] === "escalation_pending");
       const hasEscalationAwaiting = wtTaskInfo.some((col) => col["name"] === "escalation_awaiting_review");
       const hasEscalationArtifact = wtTaskInfo.some((col) => col["name"] === "escalation_artifact_path");
       const hasEscalationOverride = wtTaskInfo.some((col) => col["name"] === "escalation_override_applied_at");
-      const wtArtifactInfo = adapter.prepare("PRAGMA wt.table_info('artifacts')").all();
-      const hasArtifactContentHash = wtArtifactInfo.some((col) => col["name"] === "content_hash");
-      const wtMemoryInfo = adapter.prepare("PRAGMA wt.table_info('memories')").all();
+      const wtArtifactInfo = wtTableInfo("artifacts");
+      const hasWtArtifacts = wtArtifactInfo.length > 0;
+      const wtMemoryInfo = wtTableInfo("memories");
+      const hasWtMemories = wtMemoryInfo.length > 0;
       const hasMemoryScope = wtMemoryInfo.some((col) => col["name"] === "scope");
       const hasMemoryTags = wtMemoryInfo.some((col) => col["name"] === "tags");
       const hasMemoryStructuredFields = wtMemoryInfo.some((col) => col["name"] === "structured_fields");
       const hasMemoryLastHitAt = wtMemoryInfo.some((col) => col["name"] === "last_hit_at");
+      const hasWtReplanHistory = wtTableInfo("replan_history").length > 0;
+      const hasWtAssessments = wtTableInfo("assessments").length > 0;
+      const hasWtQualityGates = wtTableInfo("quality_gates").length > 0;
+      const hasWtSliceDependencies = wtTableInfo("slice_dependencies").length > 0;
+      const hasWtVerificationEvidence = wtTableInfo("verification_evidence").length > 0;
+      const hasWtGateRuns = wtTableInfo("gate_runs").length > 0;
+      const hasWtMilestoneCommitAttributions = wtTableInfo("milestone_commit_attributions").length > 0;
+
+      if (hasWtDecisions) {
+        const decConf = adapter.prepare(
+          `SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${
+            hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"
+          } OR m.superseded_by IS NOT w.superseded_by`,
+        ).all();
+        for (const row of decConf) conflicts.push(`decision ${(row as Record<string, unknown>)["id"]}: modified in both`);
+      }
 
-      const decConf = adapter.prepare(
-        `SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${
-          hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"
-        } OR m.superseded_by IS NOT w.superseded_by`,
-      ).all();
-      for (const row of decConf) conflicts.push(`decision ${(row as Record<string, unknown>)["id"]}: modified in both`);
-
-      const reqConf = adapter.prepare(
-        `SELECT m.id FROM requirements m INNER JOIN wt.requirements w ON m.id = w.id WHERE m.description != w.description OR m.status != w.status OR m.notes != w.notes OR m.superseded_by IS NOT w.superseded_by`,
-      ).all();
-      for (const row of reqConf) conflicts.push(`requirement ${(row as Record<string, unknown>)["id"]}: modified in both`);
-
-      const merged: Omit<ReconcileResult, "conflicts"> = { decisions: 0, requirements: 0, artifacts: 0, milestones: 0, slices: 0, tasks: 0, memories: 0, verification_evidence: 0 };
-
-      function countChanges(result: unknown): number {
-        return typeof result === "object" && result !== null ? ((result as { changes?: number }).changes ?? 0) : 0;
+      if (hasWtRequirements) {
+        const reqConf = adapter.prepare(
+          `SELECT m.id FROM requirements m INNER JOIN wt.requirements w ON m.id = w.id WHERE m.description != w.description OR m.status != w.status OR m.notes != w.notes OR m.superseded_by IS NOT w.superseded_by`,
+        ).all();
+        for (const row of reqConf) conflicts.push(`requirement ${(row as Record<string, unknown>)["id"]}: modified in both`);
       }
 
+      const merged: Omit<ReconcileResult, "conflicts"> = {
+        decisions: 0,
+        requirements: 0,
+        artifacts: 0,
+        milestones: 0,
+        slices: 0,
+        tasks: 0,
+        memories: 0,
+        replan_history: 0,
+        assessments: 0,
+        quality_gates: 0,
+        slice_dependencies: 0,
+        verification_evidence: 0,
+        gate_runs: 0,
+        milestone_commit_attributions: 0,
+      };
+      const sliceTargetRepositoriesSql = hasSliceTargetRepositories
+        ? `CASE
+             WHEN w.target_repositories = '[]' AND COALESCE(m.target_repositories, '[]') <> '[]'
+             THEN m.target_repositories
+             ELSE COALESCE(w.target_repositories, m.target_repositories, '[]')
+           END`
+        : "COALESCE(m.target_repositories, '[]')";
+      const taskTargetRepositoriesSql = hasTaskTargetRepositories
+        ? `CASE
+             WHEN w.target_repositories = '[]' AND COALESCE(m.target_repositories, '[]') <> '[]'
+             THEN m.target_repositories
+             ELSE COALESCE(w.target_repositories, m.target_repositories, '[]')
+           END`
+        : "COALESCE(m.target_repositories, '[]')";
+
       adapter.exec("BEGIN");
       try {
         // Join the target decisions so we can prefer an existing main.source
         // when the worktree predates v16 — otherwise a write-through reconcile
         // would clobber 'escalation'-sourced decisions with the literal default.
-        merged.decisions = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO decisions (
-            id, when_context, scope, decision, choice, rationale, revisable, made_by, source, superseded_by
-          )
-          SELECT w.id, w.when_context, w.scope, w.decision, w.choice, w.rationale, w.revisable, ${
-            hasMadeBy ? "w.made_by" : "COALESCE(m.made_by, 'agent')"
-          }, ${
-            hasDecisionSource ? "w.source" : "COALESCE(m.source, 'discussion')"
-          }, w.superseded_by
-          FROM wt.decisions w
-          LEFT JOIN decisions m ON m.id = w.id
-        `).run());
-
-        merged.requirements = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO requirements (
-            id, class, status, description, why, source, primary_owner,
-            supporting_slices, validation, notes, full_content, superseded_by
-          )
-          SELECT id, class, status, description, why, source, primary_owner,
-                 supporting_slices, validation, notes, full_content, superseded_by
-          FROM wt.requirements
-        `).run());
-
-        // V27: preserve content_hash. If the worktree predates V27 (no column),
-        // fall back to the main DB's existing hash so reconcile doesn't null
-        // out integrity fingerprints on artifacts that were unchanged in wt.
-        merged.artifacts = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO artifacts (
-            path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at, content_hash
-          )
-          SELECT w.path, w.artifact_type, w.milestone_id, w.slice_id, w.task_id, w.full_content, w.imported_at,
-                 ${hasArtifactContentHash ? "w.content_hash" : "m.content_hash"}
-          FROM wt.artifacts w
-          LEFT JOIN artifacts m ON m.path = w.path
-        `).run());
+        if (hasWtDecisions) {
+          merged.decisions = countChanges(adapter.prepare(`
+            INSERT INTO decisions (
+              id, when_context, scope, decision, choice, rationale, revisable, made_by, source, superseded_by
+            )
+            SELECT w.id, w.when_context, w.scope, w.decision, w.choice, w.rationale, w.revisable, ${
+              hasMadeBy ? "w.made_by" : "COALESCE(m.made_by, 'agent')"
+            }, ${
+              hasDecisionSource ? "w.source" : "COALESCE(m.source, 'discussion')"
+            }, w.superseded_by
+            FROM wt.decisions w
+            LEFT JOIN decisions m ON m.id = w.id
+            WHERE true
+            ON CONFLICT(id) DO UPDATE SET
+              when_context = excluded.when_context,
+              scope = excluded.scope,
+              decision = excluded.decision,
+              choice = excluded.choice,
+              rationale = excluded.rationale,
+              revisable = excluded.revisable,
+              made_by = excluded.made_by,
+              source = excluded.source,
+              superseded_by = excluded.superseded_by
+          `).run());
+        }
+
+        if (hasWtRequirements) {
+          merged.requirements = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO requirements (
+              id, class, status, description, why, source, primary_owner,
+              supporting_slices, validation, notes, full_content, superseded_by
+            )
+            SELECT id, class, status, description, why, source, primary_owner,
+                   supporting_slices, validation, notes, full_content, superseded_by
+            FROM wt.requirements
+          `).run());
+        }
+
+        // Always recompute artifact hashes from the content being merged. Older
+        // worktree DBs may not have content_hash at all, and migrated old DBs can
+        // carry stale default/null hashes after their content changed.
+        if (hasWtArtifacts) {
+          const artifactRows = adapter.prepare(`
+            SELECT path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
+            FROM wt.artifacts
+          `).all() as Array<Record<string, unknown>>;
+          const artifactStmt = adapter.prepare(`
+            INSERT OR REPLACE INTO artifacts (
+              path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at, content_hash
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          `);
+          for (const row of artifactRows) {
+            const fullContent = String(row["full_content"] ?? "");
+            merged.artifacts += countChanges(artifactStmt.run(
+              row["path"],
+              row["artifact_type"],
+              row["milestone_id"] ?? null,
+              row["slice_id"] ?? null,
+              row["task_id"] ?? null,
+              fullContent,
+              row["imported_at"],
+              createHash("sha256").update(fullContent).digest("hex"),
+            ));
+          }
+        }
 
         // Merge milestones — worktree may have updated status/planning fields.
         // Never downgrade status: complete > active > pre-planning (#4372).
         // A stale worktree may carry an older 'active' status for a milestone
         // that the main DB has already marked 'complete'; preserve the higher status.
-        merged.milestones = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO milestones (
-            id, title, status, depends_on, created_at, completed_at,
-            vision, success_criteria, key_risks, proof_strategy,
-            verification_contract, verification_integration, verification_operational, verification_uat,
-            definition_of_done, requirement_coverage, boundary_map_markdown, sequence
-          )
-          SELECT w.id, w.title,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.status ELSE w.status
-                 END,
-                 w.depends_on,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.created_at ELSE w.created_at
-                 END,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.completed_at ELSE w.completed_at
-                 END,
-                 w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
-                 w.verification_contract, w.verification_integration, w.verification_operational, w.verification_uat,
-                 w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown,
-                 ${hasMilestoneSequence ? "COALESCE(w.sequence, 0)" : "COALESCE(m.sequence, 0)"}
-          FROM wt.milestones w
-          LEFT JOIN milestones m ON m.id = w.id
-        `).run());
+        if (hasWtMilestones) {
+          merged.milestones = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO milestones (
+              id, title, status, depends_on, created_at, completed_at,
+              vision, success_criteria, key_risks, proof_strategy,
+              verification_contract, verification_integration, verification_operational, verification_uat,
+              definition_of_done, requirement_coverage, boundary_map_markdown, sequence
+            )
+            SELECT w.id, w.title,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.status ELSE w.status
+                   END,
+                   w.depends_on,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.created_at ELSE w.created_at
+                   END,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.completed_at ELSE w.completed_at
+                   END,
+                   w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
+                   w.verification_contract, w.verification_integration, w.verification_operational, w.verification_uat,
+                   w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown,
+                   ${hasMilestoneSequence ? "COALESCE(w.sequence, 0)" : "COALESCE(m.sequence, 0)"}
+            FROM wt.milestones w
+            LEFT JOIN milestones m ON m.id = w.id
+          `).run());
+        }
 
         // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
         // ADR-011 Phase 1: carry is_sketch + sketch_scope so reconcile doesn't
         // silently clear sketch metadata. When the worktree predates v16,
         // fall back to the main DB's existing value rather than a literal 0/''.
-        merged.slices = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO slices (
-            milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
-            full_summary_md, full_uat_md, goal, success_criteria, proof_level,
-            integration_closure, observability_impact, target_repositories, sequence, replan_triggered_at,
-            is_sketch, sketch_scope
-          )
-          SELECT w.milestone_id, w.id, w.title,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.status ELSE w.status
-                 END,
-                 w.risk, w.depends, w.demo, w.created_at,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.completed_at ELSE w.completed_at
-                 END,
-                 w.full_summary_md, w.full_uat_md, w.goal, w.success_criteria, w.proof_level,
-                 w.integration_closure, w.observability_impact,
-                 ${hasSliceTargetRepositories ? "COALESCE(w.target_repositories, m.target_repositories, '[]')" : "COALESCE(m.target_repositories, '[]')"},
-                 w.sequence, w.replan_triggered_at,
-                 ${hasIsSketch ? "w.is_sketch" : "COALESCE(m.is_sketch, 0)"},
-                 ${hasSketchScope ? "w.sketch_scope" : "COALESCE(m.sketch_scope, '')"}
-          FROM wt.slices w
-          LEFT JOIN slices m ON m.milestone_id = w.milestone_id AND m.id = w.id
-        `).run());
+        if (hasWtSlices) {
+          merged.slices = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO slices (
+              milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
+              full_summary_md, full_uat_md, goal, success_criteria, proof_level,
+              integration_closure, observability_impact, target_repositories, sequence, replan_triggered_at,
+              is_sketch, sketch_scope
+            )
+            SELECT w.milestone_id, w.id, w.title,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.status ELSE w.status
+                   END,
+                   w.risk, w.depends, w.demo, w.created_at,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.completed_at ELSE w.completed_at
+                   END,
+                   w.full_summary_md, w.full_uat_md, w.goal, w.success_criteria, w.proof_level,
+                   w.integration_closure, w.observability_impact,
+                   ${sliceTargetRepositoriesSql},
+                   w.sequence, w.replan_triggered_at,
+                   ${hasIsSketch ? "w.is_sketch" : "COALESCE(m.is_sketch, 0)"},
+                   ${hasSketchScope ? "w.sketch_scope" : "COALESCE(m.sketch_scope, '')"}
+            FROM wt.slices w
+            LEFT JOIN slices m ON m.milestone_id = w.milestone_id AND m.id = w.id
+          `).run());
+        }
 
         // Merge tasks — preserve execution results, never downgrade completed status (#2558).
         // ADR-011 P2: carry blocker_source + escalation_* columns so worktree reconcile
         // doesn't silently clear escalation state back to defaults.
-        merged.tasks = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO tasks (
-            milestone_id, slice_id, id, title, status, one_liner, narrative,
-            verification_result, duration, completed_at, blocker_discovered,
-            deviations, known_issues, key_files, key_decisions, full_summary_md,
-            description, estimate, files, verify, inputs, expected_output,
-            observability_impact, full_plan_md, target_repositories, sequence,
-            blocker_source, escalation_pending, escalation_awaiting_review,
-            escalation_artifact_path, escalation_override_applied_at
-          )
-          SELECT w.milestone_id, w.slice_id, w.id, w.title,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.status ELSE w.status
-                 END,
-                 w.one_liner, w.narrative,
-                 w.verification_result, w.duration,
-                 CASE
-                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
-                   THEN m.completed_at ELSE w.completed_at
-                 END,
-                 w.blocker_discovered,
-                 w.deviations, w.known_issues, w.key_files, w.key_decisions, w.full_summary_md,
-                 w.description, w.estimate, w.files, w.verify, w.inputs, w.expected_output,
-                 w.observability_impact, w.full_plan_md,
-                 ${hasTaskTargetRepositories ? "COALESCE(w.target_repositories, m.target_repositories, '[]')" : "COALESCE(m.target_repositories, '[]')"},
-                 w.sequence,
-                 ${hasBlockerSource ? "w.blocker_source" : "COALESCE(m.blocker_source, '')"},
-                 ${hasEscalationPending ? "w.escalation_pending" : "COALESCE(m.escalation_pending, 0)"},
-                 ${hasEscalationAwaiting ? "w.escalation_awaiting_review" : "COALESCE(m.escalation_awaiting_review, 0)"},
-                 ${hasEscalationArtifact ? "w.escalation_artifact_path" : "m.escalation_artifact_path"},
-                 ${hasEscalationOverride ? "w.escalation_override_applied_at" : "m.escalation_override_applied_at"}
-          FROM wt.tasks w
-          LEFT JOIN tasks m ON m.milestone_id = w.milestone_id AND m.slice_id = w.slice_id AND m.id = w.id
-        `).run());
+        if (hasWtTasks) {
+          merged.tasks = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO tasks (
+              milestone_id, slice_id, id, title, status, one_liner, narrative,
+              verification_result, duration, completed_at, blocker_discovered,
+              deviations, known_issues, key_files, key_decisions, full_summary_md,
+              description, estimate, files, verify, inputs, expected_output,
+              observability_impact, full_plan_md, target_repositories, sequence,
+              blocker_source, escalation_pending, escalation_awaiting_review,
+              escalation_artifact_path, escalation_override_applied_at
+            )
+            SELECT w.milestone_id, w.slice_id, w.id, w.title,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.status ELSE w.status
+                   END,
+                   w.one_liner, w.narrative,
+                   w.verification_result, w.duration,
+                   CASE
+                     WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
+                     THEN m.completed_at ELSE w.completed_at
+                   END,
+                   w.blocker_discovered,
+                   w.deviations, w.known_issues, w.key_files, w.key_decisions, w.full_summary_md,
+                   w.description, w.estimate, w.files, w.verify, w.inputs, w.expected_output,
+                   w.observability_impact, w.full_plan_md,
+                   ${taskTargetRepositoriesSql},
+                   w.sequence,
+                   ${hasBlockerSource ? "w.blocker_source" : "COALESCE(m.blocker_source, '')"},
+                   ${hasEscalationPending ? "w.escalation_pending" : "COALESCE(m.escalation_pending, 0)"},
+                   ${hasEscalationAwaiting ? "w.escalation_awaiting_review" : "COALESCE(m.escalation_awaiting_review, 0)"},
+                   ${hasEscalationArtifact ? "w.escalation_artifact_path" : "m.escalation_artifact_path"},
+                   ${hasEscalationOverride ? "w.escalation_override_applied_at" : "m.escalation_override_applied_at"}
+            FROM wt.tasks w
+            LEFT JOIN tasks m ON m.milestone_id = w.milestone_id AND m.slice_id = w.slice_id AND m.id = w.id
+          `).run());
+        }
 
         // Merge memories — keep worktree-learned insights.
         // V18 (scope, tags), V21 (structured_fields), V28 (last_hit_at): for each
         // column the wt may not yet have (older worktree DB), fall back to the
         // main DB's existing value via LEFT JOIN so reconcile never silently
         // resets these fields to defaults on rows that already had them.
-        merged.memories = countChanges(adapter.prepare(`
-          INSERT OR REPLACE INTO memories (
-            seq, id, category, content, confidence, source_unit_type, source_unit_id,
-            created_at, updated_at, superseded_by, hit_count,
-            scope, tags, structured_fields, last_hit_at
-          )
-          SELECT w.seq, w.id, w.category, w.content, w.confidence, w.source_unit_type, w.source_unit_id,
-                 w.created_at, w.updated_at, w.superseded_by, w.hit_count,
-                 ${hasMemoryScope ? "w.scope" : "COALESCE(m.scope, 'project')"},
-                 ${hasMemoryTags ? "w.tags" : "COALESCE(m.tags, '[]')"},
-                 ${hasMemoryStructuredFields ? "w.structured_fields" : "m.structured_fields"},
-                 ${hasMemoryLastHitAt ? "w.last_hit_at" : "m.last_hit_at"}
-          FROM wt.memories w
-          LEFT JOIN memories m ON m.id = w.id
-        `).run());
+        if (hasWtMemories) {
+          merged.memories = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO memories (
+              seq, id, category, content, confidence, source_unit_type, source_unit_id,
+              created_at, updated_at, superseded_by, hit_count,
+              scope, tags, structured_fields, last_hit_at
+            )
+            SELECT w.seq, w.id, w.category, w.content, w.confidence, w.source_unit_type, w.source_unit_id,
+                   w.created_at, w.updated_at, w.superseded_by, w.hit_count,
+                   ${hasMemoryScope ? "w.scope" : "COALESCE(m.scope, 'project')"},
+                   ${hasMemoryTags ? "w.tags" : "COALESCE(m.tags, '[]')"},
+                   ${hasMemoryStructuredFields ? "w.structured_fields" : "m.structured_fields"},
+                   ${hasMemoryLastHitAt ? "w.last_hit_at" : "m.last_hit_at"}
+            FROM wt.memories w
+            LEFT JOIN memories m ON m.id = w.id
+          `).run());
+        }
+
+        if (hasWtReplanHistory) {
+          merged.replan_history = countChanges(adapter.prepare(`
+            INSERT INTO replan_history (
+              milestone_id, slice_id, task_id, summary, previous_artifact_path, replacement_artifact_path, created_at
+            )
+            SELECT w.milestone_id, w.slice_id, w.task_id, w.summary, w.previous_artifact_path, w.replacement_artifact_path, w.created_at
+            FROM wt.replan_history w
+            WHERE EXISTS (SELECT 1 FROM milestones m WHERE m.id = w.milestone_id)
+              AND NOT EXISTS (
+                SELECT 1 FROM replan_history m
+                WHERE m.milestone_id = w.milestone_id
+                  AND m.slice_id IS w.slice_id
+                  AND m.task_id IS w.task_id
+                  AND m.summary = w.summary
+                  AND m.previous_artifact_path IS w.previous_artifact_path
+                  AND m.replacement_artifact_path IS w.replacement_artifact_path
+              )
+          `).run());
+        }
+
+        if (hasWtAssessments) {
+          merged.assessments = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO assessments (
+              path, milestone_id, slice_id, task_id, status, scope, full_content, created_at
+            )
+            SELECT w.path, w.milestone_id, w.slice_id, w.task_id, w.status, w.scope, w.full_content, w.created_at
+            FROM wt.assessments w
+            WHERE EXISTS (SELECT 1 FROM milestones m WHERE m.id = w.milestone_id)
+          `).run());
+        }
+
+        if (hasWtQualityGates) {
+          merged.quality_gates = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO quality_gates (
+              milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at
+            )
+            SELECT w.milestone_id, w.slice_id, w.gate_id, w.scope, COALESCE(w.task_id, ''), w.status, w.verdict, w.rationale, w.findings, w.evaluated_at
+            FROM wt.quality_gates w
+            WHERE EXISTS (SELECT 1 FROM slices s WHERE s.milestone_id = w.milestone_id AND s.id = w.slice_id)
+          `).run());
+        }
+
+        if (hasWtSliceDependencies) {
+          merged.slice_dependencies = countChanges(adapter.prepare(`
+            INSERT OR IGNORE INTO slice_dependencies (milestone_id, slice_id, depends_on_slice_id)
+            SELECT w.milestone_id, w.slice_id, w.depends_on_slice_id
+            FROM wt.slice_dependencies w
+            WHERE EXISTS (SELECT 1 FROM slices s WHERE s.milestone_id = w.milestone_id AND s.id = w.slice_id)
+              AND EXISTS (SELECT 1 FROM slices d WHERE d.milestone_id = w.milestone_id AND d.id = w.depends_on_slice_id)
+          `).run());
+        }
 
         // Merge verification evidence — append-only, use INSERT OR IGNORE to avoid duplicates
-        merged.verification_evidence = countChanges(adapter.prepare(`
-          INSERT OR IGNORE INTO verification_evidence (
-            task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
-          )
-          SELECT task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
-          FROM wt.verification_evidence
-        `).run());
+        if (hasWtVerificationEvidence) {
+          merged.verification_evidence = countChanges(adapter.prepare(`
+            INSERT OR IGNORE INTO verification_evidence (
+              task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
+            )
+            SELECT task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at
+            FROM wt.verification_evidence
+          `).run());
+        }
+
+        if (hasWtGateRuns) {
+          merged.gate_runs = countChanges(adapter.prepare(`
+            INSERT INTO gate_runs (
+              trace_id, turn_id, gate_id, gate_type, unit_type, unit_id, milestone_id, slice_id, task_id,
+              outcome, failure_class, rationale, findings, attempt, max_attempts, retryable, evaluated_at
+            )
+            SELECT w.trace_id, w.turn_id, w.gate_id, w.gate_type, w.unit_type, w.unit_id, w.milestone_id, w.slice_id, w.task_id,
+                   w.outcome, w.failure_class, w.rationale, w.findings, w.attempt, w.max_attempts, w.retryable, w.evaluated_at
+            FROM wt.gate_runs w
+            WHERE NOT EXISTS (
+              SELECT 1 FROM gate_runs m
+              WHERE m.trace_id = w.trace_id
+                AND m.turn_id = w.turn_id
+                AND m.gate_id = w.gate_id
+                AND m.attempt = w.attempt
+                AND m.evaluated_at = w.evaluated_at
+            )
+          `).run());
+        }
+
+        if (hasWtMilestoneCommitAttributions) {
+          merged.milestone_commit_attributions = countChanges(adapter.prepare(`
+            INSERT OR REPLACE INTO milestone_commit_attributions (
+              commit_sha, milestone_id, slice_id, task_id, source, confidence, files_json, created_at
+            )
+            SELECT w.commit_sha, w.milestone_id, w.slice_id, w.task_id, w.source, w.confidence, w.files_json, w.created_at
+            FROM wt.milestone_commit_attributions w
+            WHERE EXISTS (SELECT 1 FROM milestones m WHERE m.id = w.milestone_id)
+          `).run());
+        }
 
         adapter.exec("COMMIT");
       } catch (txErr) {
@@ -2364,12 +2584,13 @@ export function saveGateResult(g: {
   findings: string;
 }): void {
   if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-  currentDb.prepare(
+  const evaluatedAt = new Date().toISOString();
+  const result = currentDb.prepare(
     `UPDATE quality_gates
      SET status = 'complete', verdict = :verdict, rationale = :rationale,
          findings = :findings, evaluated_at = :evaluated_at
      WHERE milestone_id = :mid AND slice_id = :sid AND gate_id = :gid
-       AND task_id = :tid`,
+       AND (task_id = :tid OR (:tid = '' AND task_id IS NULL))`,
   ).run({
     ":mid": g.milestoneId,
     ":sid": g.sliceId,
@@ -2378,8 +2599,15 @@ export function saveGateResult(g: {
     ":verdict": g.verdict,
     ":rationale": g.rationale,
     ":findings": g.findings,
-    ":evaluated_at": new Date().toISOString(),
-  });
+    ":evaluated_at": evaluatedAt,
+  }) as { changes?: number };
+
+  if ((result.changes ?? 0) === 0) {
+    throw new GSDError(
+      GSD_STALE_STATE,
+      `quality gate row not found for ${g.milestoneId}/${g.sliceId}/${g.gateId}${g.taskId ? `/${g.taskId}` : ""}`,
+    );
+  }
 
   const outcome =
     g.verdict === "pass"
@@ -2402,7 +2630,7 @@ export function saveGateResult(g: {
     attempt: 1,
     maxAttempts: 1,
     retryable: false,
-    evaluatedAt: new Date().toISOString(),
+    evaluatedAt,
   });
 }
 
@@ -2438,6 +2666,30 @@ export function markAllGatesOmitted(milestoneId: string, sliceId: string): void
   });
 }
 
+export function markPendingGatesOmittedForTurn(
+  milestoneId: string,
+  sliceId: string,
+  turn: OwnerTurn,
+): void {
+  if (!currentDb) return;
+  const gateIds = [...getGateIdsForTurn(turn)];
+  if (gateIds.length === 0) return;
+  const placeholders = gateIds.map((_, i) => `:gid${i}`).join(",");
+  const params: Record<string, unknown> = {
+    ":mid": milestoneId,
+    ":sid": sliceId,
+    ":now": new Date().toISOString(),
+  };
+  gateIds.forEach((id, index) => {
+    params[`:gid${index}`] = id;
+  });
+  currentDb.prepare(
+    `UPDATE quality_gates SET status = 'complete', verdict = 'omitted', evaluated_at = :now
+     WHERE milestone_id = :mid AND slice_id = :sid AND status = 'pending'
+       AND gate_id IN (${placeholders})`,
+  ).run(params);
+}
+
 export function getPendingSliceGateCount(milestoneId: string, sliceId: string): number {
   if (!currentDb) return 0;
   const row = currentDb.prepare(
@@ -2858,21 +3110,75 @@ export function upsertQualityGate(g: {
 
 /**
  * Atomically replace all workflow state from a manifest. Lifted verbatim from
- * workflow-manifest.ts so the single-writer invariant holds. Only touches
- * engine tables + decisions. Does NOT modify artifacts or memories.
+ * workflow-manifest.ts so the single-writer invariant holds. Restores
+ * correctness-bearing workflow tables; runtime soft state and append-only audit
+ * streams stay outside this recovery path.
  */
 export function restoreManifest(manifest: StateManifest): void {
   if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
   const db = currentDb;
 
   transaction(() => {
-    // Clear engine tables (order matters for foreign-key-like consistency)
+    const restoredMilestoneIds = new Set(manifest.milestones.map((m) => m.id));
+    const restoredSliceKeys = new Set(manifest.slices.map((s) => JSON.stringify([s.milestone_id, s.id])));
+    const preservedReplanHistory = manifest.replan_history === undefined
+      ? db.prepare("SELECT * FROM replan_history ORDER BY id").all() as unknown as NonNullable<StateManifest["replan_history"]>
+      : [];
+    const preservedAssessments = manifest.assessments === undefined
+      ? db.prepare("SELECT * FROM assessments ORDER BY path").all() as unknown as NonNullable<StateManifest["assessments"]>
+      : [];
+    const preservedQualityGates = manifest.quality_gates === undefined
+      ? db.prepare("SELECT * FROM quality_gates ORDER BY milestone_id, slice_id, gate_id, task_id").all() as unknown as NonNullable<StateManifest["quality_gates"]>
+      : [];
+    const preservedCommitAttributions = manifest.milestone_commit_attributions === undefined
+      ? db.prepare("SELECT * FROM milestone_commit_attributions ORDER BY milestone_id, commit_sha").all() as unknown as NonNullable<StateManifest["milestone_commit_attributions"]>
+      : [];
+
+    // Clear workflow tables in dependency order.
     db.exec("DELETE FROM verification_evidence");
+    db.exec("DELETE FROM quality_gates");
+    db.exec("DELETE FROM slice_dependencies");
+    db.exec("DELETE FROM assessments");
+    db.exec("DELETE FROM replan_history");
+    db.exec("DELETE FROM milestone_commit_attributions");
     db.exec("DELETE FROM tasks");
     db.exec("DELETE FROM slices");
     db.exec("DELETE FROM milestone_leases");
     db.exec("DELETE FROM milestones");
     db.exec("DELETE FROM decisions WHERE 1=1");
+    db.exec(`DELETE FROM memories WHERE category = 'architecture' AND structured_fields LIKE '%"sourceDecisionId":"%'`);
+    if (manifest.artifacts !== undefined) db.exec("DELETE FROM artifacts");
+    if (manifest.requirements !== undefined) db.exec("DELETE FROM requirements");
+
+    if (manifest.requirements !== undefined) {
+      const reqStmt = db.prepare(
+        `INSERT INTO requirements (
+          id, class, status, description, why, source, primary_owner,
+          supporting_slices, validation, notes, full_content, superseded_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      for (const r of manifest.requirements) {
+        reqStmt.run(
+          r.id, r.class, r.status, r.description, r.why, r.source, r.primary_owner,
+          r.supporting_slices, r.validation, r.notes, r.full_content, r.superseded_by,
+        );
+      }
+    }
+
+    if (manifest.artifacts !== undefined) {
+      const artStmt = db.prepare(
+        `INSERT INTO artifacts (
+          path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at, content_hash
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      for (const a of manifest.artifacts) {
+        const fullContent = a.full_content ?? "";
+        artStmt.run(
+          a.path, a.artifact_type, a.milestone_id, a.slice_id, a.task_id,
+          fullContent, a.imported_at, a.content_hash ?? createHash("sha256").update(fullContent).digest("hex"),
+        );
+      }
+    }
 
     // Restore milestones
     const msStmt = db.prepare(
@@ -2914,16 +3220,25 @@ export function restoreManifest(manifest: StateManifest): void {
       );
     }
 
+    const depStmt = db.prepare(
+      "INSERT OR IGNORE INTO slice_dependencies (milestone_id, slice_id, depends_on_slice_id) VALUES (?, ?, ?)",
+    );
+    for (const s of manifest.slices) {
+      for (const dep of s.depends ?? []) {
+        depStmt.run(s.milestone_id, s.id, dep);
+      }
+    }
+
     // Restore tasks (ADR-011 P2: includes blocker_source + escalation_* columns)
     const tkStmt = db.prepare(
       `INSERT INTO tasks (milestone_id, slice_id, id, title, status,
         one_liner, narrative, verification_result, duration, completed_at,
         blocker_discovered, deviations, known_issues, key_files, key_decisions,
         full_summary_md, description, estimate, files, verify,
-        inputs, expected_output, observability_impact, target_repositories, sequence,
+        inputs, expected_output, observability_impact, full_plan_md, target_repositories, sequence,
         blocker_source, escalation_pending, escalation_awaiting_review,
         escalation_artifact_path, escalation_override_applied_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     );
     for (const t of manifest.tasks) {
       tkStmt.run(
@@ -2933,7 +3248,7 @@ export function restoreManifest(manifest: StateManifest): void {
         JSON.stringify(t.key_files), JSON.stringify(t.key_decisions),
         t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify,
         JSON.stringify(t.inputs), JSON.stringify(t.expected_output),
-        t.observability_impact, JSON.stringify(t.target_repositories ?? []), t.sequence,
+        t.observability_impact, t.full_plan_md ?? "", JSON.stringify(t.target_repositories ?? []), t.sequence,
         t.blocker_source ?? "",
         t.escalation_pending ?? 0,
         t.escalation_awaiting_review ?? 0,
@@ -2951,6 +3266,69 @@ export function restoreManifest(manifest: StateManifest): void {
       dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.source ?? "discussion", d.superseded_by);
     }
 
+    const replanHistoryRows = manifest.replan_history ?? preservedReplanHistory.filter((r) => restoredMilestoneIds.has(r.milestone_id));
+    if (replanHistoryRows.length > 0) {
+      const replStmt = db.prepare(
+        `INSERT INTO replan_history (
+          id, milestone_id, slice_id, task_id, summary, previous_artifact_path, replacement_artifact_path, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      for (const r of replanHistoryRows) {
+        replStmt.run(
+          r.id, r.milestone_id, r.slice_id, r.task_id, r.summary,
+          r.previous_artifact_path, r.replacement_artifact_path, r.created_at,
+        );
+      }
+    }
+
+    const assessmentRows = manifest.assessments ?? preservedAssessments.filter((a) => restoredMilestoneIds.has(a.milestone_id));
+    if (assessmentRows.length > 0) {
+      const assessStmt = db.prepare(
+        `INSERT INTO assessments (
+          path, milestone_id, slice_id, task_id, status, scope, full_content, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      for (const a of assessmentRows) {
+        assessStmt.run(
+          a.path, a.milestone_id, a.slice_id, a.task_id,
+          a.status, a.scope, a.full_content, a.created_at,
+        );
+      }
+    }
+
+    const qualityGateRows = manifest.quality_gates ?? preservedQualityGates.filter((g) => (
+      restoredSliceKeys.has(JSON.stringify([g.milestone_id, g.slice_id]))
+    ));
+    if (qualityGateRows.length > 0) {
+      const gateStmt = db.prepare(
+        `INSERT INTO quality_gates (
+          milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      for (const g of qualityGateRows) {
+        gateStmt.run(
+          g.milestone_id, g.slice_id, g.gate_id, g.scope, g.task_id,
+          g.status, g.verdict ?? "", g.rationale, g.findings, g.evaluated_at,
+        );
+      }
+    }
+
+    const commitAttributionRows = manifest.milestone_commit_attributions ??
+      preservedCommitAttributions.filter((a) => restoredMilestoneIds.has(a.milestone_id));
+    if (commitAttributionRows.length > 0) {
+      const attrStmt = db.prepare(
+        `INSERT OR REPLACE INTO milestone_commit_attributions (
+          commit_sha, milestone_id, slice_id, task_id, source, confidence, files_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      );
+      for (const a of commitAttributionRows) {
+        attrStmt.run(
+          a.commit_sha, a.milestone_id, a.slice_id, a.task_id,
+          a.source, a.confidence, a.files_json, a.created_at,
+        );
+      }
+    }
+
     // Restore verification evidence
     const evStmt = db.prepare(
       `INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)