@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/state/derive/index.ts

@@ -0,0 +1,104 @@
+// Project/App: gsd-pi
+// File Purpose: deriveState orchestrator — cache, DB open, pure DB projection.
+
+import type { GSDState } from '../../types.js';
+import { loadFile } from '../../files.js';
+import { resolveGsdRootFile } from '../../paths.js';
+import { isDbAvailable } from '../../gsd-db.js';
+import { wasWorkflowDatabaseOpenAttempted } from '../../db-workspace.js';
+import { debugCount, debugTime } from '../../debug-logger.js';
+import { logWarning } from '../../workflow-logger.js';
+
+import {
+  getDeriveTelemetry,
+  incrementDbDeriveCount,
+  invalidateStateCache,
+  readCachedDeriveState,
+  resetDeriveTelemetry,
+  writeCachedDeriveState,
+} from './cache.js';
+import {
+  buildDbUnavailableState,
+  ensureExistingWorkflowDbOpen,
+} from './db-open.js';
+import { deriveStateFromDb } from './from-db.js';
+
+export interface DeriveStateOptions {
+  projectRootForReads?: string;
+}
+
+export {
+  getDeriveTelemetry,
+  invalidateStateCache,
+  resetDeriveTelemetry,
+};
+
+async function loadRecentDecisions(basePath: string): Promise<string[]> {
+  const decisionsPath = resolveGsdRootFile(basePath, "DECISIONS");
+  const content = await loadFile(decisionsPath);
+  if (!content) return [];
+
+  const fromTable = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("|"))
+    .map((line) => {
+      const cells = line
+        .split("|")
+        .map((cell) => cell.trim())
+        .filter((cell) => cell.length > 0);
+      if (cells.length < 6) return null;
+      const id = cells[0];
+      if (!/^D\d+$/i.test(id)) return null;
+      const whenContext = cells[1];
+      const decision = cells[3];
+      const choice = cells[4];
+      if (!decision || !choice) return null;
+      return `${id} (${whenContext}): ${decision} -> ${choice}`;
+    })
+    .filter((value): value is string => value != null);
+
+  if (fromTable.length > 0) return fromTable.slice(-5);
+
+  const fromBullets = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => /^-\s+/.test(line))
+    .map((line) => line.replace(/^-+\s+/, ""))
+    .filter((line) => /^D\d+\b/i.test(line));
+
+  return fromBullets.slice(-5);
+}
+
+export async function deriveState(
+  basePath: string,
+  opts?: DeriveStateOptions,
+): Promise<GSDState> {
+  const cacheKey = opts?.projectRootForReads ?? basePath;
+
+  const cached = readCachedDeriveState(cacheKey);
+  if (cached) return cached;
+
+  const stopTimer = debugTime("derive-state-impl");
+  let result: GSDState;
+
+  ensureExistingWorkflowDbOpen(basePath);
+
+  if (isDbAvailable()) {
+    const stopDbTimer = debugTime("derive-state-db");
+    result = await deriveStateFromDb(basePath, opts?.projectRootForReads ?? basePath);
+    stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+    incrementDbDeriveCount();
+  } else {
+    if (wasWorkflowDatabaseOpenAttempted()) {
+      logWarning("state", "DB unavailable — refusing implicit markdown state derivation");
+    }
+    result = buildDbUnavailableState();
+  }
+
+  result.recentDecisions = await loadRecentDecisions(cacheKey);
+  stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+  debugCount("deriveStateCalls");
+  writeCachedDeriveState(cacheKey, result);
+  return result;
+}

package/src/resources/extensions/gsd/state/derive/interrupted-work.ts

@@ -0,0 +1,31 @@
+// Project/App: gsd-pi
+// File Purpose: Detect interrupted slice work from CONTINUE artifacts (legacy path).
+
+import { join } from 'node:path';
+import { loadFile } from '../../files.js';
+import { resolveSliceFile, resolveSlicePath } from '../../paths.js';
+
+export async function detectInterruptedWork(
+  basePath: string,
+  milestoneId: string,
+  sliceId: string,
+): Promise<boolean> {
+  const sliceDir = resolveSlicePath(basePath, milestoneId, sliceId);
+  const continueFile = sliceDir
+    ? resolveSliceFile(basePath, milestoneId, sliceId, "CONTINUE")
+    : null;
+  if (continueFile && await loadFile(continueFile)) return true;
+  if (sliceDir && await loadFile(join(sliceDir, "continue.md"))) return true;
+  return false;
+}
+
+export function interruptedWorkNextAction(
+  taskId: string,
+  taskTitle: string,
+  sliceId: string,
+  interrupted: boolean,
+): string {
+  return interrupted
+    ? `Resume interrupted work on ${taskId}: ${taskTitle} in slice ${sliceId}. Read continue.md first.`
+    : `Execute ${taskId}: ${taskTitle} in slice ${sliceId}.`;
+}

