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

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/reopen-reason.js

@@ -0,0 +1,98 @@
+// Project/App: gsd-pi
+// File Purpose: Persist a reopened task's failure diagnosis and inject it into the re-dispatched execute-task prompt.
+// GSD Extension — follow-up to #1225 (#1272)
+//
+// When complete-slice's gate reopens a task via gsd_task_reopen, the operator
+// supplies a `reason` explaining exactly what the full-suite gate caught and
+// how to fix it. That reason previously only landed in the workflow event log
+// (audit trail) and never reached the re-dispatched executor, so the executor
+// re-ran the original (green) verify and re-completed the task without touching
+// the regression. This module is the "inject unresolved context into the next
+// dispatch" mechanism for reopen reasons — a lightweight, file-based sibling of
+// escalation.js#claimOverrideForInjection, keyed by (milestone, slice, task).
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { legacyMilestonesDir, resolveSlicePath, resolveTasksDir } from "./paths.js";
+import { atomicWriteSync } from "./atomic-write.js";
+import { logWarning } from "./workflow-logger.js";
+/**
+ * Canonical reopen-reason artifact path, parallel to T##-SUMMARY.md and
+ * T##-ESCALATION.json:
+ *   .gsd/milestones/{M}/slices/{S}/tasks/{T}-REOPEN.json
+ * Flat-phase: the artifact sits directly in the phase dir. Legacy layouts
+ * without a tasks/ subdir return null (caller degrades gracefully).
+ */
+export function reopenReasonArtifactPath(basePath, milestoneId, sliceId, taskId) {
+    const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (tDir)
+        return join(tDir, `${taskId}-REOPEN.json`);
+    if (existsSync(legacyMilestonesDir(basePath)))
+        return null;
+    const phaseDir = resolveSlicePath(basePath, milestoneId, sliceId);
+    if (!phaseDir)
+        return null;
+    return join(phaseDir, `${taskId}-REOPEN.json`);
+}
+/**
+ * Persist the reopen reason so the next execute-task dispatch can surface it.
+ * A no-op when the reason is empty or the artifact path cannot be resolved —
+ * reopen itself must still succeed even if we cannot attach context.
+ */
+export function writeReopenReason(basePath, milestoneId, sliceId, taskId, reason) {
+    const trimmed = reason.trim();
+    if (!trimmed)
+        return;
+    const path = reopenReasonArtifactPath(basePath, milestoneId, sliceId, taskId);
+    if (!path) {
+        logWarning("tool", `reopen-reason: cannot resolve artifact path for ${milestoneId}/${sliceId}/${taskId}; reopen reason not attached to next dispatch`);
+        return;
+    }
+    const artifact = {
+        version: 1,
+        milestoneId, sliceId, taskId,
+        reason: trimmed,
+        createdAt: new Date().toISOString(),
+    };
+    mkdirSync(join(path, ".."), { recursive: true });
+    atomicWriteSync(path, JSON.stringify(artifact, null, 2));
+}
+/**
+ * If a reopen reason is pending for this task, claim it (one-shot: the artifact
+ * is deleted on read) and return the markdown block to prepend to the executor's
+ * prompt. Returns null when nothing is pending or the artifact is malformed.
+ */
+export function claimReopenReasonForInjection(basePath, milestoneId, sliceId, taskId) {
+    const path = reopenReasonArtifactPath(basePath, milestoneId, sliceId, taskId);
+    if (!path || !existsSync(path))
+        return null;
+    let art = null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed && parsed.version === 1 && typeof parsed.reason === "string" && parsed.reason.trim()) {
+            art = parsed;
+        }
+    }
+    catch {
+        art = null;
+    }
+    // Claim (delete) regardless of validity so a malformed artifact doesn't
+    // wedge every future dispatch of this task.
+    try {
+        unlinkSync(path);
+    }
+    catch { /* already gone */ }
+    if (!art)
+        return null;
+    return { injectionBlock: formatReopenReasonBlock(art) };
+}
+function formatReopenReasonBlock(art) {
+    return [
+        `## Reopened — Reason (from ${art.taskId})`,
+        "",
+        "This task was previously marked complete but a downstream gate (e.g. complete-slice's full-suite run) reopened it. The verify command in your task plan passed in isolation — it did **not** catch the regression below. Do **not** call `gsd_task_complete` until you have reproduced and fixed exactly what this diagnosis describes, then re-run the specific failing command it names (not just the original scoped verify).",
+        "",
+        "**Diagnosis / fix instructions from the gate:**",
+        "",
+        art.reason.trim(),
+    ].join("\n");
+}

package/dist/resources/extensions/gsd/session-status-io.js

@@ -18,6 +18,11 @@ const PARALLEL_DIR = "parallel";
 const STATUS_SUFFIX = ".status.json";
 const SIGNAL_SUFFIX = ".signal.json";
 const DEFAULT_STALE_TIMEOUT_MS = 30_000;
+// How long a paused worker waits for the coordinator to lift the pause before
+// it degrades to in-process serialization (#1273). Kept below the stale
+// timeout so the wait never races the coordinator's liveness detection.
+const DEFAULT_RESUME_WAIT_MS = 10_000;
+const DEFAULT_RESUME_POLL_MS = 250;
 function isSessionStatus(data) {
     return data !== null && typeof data === "object" && "milestoneId" in data && "pid" in data;
 }
