@opengsd/gsd-pi 1.7.0 → 1.8.1

package/dist/resources/extensions/gsd/md-importer.js

@@ -656,8 +656,13 @@ export function migrateHierarchyToDb(basePath) {
                 updateSliceStatus(milestoneId, sliceEntry.id, sliceStatus, importCompletionTimestamp(sliceSummary));
             }
             counts.slices++;
-            // Insert tasks from parsed plan
-            if (!plan)
+            // Insert tasks from parsed plan.
+            // Sketch slices carry only a stub PLAN until refined; do not seed DB
+            // tasks from a placeholder <tasks> block (would falsely flip
+            // planning -> executing before the slice is decomposed). Once the
+            // `[sketch]` badge is removed by a real plan-slice, tasks import
+            // normally on the next pass. (#1286)
+            if (!plan || sliceEntry.isSketch)
                 continue;
             for (const taskEntry of plan.tasks) {
                 // Per K002: use 'complete' not 'done'

package/dist/resources/extensions/gsd/migrate/planning-writer.js

@@ -9,6 +9,7 @@ import { mkdirSync } from "node:fs";
 import { join, relative } from "node:path";
 import { getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
 import { saveFile } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
 import { applyPlanningProjectionWrites, } from "../compat/planning-compat.js";
 function planningRoot(basePath) {
     return join(basePath, ".planning");
@@ -86,7 +87,11 @@ function formatPlanningPlan(phaseNum, planNum, title, tasks) {
     lines.push("<tasks>");
     for (const t of tasks) {
         const est = t.estimate ? ` _(${t.estimate})_` : "";
-        lines.push(`- [ ] **${t.id}**: ${t.title}${est}`);
+        // Render the checkbox from the task's DB status so a DB→.planning
+        // projection preserves completion. Hardcoding `[ ]` here silently reset
+        // every completed historical task to unchecked on each reconcile (#1276).
+        const box = t.done ? "[x]" : "[ ]";
+        lines.push(`- ${box} **${t.id}**: ${t.title}${est}`);
     }
     lines.push("</tasks>");
     lines.push("");
@@ -131,7 +136,7 @@ export async function writePlanningDirectory(basePath, layout) {
             const phaseDir = join(root, "phases", phaseDirName);
             mkdirSync(phaseDir, { recursive: true });
             const tasks = getSliceTasks(milestone.id, slice.id);
-            const isDone = tasks.length > 0 && tasks.every((t) => t.status === "complete");
+            const isDone = tasks.length > 0 && tasks.every((t) => isClosedStatus(t.status));
             roadmapEntries.push({
                 number: phaseNum,
                 title: slice.title || slice.id,
@@ -157,6 +162,7 @@ export async function writePlanningDirectory(basePath, layout) {
                             id: task.id,
                             title: task.title || task.id,
                             estimate: task.estimate || undefined,
+                            done: isClosedStatus(task.status),
                         },
                     ]));
                     paths.push(planPath);

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

@@ -117,6 +117,10 @@ export function scanMarkdownHierarchy(basePath) {
         scan.counts.slices += roadmap.slices.length;
         for (const slice of roadmap.slices) {
             scan.slices.add(`${milestoneId}/${slice.id}`);
+            // Sketch slices carry only a stub PLAN until refined; match migrateHierarchyToDb
+            // and do not count placeholder tasks from the <tasks> block (#1286).
+            if (slice.isSketch)
+                continue;
             const planPath = resolveSliceFile(basePath, milestoneId, slice.id, "PLAN");
             if (!planPath || !existsSync(planPath))
                 continue;

package/dist/resources/extensions/gsd/state-reconciliation/drift/project-md.js

@@ -5,8 +5,8 @@
 // instruction. Markdown hierarchy import is reserved for operator-controlled
 // migration/recovery commands, not automatic runtime reconciliation.
 import { existsSync } from "node:fs";
-import { getMilestone, isDbAvailable } from "../../gsd-db.js";
-import { findMilestoneIds } from "../../milestone-ids.js";
+import { getAllMilestones, getMilestone, isDbAvailable } from "../../gsd-db.js";
+import { findMilestoneIds, parseMilestoneId } from "../../milestone-ids.js";
 import { resolveMilestoneFile, resolveMilestonePath } from "../../paths.js";
 function milestoneHasContent(basePath, milestoneId) {
     const roadmap = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
@@ -16,6 +16,26 @@ function milestoneHasContent(basePath, milestoneId) {
         (context !== null && existsSync(context)) ||
         (summary !== null && existsSync(summary)));
 }
+/**
+ * A directory extracted to a bare `M{NNN}` id is not unregistered when the
+ * milestone is actually registered under a `unique_milestone_ids` suffixed id
+ * (`M{NNN}-<suffix>`) for the same sequence number. The flat-phase extractor in
+ * `milestone-ids` cannot recover the suffix from a descriptive slug (e.g.
+ * `07-v40fmq-m007-...-footer-system`), so it falls through to the bare `M007`.
+ * Probing the DB for a suffixed row on that sequence resolves the directory to
+ * its registered identity instead of firing a false-positive drift (issue
+ * #1281).
+ */
+function hasRegisteredSuffixedVariant(milestoneId) {
+    const { suffix, num } = parseMilestoneId(milestoneId);
+    // Only bare, well-formed `M{NNN}` ids can be ambiguous with a suffixed row.
+    if (suffix || num === 0)
+        return false;
+    return getAllMilestones().some((m) => {
+        const parsed = parseMilestoneId(m.id);
+        return parsed.num === num && parsed.suffix !== undefined;
+    });
+}
 export function detectUnregisteredMilestoneDrift(_state, ctx) {
     if (!isDbAvailable())
         return [];
@@ -23,6 +43,8 @@ export function detectUnregisteredMilestoneDrift(_state, ctx) {
     for (const milestoneId of findMilestoneIds(ctx.basePath)) {
         if (getMilestone(milestoneId))
             continue;
+        if (hasRegisteredSuffixedVariant(milestoneId))
+            continue;
         if (!milestoneHasContent(ctx.basePath, milestoneId))
             continue;
         drifts.push({ kind: "unregistered-milestone", milestoneId });
@@ -30,29 +52,47 @@ export function detectUnregisteredMilestoneDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair intentionally fails closed. The project-root DB is authoritative at
- * 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).
+ * The recovery 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, ctx) {
+function unregisteredMilestoneGuidance(record, ctx) {
     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 ` +
+    return (`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.");
 }
+/**
+ * Terminal blocker for an unregistered milestone. The project-root DB is
+ * authoritative at runtime; markdown-only milestones must be reconciled through
+ * an explicit, operator-controlled action so operators opt into changing
+ * canonical state. Exposing this as a `blocker` (matching the `artifact-db`
+ * convention) surfaces the drift as a pause-with-hint that gates dispatch,
+ * instead of a guaranteed repair throw that escalates auto-mode health to red
+ * (see issue #1281).
+ */
+export function describeUnregisteredMilestoneBlocker(record, ctx) {
+    return unregisteredMilestoneGuidance(record, ctx);
+}
+/**
+ * Repair intentionally fails closed. Retained as a defensive fallback for the
+ * reconciliation engine; in practice `blocker` short-circuits this drift into a
+ * non-fatal pause before repair is ever attempted.
+ */
+export function repairUnregisteredMilestone(record, ctx) {
+    throw new Error(unregisteredMilestoneGuidance(record, ctx));
+}
 export const unregisteredMilestoneHandler = {
     kind: "unregistered-milestone",
     detect: detectUnregisteredMilestoneDrift,
+    blocker: describeUnregisteredMilestoneBlocker,
     repair: repairUnregisteredMilestone,
 };

package/dist/resources/extensions/gsd/state-reconciliation/drift/sketch-flag.js

@@ -7,8 +7,9 @@
 //   2. Flag-OFF downgrade: when progressive_planning is off, dispatch routes
 //      sketch slices to plan-slice, which writes PLAN.md but leaves
 //      is_sketch=1 — the next reconciliation pass clears it.
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { getSketchedSliceIds, isDbAvailable, setSliceSketchFlag, } from "../../gsd-db.js";
+import { parsePlan } from "../../parsers-legacy.js";
 import { resolveSliceFile } from "../../paths.js";
 export function detectStaleSketchFlags(state, ctx) {
     if (!isDbAvailable())
@@ -18,12 +19,54 @@ export function detectStaleSketchFlags(state, ctx) {
         return [];
     const sliceIds = getSketchedSliceIds(mid);
     return sliceIds
-        .filter((sid) => {
-        const planPath = resolveSliceFile(ctx.basePath, mid, sid, "PLAN");
-        return planPath !== null && existsSync(planPath);
-    })
+        .filter((sid) => sketchIsPlanned(ctx.basePath, mid, sid))
         .map((sid) => ({ kind: "stale-sketch-flag", mid, sid }));
 }
+/**
+ * True when a task title is a synthetic placeholder emitted by a projection
+ * round-trip rather than a real, refined task. `migrate/transformer.buildTaskTitle`
+ * produces two shapes when a plan was never decomposed:
+ *   - `Plan NN`            (fallback when phase/plan frontmatter is absent)
+ *   - `${phase} ${plan}`   (e.g. `00 01`, `00 03b`, `29-auth-system 01`)
+ * Neither carries genuine planning intent, so both must be treated as stubs.
+ */
+function isPlaceholderTaskTitle(title) {
+    const t = title.trim();
+    if (/^Plan\s+\d+[a-z]*$/i.test(t))
+        return true;
+    // buildTaskTitle returns `${phase} ${plan}` when frontmatter has both fields.
+    // Phase slugs are digit-led (e.g. `00`, `29-auth-system`); require that so
+    // legitimate titles like `Step 1` are not misclassified as stubs.
+    return /^\d[\w-]*\s+\d+[a-z]*$/i.test(t);
+}
+/**
+ * A sketch slice counts as "planned" (so its is_sketch flag may be cleared)
+ * only when it has a *real* plan on disk — not merely any PLAN file.
+ *
+ * File existence alone (#1287) is too weak: a stub/placeholder PLAN, a
+ * crash-leftover, or a projection round-trip that emits synthetic placeholder
+ * task titles (migrate/transformer.buildTaskTitle) all satisfy existsSync yet
+ * were never actually refined. Clearing the flag for one strips the `refining`
+ * guard in phase derivation and lets a phantom task drive dispatch.
+ *
+ * A legitimate plan-slice always decomposes into >= 1 genuine task, so require
+ * at least one non-placeholder task. This is strictly stricter than the old
+ * existence check — the documented crash-recovery scenarios (a real plan-slice
+ * that wrote its tasks) still clear, a bare stub no longer does.
+ */
+function sketchIsPlanned(basePath, mid, sid) {
+    const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+    if (planPath === null || !existsSync(planPath))
+        return false;
+    try {
+        const plan = parsePlan(readFileSync(planPath, "utf-8"));
+        return plan.tasks.some((t) => !isPlaceholderTaskTitle(t.title));
+    }
+    catch {
+        // A PLAN we cannot parse is not a trustworthy "planning done" signal.
+        return false;
+    }
+}
 export function repairStaleSketchFlag(record) {
     setSliceSketchFlag(record.mid, record.sid, false);
 }