package/src/resources/extensions/gsd/state-reconciliation/drift/artifact-db.ts

@@ -213,13 +213,21 @@ function detectArtifactDbStatusDriftForMilestone(
 
     for (const task of tasks) {
       if (isClosedStatus(task.status)) continue;
-      const diskTaskSummary = resolveTaskFile(
+      // Flat-phase: task summaries live in the phase dir as TID-SUMMARY.md
+      let diskTaskSummary = resolveTaskFile(
         basePath,
         milestoneId,
         slice.id,
         task.id,
         "SUMMARY",
       );
+      if (!diskTaskSummary) {
+        const phaseDir = resolveMilestonePath(basePath, milestoneId);
+        if (phaseDir) {
+          const flatSummary = join(phaseDir, `${task.id}-SUMMARY.md`);
+          if (existsSync(flatSummary)) diskTaskSummary = flatSummary;
+        }
+      }
       if (!diskTaskSummary || !existsSync(diskTaskSummary)) continue;
       addUniqueDrift(drifts, seen, {
         kind: "artifact-db-status-divergence",
@@ -302,12 +310,35 @@ function detectDiskSliceIdDivergenceForMilestone(
   const milestonePath = resolveMilestonePath(basePath, milestoneId);
   if (!milestonePath) return [];
 
-  const slicesDir = join(milestonePath, "slices");
-  if (!existsSync(slicesDir)) return [];
-
   const knownSliceIds = new Set(getMilestoneSlices(milestoneId).map((slice) => slice.id));
   const drifts: DiskSliceIdDivergenceDrift[] = [];
 
+  // Flat-phase: scan phase dir for plan files (NN-MM-PLAN.md) where MM
+  // doesn't match any known slice. Each plan file's slice id is S<MM>.
+  try {
+    for (const entry of readdirSync(milestonePath)) {
+      const planMatch = entry.match(/^\d+-(\d+)-PLAN\.md$/i);
+      if (!planMatch) continue;
+      const planNum = parseInt(planMatch[1]!, 10);
+      const sliceId = `S${String(planNum).padStart(2, "0")}`;
+      if (knownSliceIds.has(sliceId)) continue;
+      drifts.push({
+        kind: "disk-slice-id-divergence",
+        milestoneId,
+        sliceId,
+        sliceDir: join(milestonePath, entry),
+        disposition: "block-meaningful",
+        reason: `plan file ${entry} references unknown ${sliceId}`,
+      });
+    }
+  } catch {
+    // unreadable phase dir
+  }
+
+  // Legacy: scan slices/ subdir for unknown slice dirs
+  const slicesDir = join(milestonePath, "slices");
+  if (!existsSync(slicesDir)) return drifts;
+
   for (const entry of readdirSync(slicesDir)) {
     const sliceDir = join(slicesDir, entry);
     try {

package/src/resources/extensions/gsd/state-reconciliation/drift/completion.ts

@@ -20,9 +20,11 @@ import {
 } from "../../gsd-db.js";
 import {
   resolveMilestoneFile,
+  resolveMilestonePath,
   resolveSliceFile,
   resolveTaskFile,
 } from "../../paths.js";
+import { join } from "node:path";
 import type { GSDState } from "../../types.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
@@ -103,13 +105,23 @@ function collectMilestoneCompletionDrift(
     for (const task of getSliceTasks(mid, slice.id)) {
       if (!COMPLETE_STATUSES.has(task.status)) continue;
       if (task.completed_at !== null) continue;
-      const taskSummary = resolveTaskFile(
+      // Flat-phase: task summaries live in the phase dir as TID-SUMMARY.md.
+      // Legacy: resolveTaskFile returns the tasks/TID/TID-SUMMARY.md path.
+      let taskSummary = resolveTaskFile(
         ctx.basePath,
         mid,
         slice.id,
         task.id,
         "SUMMARY",
       );
+      // Flat-phase fallback: check the phase dir directly
+      if (!taskSummary) {
+        const phaseDir = resolveMilestonePath(ctx.basePath, mid);
+        if (phaseDir) {
+          const flatSummary = join(phaseDir, `${task.id}-SUMMARY.md`);
+          if (existsSync(flatSummary)) taskSummary = flatSummary;
+        }
+      }
       if (taskSummary && existsSync(taskSummary)) {
         drifts.push({
           kind: "missing-completion-timestamp",
@@ -170,7 +182,15 @@ export function repairMissingCompletionTimestamp(
       task.completed_at !== null ||
       !COMPLETE_STATUSES.has(task.status)
     ) return;
-    const summary = resolveTaskFile(ctx.basePath, mid, sid, tid, "SUMMARY");
+    // Flat-phase: task summaries live in the phase dir as TID-SUMMARY.md
+    let summary = resolveTaskFile(ctx.basePath, mid, sid, tid, "SUMMARY");
+    if (!summary) {
+      const phaseDir = resolveMilestonePath(ctx.basePath, mid);
+      if (phaseDir) {
+        const flatSummary = join(phaseDir, `${tid}-SUMMARY.md`);
+        if (existsSync(flatSummary)) summary = flatSummary;
+      }
+    }
     const ts = summary ? summaryMtimeIso(summary) : null;
     if (!ts) return;
     updateTaskStatus(mid, sid, tid, task.status, ts);

package/src/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.ts

@@ -0,0 +1,105 @@
+// Project/App: gsd-pi
+// File Purpose: ADR-017 drift handler for external (gsd-core) markdown edits.
+//
+// gsd-pi's DB is canonical, but .gsd/*.md is the inter-tool contract. When
+// gsd-core edits a projection file, this handler detects the sha drift vs the
+// recorded baseline in .gsd/.compat.json and re-imports the affected entities
+// into the DB. The next renderAllFromDb pass re-projects; the write-time
+// invalidation hook then refreshes the marker entry, closing the loop.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  computeProjectionSha,
+  readCompatMarker,
+  writeCompatMarker,
+} from "../../compat/compat-marker.js";
+import { logWarning } from "../../workflow-logger.js";
+import type { GSDState } from "../../types.js";
+import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
+
+type ExternalMarkdownEditDrift = Extract<
+  DriftRecord,
+  { kind: "external-markdown-edit" }
+>;
+
+/**
+ * Detect sha drift between the marker baseline and current file contents.
+ *
+ * - Missing marker → no records (the broader /gsd recover flow handles a
+ *   cold-start; this handler only fires when we have a baseline to compare).
+ * - Missing file on disk → no record (other handlers cover missing artifacts).
+ * - Sha match → no record (gsd-pi's own write or no change).
+ * - Sha mismatch → one record per drifted file, scoped to its recorded entities.
+ */
+function detectExternalMarkdownEdit(
+  _state: GSDState,
+  ctx: DriftContext,
+): ExternalMarkdownEditDrift[] {
+  const marker = readCompatMarker(ctx.basePath);
+  const entries = Object.entries(marker.projections);
+  if (entries.length === 0) return [];
+
+  const records: ExternalMarkdownEditDrift[] = [];
+  for (const [projectionPath, entry] of entries) {
+    const abs = join(ctx.basePath, ".gsd", projectionPath);
+    if (!existsSync(abs)) continue;
+    const actual = computeProjectionSha(readFileSync(abs, "utf-8"));
+    if (actual === entry.sha) continue;
+    records.push({
+      kind: "external-markdown-edit",
+      projectionPath,
+      expectedSha: entry.sha,
+      actualSha: actual,
+      entities: entry.entities,
+    });
+  }
+  return records;
+}
+
+/**
+ * Idempotent repair: re-import hierarchy for the affected entities from
+ * markdown into the DB, then update the marker entry so the next detect pass
+ * sees the file as expected. migrateHierarchyToDb is itself idempotent
+ * (upsert), so re-running this repair after a successful one is a no-op.
+ */
+async function repairExternalMarkdownEdit(
+  record: ExternalMarkdownEditDrift,
+  ctx: DriftContext,
+): Promise<void> {
+  try {
+    // Dynamic imports break a module-init cycle: this handler ← registry ←
+    // state.ts ← guided-flow.ts ← md-importer.ts ← (this handler's old static
+    // import). Deferring to repair time keeps module load cycle-free.
+    const { migrateHierarchyToDb } = await import("../../md-importer.js");
+    const { invalidateStateCache } = await import("../../state.js");
+    // Scoped re-import. migrateHierarchyToDb walks the whole tree but is a
+    // cheap upsert; per-entity scoping would require decomposing it, which is
+    // out of scope for v1. The cost is bounded by tree size and runs at most
+    // once per reconcile pass (MAX_PASSES=2).
+    migrateHierarchyToDb(ctx.basePath);
+    invalidateStateCache();
+  } catch (err) {
+    logWarning(
+      "reconcile",
+      `external-markdown-edit repair failed for ${record.projectionPath}: ${(err as Error).message}`,
+    );
+    throw err;
+  }
+
+  // Refresh the marker so a second pass (cap=2 reconcile) doesn't re-fire.
+  const marker = readCompatMarker(ctx.basePath);
+  marker.projections[record.projectionPath] = {
+    sha: record.actualSha,
+    entities: record.entities,
+  };
+  marker.lastProjectedAt = new Date().toISOString();
+  writeCompatMarker(ctx.basePath, marker);
+}
+
+export const externalMarkdownEditHandler: DriftHandler<ExternalMarkdownEditDrift> = {
+  kind: "external-markdown-edit",
+  detect: detectExternalMarkdownEdit,
+  repair: repairExternalMarkdownEdit,
+};

package/src/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.ts

@@ -0,0 +1,180 @@
+// Project/App: gsd-pi
+// File Purpose: ADR-017 drift handler for external (gsd-core) edits to .planning/.
+// Parallel to external-markdown-edit.ts. Detects sha drift between the compat
+// marker's planning.projections/passthrough and current .planning/ files.
+//
+// Modeled files (projections): re-imported via parsePlanningDirectory → DB.
+// Passthrough files (un-modeled docs): sha refreshed, content untouched.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  computeProjectionSha,
+  readCompatMarker,
+  writeCompatMarker,
+} from "../../compat/compat-marker.js";
+import {
+  isPlanningPassthroughRelPath,
+  walkPlanningRelPaths,
+} from "../../compat/planning-compat.js";
+import { logWarning } from "../../workflow-logger.js";
+import type { GSDState } from "../../types.js";
+import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
+
+type ExternalPlanningEditDrift = Extract<
+  DriftRecord,
+  { kind: "external-planning-edit" }
+>;
+
+function detectOne(
+  ctx: DriftContext,
+  entries: Record<string, { sha: string; entities: string[] }>,
+  passthrough: boolean,
+): ExternalPlanningEditDrift[] {
+  const records: ExternalPlanningEditDrift[] = [];
+  for (const [projectionPath, entry] of Object.entries(entries)) {
+    const abs = join(ctx.basePath, ".planning", projectionPath);
+    if (!existsSync(abs)) continue; // missing-file drift is covered by other handlers
+    const actual = computeProjectionSha(readFileSync(abs, "utf-8"));
+    if (actual === entry.sha) continue;
+    records.push({
+      kind: "external-planning-edit",
+      projectionPath,
+      expectedSha: entry.sha,
+      actualSha: actual,
+      entities: entry.entities,
+      passthrough,
+    });
+  }
+  return records;
+}
+
+function detectUnseededPlanningFiles(
+  ctx: DriftContext,
+  projections: Record<string, { sha: string; entities: string[] }>,
+  passthrough: Record<string, { sha: string; entities: string[] }>,
+): ExternalPlanningEditDrift[] {
+  const planningDir = join(ctx.basePath, ".planning");
+  if (!existsSync(planningDir)) return [];
+
+  const records: ExternalPlanningEditDrift[] = [];
+  for (const relPath of walkPlanningRelPaths(planningDir)) {
+    const isPassthrough = isPlanningPassthroughRelPath(relPath);
+    const map = isPassthrough ? passthrough : projections;
+    if (map[relPath]) continue;
+    const abs = join(planningDir, relPath);
+    const actual = computeProjectionSha(readFileSync(abs, "utf-8"));
+    records.push({
+      kind: "external-planning-edit",
+      projectionPath: relPath,
+      expectedSha: "",
+      actualSha: actual,
+      entities: [],
+      passthrough: isPassthrough,
+    });
+  }
+  return records;
+}
+
+async function detectExternalPlanningEdit(
+  _state: GSDState,
+  ctx: DriftContext,
+): Promise<ExternalPlanningEditDrift[]> {
+  const marker = readCompatMarker(ctx.basePath);
+  if (!marker.planning?.active) {
+    // Not yet activated. Activation (layout parse + DB import) is owned by
+    // capturePlanningCompatIfNeeded, called from reconcileBeforeDispatch when
+    // !dryRun. detect() must never write the marker — it is called in both
+    // dry-run and non-dry-run contexts. In dry-run, preview unseeded files
+    // without persisting activation.
+    if (!ctx.dryRun) return [];
+
+    const planningDir = join(ctx.basePath, ".planning");
+    if (!existsSync(planningDir)) return [];
+    try {
+      const { parsePlanningDirectory } = await import("../../migrate/parser.js");
+      const { detectPlanningLayout } = await import("../../migrate/layout-detect.js");
+      const parsed = await parsePlanningDirectory(planningDir);
+      const layout = detectPlanningLayout(parsed);
+      if (!layout) return [];
+      return detectUnseededPlanningFiles(ctx, {}, {});
+    } catch (e) {
+      logWarning(
+        "reconcile",
+        `planning layout auto-detection failed: ${(e as Error).message}`,
+      );
+    }
+    return [];
+  }
+  const projections = marker.planning.projections;
+  const passthrough = marker.planning.passthrough;
+  const hasBaselines =
+    Object.keys(projections).length > 0 || Object.keys(passthrough).length > 0;
+  return [
+    ...detectOne(ctx, projections, false),
+    ...detectOne(ctx, passthrough, true),
+    // No baseline yet (post-capture, pre-writePlanningDirectory): skip unseeded
+    // detection so every on-disk file is not treated as drift in the same pass.
+    ...(hasBaselines ? detectUnseededPlanningFiles(ctx, projections, passthrough) : []),
+  ];
+}
+
+async function repairExternalPlanningEdit(
+  record: ExternalPlanningEditDrift,
+  ctx: DriftContext,
+): Promise<void> {
+  // Passthrough: never re-import (no DB model). Just refresh the sha.
+  if (record.passthrough) {
+    const marker = readCompatMarker(ctx.basePath);
+    marker.planning!.passthrough[record.projectionPath] = {
+      sha: record.actualSha,
+      entities: record.entities,
+    };
+    marker.lastProjectedAt = new Date().toISOString();
+    writeCompatMarker(ctx.basePath, marker);
+    return;
+  }
+
+  // Modeled: re-import via the migrate read path. Dynamic imports break the
+  // module-init cycle (this handler ← registry ← state.ts ← guided-flow.ts
+  // ← md-importer.ts). parsePlanningDirectory reads .planning/; always
+  // transform + writeGSDDirectory so .gsd/ reflects the edited .planning/ file
+  // before migrateHierarchyToDb ingests it. In coexistence, .planning/ is the
+  // gsd-core native format and takes precedence: writing .gsd/ here propagates
+  // the edit that must survive future projections. external-markdown-edit (index
+  // 0) runs before this handler, so .gsd/-only drift is already imported first.
+  try {
+    const { parsePlanningDirectory } = await import("../../migrate/parser.js");
+    const { transformToGSD } = await import("../../migrate/transformer.js");
+    const { writeGSDDirectory } = await import("../../migrate/writer.js");
+    const { migrateHierarchyToDb } = await import("../../md-importer.js");
+    const { invalidateStateCache } = await import("../../state.js");
+
+    const parsed = await parsePlanningDirectory(join(ctx.basePath, ".planning"));
+    const gsdProject = transformToGSD(parsed);
+    await writeGSDDirectory(gsdProject, ctx.basePath);
+    migrateHierarchyToDb(ctx.basePath);
+    invalidateStateCache();
+  } catch (err) {
+    logWarning(
+      "reconcile",
+      `external-planning-edit repair failed for ${record.projectionPath}: ${(err as Error).message}`,
+    );
+    throw err;
+  }
+
+  const marker = readCompatMarker(ctx.basePath);
+  marker.planning!.projections[record.projectionPath] = {
+    sha: record.actualSha,
+    entities: record.entities,
+  };
+  marker.lastProjectedAt = new Date().toISOString();
+  writeCompatMarker(ctx.basePath, marker);
+}
+
+export const externalPlanningEditHandler: DriftHandler<ExternalPlanningEditDrift> = {
+  kind: "external-planning-edit",
+  detect: detectExternalPlanningEdit,
+  repair: repairExternalPlanningEdit,
+};

package/src/resources/extensions/gsd/state-reconciliation/drift/project-md.ts

@@ -9,7 +9,7 @@ import { existsSync } from "node:fs";
 
 import { getMilestone, isDbAvailable } from "../../gsd-db.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
-import { resolveMilestoneFile } from "../../paths.js";
+import { resolveMilestoneFile, resolveMilestonePath } from "../../paths.js";
 import type { GSDState } from "../../types.js";
 import type { DriftContext, DriftHandler, DriftRecord } from "../types.js";
 
@@ -46,16 +46,29 @@ export function detectUnregisteredMilestoneDrift(
 
 /**
  * Repair intentionally fails closed. The project-root DB is authoritative at
- * runtime; markdown-only milestones must be imported through an explicit
- * migration/recovery command so operators opt into changing canonical state.
+ * runtime; markdown-only milestones must be reconciled through an explicit,
+ * operator-controlled action so operators opt into changing canonical state.
+ *
+ * The hint deliberately leads with the *targeted*, non-destructive options. The
+ * common cause of this drift is a directory left under an old ID after a
+ * `unique_milestone_ids` rename, where the right fix is to rename (move) the
+ * directory — not a full DB reimport. `/gsd recover --confirm` is a destructive
+ * clear-and-reimport of the entire DB and is offered only as a last resort, so
+ * users do not reach for it expecting a targeted repair (see issue #826).
  */
 export function repairUnregisteredMilestone(
   record: UnregisteredMilestoneDrift,
-  _ctx: DriftContext,
+  ctx: DriftContext,
 ): void {
+  const dir = resolveMilestonePath(ctx.basePath, record.milestoneId);
+  const dirHint = dir ?? `the .gsd directory for ${record.milestoneId}`;
   throw new Error(
-    `Milestone ${record.milestoneId} exists only as markdown projection. ` +
-      "Runtime reconciliation will not import markdown into the authoritative DB; run `/gsd recover --confirm` if this markdown should repopulate the database.",
+    `Milestone ${record.milestoneId} exists only as markdown projection ` +
+      "(on-disk ROADMAP/CONTEXT/SUMMARY with no authoritative DB row). " +
+      "Runtime reconciliation will not import markdown into the DB. Choose one:\n" +
+      `  • Rename: if this directory is the same milestone under an old ID (e.g. a unique_milestone_ids rename), move \`${dirHint}\` to the current ID's directory and re-run.\n` +
+      `  • Discard: if this milestone is no longer relevant, delete \`${dirHint}\` and re-run.\n` +
+      "  • Last resort: `/gsd recover --confirm` performs a destructive full DB clear-and-reimport — it does NOT do a targeted import and can replace or duplicate existing DB milestones.",
   );
 }
 

package/src/resources/extensions/gsd/state-reconciliation/drift/roadmap.ts

@@ -60,6 +60,7 @@ function milestoneHasDivergence(
 
   const dbSlices = getMilestoneSlices(milestoneId);
   const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+  const dbSliceOrder = new Map(dbSlices.map((s, index) => [s.id, index]));
   const readySliceIds = getSlicesReadyForDivergenceCheck(milestoneId, dbSlices);
   if (dbSlices.length > 0 && readySliceIds.size === 0) {
     return false;
@@ -69,11 +70,10 @@ function milestoneHasDivergence(
   for (let i = 0; i < roadmap.slices.length; i++) {
     const roadmapSlice = roadmap.slices[i]!;
     roadmapSliceIds.add(roadmapSlice.id);
-    const expectedSequence = i + 1;
     const dbSlice = dbSliceMap.get(roadmapSlice.id);
     if (!dbSlice) return true; // Roadmap has a slice the DB doesn't.
     if (!readySliceIds.has(dbSlice.id)) continue;
-    if (dbSlice.sequence !== expectedSequence) return true;
+    if (dbSliceOrder.get(dbSlice.id) !== i) return true;
     if (!arraysEqual(dbSlice.depends, roadmapSlice.depends)) return true;
     if (isClosedStatus(dbSlice.status) !== roadmapSlice.done) return true;
   }