@@ -105,6 +110,32 @@ export function consumeSignal(basePath, milestoneId) {
     }
     return msg;
 }
+/**
+ * Wait for a coordinator to lift a `pause` on a worker by sending `resume`
+ * (or `stop`). Polls the signal file until one of those arrives or the timeout
+ * elapses. Intervening `pause`/`rebase` signals are consumed and ignored so a
+ * repeated pause doesn't reset the wait.
+ *
+ * A worker's `pause` is only ever lifted by the interactive/dashboard resumer;
+ * unattended `gsd headless auto` owns no resumer, so callers use the `"timeout"`
+ * result to degrade to in-process serialization instead of stranding the worker
+ * at a terminal pause it cannot resume (#1273).
+ */
+export async function awaitWorkerResume(basePath, milestoneId, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_RESUME_WAIT_MS;
+    const pollMs = opts.pollMs ?? DEFAULT_RESUME_POLL_MS;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const msg = consumeSignal(basePath, milestoneId);
+        if (msg?.signal === "resume")
+            return "resume";
+        if (msg?.signal === "stop")
+            return "stop";
+        if (Date.now() >= deadline)
+            return "timeout";
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}
 // ─── Stale Detection ───────────────────────────────────────────────────────
 /** Check whether a session is stale (PID dead or heartbeat timed out). */
 export function isSessionStale(status, timeoutMs = DEFAULT_STALE_TIMEOUT_MS) {

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);
 }

package/dist/resources/extensions/gsd/tools/reopen-task.js

@@ -15,6 +15,7 @@ import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { writeReopenReason } from "../reopen-reason.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join, basename, dirname } from "node:path";
 import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
@@ -89,6 +90,20 @@ export async function handleReopenTask(params, basePath) {
         logWarning("tool", `reopen-task artifact cleanup warning: ${cleanupErr.message}`);
     }
     clearPathCache();
+    // ── Persist the reopen reason for the next execute-task dispatch (#1272) ──
+    // Without this, the re-dispatched executor receives the original task plan
+    // and verify command with zero signal that it was reopened — it re-runs the
+    // (still-green) scoped verify and re-completes the task, never touching the
+    // regression the gate actually caught. buildExecuteTaskPrompt claims this
+    // artifact and prepends the diagnosis to the next dispatch.
+    if (params.reason && params.reason.trim() !== "") {
+        try {
+            writeReopenReason(basePath, params.milestoneId, params.sliceId, params.taskId, params.reason);
+        }
+        catch (reasonErr) {
+            logWarning("tool", `reopen-task reason persistence warning: ${reasonErr.message}`);
+        }
+    }
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
         await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });

package/dist/resources/extensions/shared/gsd-browser-cli.js

@@ -307,11 +307,12 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
     };
 }
 /**
- * CLI invocation that starts the gsd-browser session daemon with the same
- * session and identity flags as {@link resolveGsdBrowserMcpLaunchConfig}, so
- * browser UAT can warm Chrome/CDP before the first MCP navigation.
+ * CLI invocation that runs a `daemon <action>` command against the gsd-browser
+ * session daemon with the same session and identity flags as
+ * {@link resolveGsdBrowserMcpLaunchConfig}, so start (warm-up) and stop
+ * (teardown) address the exact same managed daemon.
  */
-export function resolveGsdBrowserDaemonStartInvocation(projectRoot, env = process.env, options = {}) {
+function resolveGsdBrowserDaemonInvocation(action, projectRoot, env, options) {
     const launch = resolveGsdBrowserMcpLaunchConfig(projectRoot, env, options);
     const mcpIndex = launch.args.indexOf("mcp");
     if (mcpIndex < 0) {
@@ -321,8 +322,24 @@ export function resolveGsdBrowserDaemonStartInvocation(projectRoot, env = proces
     const sessionFlags = launch.args.slice(mcpIndex + 1);
     return {
         command: launch.command,
-        args: [...prefix, "daemon", "start", ...sessionFlags],
+        args: [...prefix, "daemon", action, ...sessionFlags],
         cwd: launch.cwd,
         ...(launch.env ? { env: launch.env } : {}),
     };
 }
+/**
+ * CLI invocation that starts the gsd-browser session daemon with the same
+ * session and identity flags as {@link resolveGsdBrowserMcpLaunchConfig}, so
+ * browser UAT can warm Chrome/CDP before the first MCP navigation.
+ */
+export function resolveGsdBrowserDaemonStartInvocation(projectRoot, env = process.env, options = {}) {
+    return resolveGsdBrowserDaemonInvocation("start", projectRoot, env, options);
+}
+/**
+ * CLI invocation that stops the gsd-browser session daemon warmed for browser
+ * UAT, so the Chrome process is torn down instead of lingering after the
+ * triggering task/session ends.
+ */
+export function resolveGsdBrowserDaemonStopInvocation(projectRoot, env = process.env, options = {}) {
+    return resolveGsdBrowserDaemonInvocation("stop", projectRoot, env, options);
+}