@opengsd/gsd-pi 1.7.0-dev.30c4ec2f → 1.7.0-dev.e0039c3c

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

@@ -656,13 +656,8 @@ export function migrateHierarchyToDb(basePath) {
                 updateSliceStatus(milestoneId, sliceEntry.id, sliceStatus, importCompletionTimestamp(sliceSummary));
             }
             counts.slices++;
-            // 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)
+            // Insert tasks from parsed plan
+            if (!plan)
                 continue;
             for (const taskEntry of plan.tasks) {
                 // Per K002: use 'complete' not 'done'

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

@@ -9,7 +9,6 @@ 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");
@@ -87,11 +86,7 @@ function formatPlanningPlan(phaseNum, planNum, title, tasks) {
     lines.push("<tasks>");
     for (const t of tasks) {
         const est = t.estimate ? ` _(${t.estimate})_` : "";
-        // 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(`- [ ] **${t.id}**: ${t.title}${est}`);
     }
     lines.push("</tasks>");
     lines.push("");
@@ -136,7 +131,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) => isClosedStatus(t.status));
+            const isDone = tasks.length > 0 && tasks.every((t) => t.status === "complete");
             roadmapEntries.push({
                 number: phaseNum,
                 title: slice.title || slice.id,
@@ -162,7 +157,6 @@ 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,10 +117,6 @@ 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 { getAllMilestones, getMilestone, isDbAvailable } from "../../gsd-db.js";
-import { findMilestoneIds, parseMilestoneId } from "../../milestone-ids.js";
+import { getMilestone, isDbAvailable } from "../../gsd-db.js";
+import { findMilestoneIds } from "../../milestone-ids.js";
 import { resolveMilestoneFile, resolveMilestonePath } from "../../paths.js";
 function milestoneHasContent(basePath, milestoneId) {
     const roadmap = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
@@ -16,26 +16,6 @@ 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 [];
@@ -43,8 +23,6 @@ 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 });
@@ -52,47 +30,29 @@ export function detectUnregisteredMilestoneDrift(_state, ctx) {
     return drifts;
 }
 /**
- * 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).
+ * 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).
  */
-function unregisteredMilestoneGuidance(record, ctx) {
+export function repairUnregisteredMilestone(record, ctx) {
     const dir = resolveMilestonePath(ctx.basePath, record.milestoneId);
     const dirHint = dir ?? `the .gsd directory for ${record.milestoneId}`;
-    return (`Milestone ${record.milestoneId} exists only as markdown projection ` +
+    throw new Error(`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,9 +7,8 @@
 //   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, readFileSync } from "node:fs";
+import { existsSync } 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())
@@ -19,54 +18,12 @@ export function detectStaleSketchFlags(state, ctx) {
         return [];
     const sliceIds = getSketchedSliceIds(mid);
     return sliceIds
-        .filter((sid) => sketchIsPlanned(ctx.basePath, mid, sid))
+        .filter((sid) => {
+        const planPath = resolveSliceFile(ctx.basePath, mid, sid, "PLAN");
+        return planPath !== null && existsSync(planPath);
+    })
         .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);
 }