@opengsd/gsd-pi 1.9.0-dev.5c1a3ff2 → 1.9.0-dev.d2070876

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.js

@@ -8,9 +8,81 @@
 // 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 { basename, join } from "node:path";
 import { computeProjectionSha, readCompatMarker, writeCompatMarker, } from "../../compat/compat-marker.js";
+import { _getAdapter } from "../../gsd-db.js";
 import { logWarning } from "../../workflow-logger.js";
+function deepestProjectionScope(entities) {
+    let best = null;
+    for (const entity of entities) {
+        const parts = entity.split("/").filter(Boolean);
+        if (parts.length === 0)
+            continue;
+        if (!best || parts.length > best.length)
+            best = parts;
+    }
+    if (!best)
+        return null;
+    return {
+        milestoneId: best[0],
+        sliceId: best[1] ?? null,
+        taskId: best[2] ?? null,
+    };
+}
+function artifactTypeFromProjectionPath(projectionPath) {
+    const name = basename(projectionPath);
+    const match = name.match(/^(?:[A-Za-z]\d+|\d+(?:-\d+)?)-(.+)\.md$/);
+    return match?.[1]?.toUpperCase() ?? null;
+}
+function dbProjectionMatches(projectionPath, entry, actualSha) {
+    const adapter = _getAdapter();
+    if (!adapter)
+        return false;
+    try {
+        const rows = adapter
+            .prepare("SELECT full_content FROM artifacts WHERE path = :path")
+            .all({ ":path": projectionPath });
+        const scope = deepestProjectionScope(entry.entities);
+        const artifactType = artifactTypeFromProjectionPath(projectionPath);
+        if (scope?.taskId) {
+            rows.push(...adapter
+                .prepare(`SELECT full_content
+             FROM artifacts
+             WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid
+               AND (:type IS NULL OR artifact_type = :type)`)
+                .all({
+                ":mid": scope.milestoneId,
+                ":sid": scope.sliceId,
+                ":tid": scope.taskId,
+                ":type": artifactType,
+            }));
+        }
+        else if (scope?.sliceId) {
+            rows.push(...adapter
+                .prepare(`SELECT full_content
+             FROM artifacts
+             WHERE milestone_id = :mid AND slice_id = :sid AND task_id IS NULL
+               AND (:type IS NULL OR artifact_type = :type)`)
+                .all({
+                ":mid": scope.milestoneId,
+                ":sid": scope.sliceId,
+                ":type": artifactType,
+            }));
+        }
+        else if (scope) {
+            rows.push(...adapter
+                .prepare(`SELECT full_content
+             FROM artifacts
+             WHERE milestone_id = :mid AND slice_id IS NULL AND task_id IS NULL
+               AND (:type IS NULL OR artifact_type = :type)`)
+                .all({ ":mid": scope.milestoneId, ":type": artifactType }));
+        }
+        return rows.some((row) => computeProjectionSha(row.full_content) === actualSha);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Detect sha drift between the marker baseline and current file contents.
  *
@@ -21,11 +93,15 @@ import { logWarning } from "../../workflow-logger.js";
  * - Sha mismatch → one record per drifted file, scoped to its recorded entities.
  */
 function detectExternalMarkdownEdit(_state, ctx) {
-    const marker = readCompatMarker(ctx.basePath);
+    const marker = readCompatMarker(ctx.basePath, {
+        healInvalidKeys: !ctx.dryRun,
+        quarantineInvalid: !ctx.dryRun,
+    });
     const entries = Object.entries(marker.projections);
     if (entries.length === 0)
         return [];
     const records = [];
+    let markerChanged = false;
     for (const [projectionPath, entry] of entries) {
         const abs = join(ctx.basePath, ".gsd", projectionPath);
         if (!existsSync(abs))
@@ -33,6 +109,21 @@ function detectExternalMarkdownEdit(_state, ctx) {
         const actual = computeProjectionSha(readFileSync(abs, "utf-8"));
         if (actual === entry.sha)
             continue;
+        if (dbProjectionMatches(projectionPath, entry, actual)) {
+            if (!ctx.dryRun) {
+                marker.projections[projectionPath] = {
+                    sha: actual,
+                    entities: entry.entities,
+                };
+                markerChanged = true;
+                logWarning("reconcile", `external-markdown-edit: refreshed stale compat marker for ${projectionPath} (expectedSha=${entry.sha}, actualSha=${actual})`);
+            }
+            else {
+                logWarning("reconcile", `external-markdown-edit: stale compat marker for ${projectionPath} (expectedSha=${entry.sha}, actualSha=${actual})`);
+            }
+            continue;
+        }
+        logWarning("reconcile", `external-markdown-edit drift for ${projectionPath} (expectedSha=${entry.sha}, actualSha=${actual})`);
         records.push({
             kind: "external-markdown-edit",
             projectionPath,
@@ -41,6 +132,11 @@ function detectExternalMarkdownEdit(_state, ctx) {
             entities: entry.entities,
         });
     }
+    if (markerChanged) {
+        marker.lastWriter = "gsd-pi";
+        marker.lastProjectedAt = new Date().toISOString();
+        writeCompatMarker(ctx.basePath, marker);
+    }
     return records;
 }
 /**

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.js

@@ -55,7 +55,10 @@ function detectUnseededPlanningFiles(ctx, projections, passthrough) {
     return records;
 }
 async function detectExternalPlanningEdit(_state, ctx) {
-    const marker = readCompatMarker(ctx.basePath);
+    const marker = readCompatMarker(ctx.basePath, {
+        healInvalidKeys: !ctx.dryRun,
+        quarantineInvalid: !ctx.dryRun,
+    });
     if (!marker.planning?.active) {
         // Not yet activated. Activation (layout parse + DB import) is owned by
         // capturePlanningCompatIfNeeded, called from reconcileBeforeDispatch when

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

@@ -9,7 +9,7 @@ import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
-import { isClosedStatus } from "../../status-guards.js";
+import { isClosedStatus, isSkippedForDispatch } from "../../status-guards.js";
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -76,7 +76,10 @@ export function detectRoadmapDivergenceDrift(_state, ctx) {
     for (const milestoneId of findMilestoneIds(ctx.basePath)) {
         // Skip milestones that don't yet have a DB row — that's the
         // unregistered-milestone drift handler's responsibility.
-        if (!getMilestone(milestoneId))
+        const milestone = getMilestone(milestoneId);
+        if (!milestone)
+            continue;
+        if (isSkippedForDispatch(milestone.status))
             continue;
         if (milestoneHasDivergence(ctx.basePath, milestoneId)) {
             drifts.push({ kind: "roadmap-divergence", milestoneId });

package/dist/resources/extensions/gsd/stop-notice.js

@@ -22,6 +22,12 @@ export function formatStopNoticePrefix(reason) {
     const prefix = stopNoticeKind(reason) === "blocked" ? "Auto-mode blocked" : "Auto-mode stopped";
     return displayReason ? `${prefix} — ${displayReason}` : prefix;
 }
+export function formatVerdictRecordedNotice(message) {
+    return `Verdict recorded: ${message}`;
+}
+export function formatVerdictRejectedNotice(message) {
+    return `Verdict rejected: ${message}`;
+}
 // ─── Classification (headless host side) ────────────────────────────────
 // The canonical lowercase prefixes the headless event loop recognizes in
 // notify messages. Emitters above and ad-hoc emitters elsewhere must start
@@ -33,6 +39,8 @@ export const TERMINAL_NOTICE_PREFIXES = [
     "auto-mode complete",
     "no active milestone",
     "auto-mode idle",
+    "verdict recorded",
+    "verdict rejected",
 ];
 /** Manual-resolution notices emitted before auto-mode can formally pause/stop. */
 export function isManualResolutionNotice(message) {
@@ -65,6 +73,7 @@ export function isInteractiveMenuUnavailableNotice(message) {
 }
 export function isBlockedNoticeMessage(message) {
     return (message.includes("blocked:") ||
+        message.startsWith("verdict rejected") ||
         (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
         isManualResolutionNotice(message) ||
         isInteractiveMenuUnavailableNotice(message));

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -21,7 +21,7 @@
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { reconcileWorktreeDb } from "./gsd-db.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { logError, logWarning } from "./workflow-logger.js";
 // ─── Private helpers ──────────────────────────────────────────────────────
@@ -129,6 +129,8 @@ function syncOtherMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir, current
             if (milestoneEntry.name === currentMilestoneId)
                 continue;
             const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+            if (!dirIsContentBearingLegacyMilestone(srcMilestoneDir))
+                continue;
             const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
             // Additively project the entire milestone subtree (force:false), not just
             // top-level files. Prior completed milestones keep their per-slice and
@@ -219,25 +221,25 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // Without this, worktree-local files (e.g. VALIDATION.md written
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
-    safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { force: false });
-    // Additively project the full subtree of every OTHER milestone so
-    // worktree-bound units can read prior-milestone context artifacts and so
-    // completed milestones retain their per-slice/per-task SUMMARY.md and
-    // UAT.md on the worktree filesystem (otherwise the stale-render detector
-    // flags them as "complete in DB but missing on disk").
-    syncOtherMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"), milestoneId);
-    // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
-    // The additive-only copy above preserves worktree-local files, but
-    // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
-    // syncs it to the project root, the worktree may retain a stale copy (e.g.
-    // verdict:fail while the project root has verdict:pass from a retry). On
-    // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
-    // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
-    // run-uat indefinitely (stuck-loop ×9).
     const prMilestoneDir = join(prGsd, "milestones", milestoneId);
     const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
-    forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
-    forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+    if (dirIsContentBearingLegacyMilestone(prMilestoneDir)) {
+        safeCopyRecursive(prMilestoneDir, wtMilestoneDir, { force: false });
+        // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
+        // The additive-only copy above preserves worktree-local files, but
+        // ASSESSMENT files are special: after run-uat writes a verdict and post-unit
+        // syncs it to the project root, the worktree may retain a stale copy (e.g.
+        // verdict:fail while the project root has verdict:pass from a retry). On
+        // session resume the DB is rebuilt from disk, and if the stale ASSESSMENT
+        // persists, checkNeedsRunUat finds no passing verdict → re-dispatches
+        // run-uat indefinitely (stuck-loop ×9).
+        forceOverwriteValidationWithVerdict(prMilestoneDir, wtMilestoneDir, milestoneId);
+        forceOverwriteAssessmentsWithVerdict(prMilestoneDir, wtMilestoneDir);
+    }
+    // Additively project the full subtree of every OTHER content-bearing legacy
+    // milestone so worktree-bound units can read prior-milestone context artifacts
+    // without recreating empty/meta-only milestones/ scaffolds in flat-phase projects.
+    syncOtherMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"), milestoneId);
     // Forward-sync completed-units.json from project root to worktree.
     // Project root is authoritative for completion state after crash recovery;
     // without this, the worktree re-dispatches already-completed units (#1886).

package/dist/resources/extensions/shared/interview-ui.js

@@ -144,6 +144,10 @@ export async function showInterviewRound(questions, opts, ctx) {
         let previewViewport = 0;
         let previewTotal = 0;
         function resetPreviewScroll() { previewScroll = 0; }
+        let optionsScroll = 0;
+        let optionsViewport = 0;
+        let optionsTotal = 0;
+        function resetOptionsScroll() { optionsScroll = 0; }
         function finish(result) {
             if (completed)
                 return;
@@ -203,6 +207,7 @@ export async function showInterviewRound(questions, opts, ctx) {
             saveEditorToState();
             currentIdx = newIdx;
             resetPreviewScroll();
+            resetOptionsScroll();
             loadStateToEditor();
             focusNotes = states[currentIdx].notesVisible && states[currentIdx].notes.length > 0;
             refresh();
@@ -376,32 +381,49 @@ export async function showInterviewRound(questions, opts, ctx) {
                     return;
                 }
             }
-            // ── Preview scrolling ────────────────────────────────────────
+            // ── Side-by-side panel scrolling ─────────────────────────────
             if (matchesKey(data, Key.pageUp)) {
+                let didScroll = false;
+                if (optionsScroll > 0) {
+                    optionsScroll = Math.max(0, optionsScroll - optionsViewport);
+                    didScroll = true;
+                }
                 if (previewScroll > 0) {
                     previewScroll = Math.max(0, previewScroll - previewViewport);
-                    refresh();
+                    didScroll = true;
                 }
+                if (didScroll)
+                    refresh();
                 return;
             }
             if (matchesKey(data, Key.pageDown)) {
+                let didScroll = false;
+                const maxOptionsScroll = Math.max(0, optionsTotal - optionsViewport);
+                if (optionsScroll < maxOptionsScroll) {
+                    optionsScroll = Math.min(maxOptionsScroll, optionsScroll + optionsViewport);
+                    didScroll = true;
+                }
                 const maxScroll = Math.max(0, previewTotal - previewViewport);
                 if (previewScroll < maxScroll) {
                     previewScroll = Math.min(maxScroll, previewScroll + previewViewport);
-                    refresh();
+                    didScroll = true;
                 }
+                if (didScroll)
+                    refresh();
                 return;
             }
             // ── Cursor navigation ────────────────────────────────────────
             if (matchesKey(data, Key.up)) {
                 st.cursorIndex = (st.cursorIndex - 1 + optCount) % optCount;
                 resetPreviewScroll();
+                resetOptionsScroll();
                 refresh();
                 return;
             }
             if (matchesKey(data, Key.down)) {
                 st.cursorIndex = (st.cursorIndex + 1) % optCount;
                 resetPreviewScroll();
+                resetOptionsScroll();
                 refresh();
                 return;
             }
@@ -637,6 +659,8 @@ export async function showInterviewRound(questions, opts, ctx) {
             // No scrollable preview unless the side-by-side path sets these below.
             previewTotal = 0;
             previewViewport = 0;
+            optionsTotal = 0;
+            optionsViewport = 0;
             if (useSideBySide) {
                 // ── Preview path ──────────────────────────────────────
                 const ui = makeUI(theme, contentWidth);
@@ -672,10 +696,21 @@ export async function showInterviewRound(questions, opts, ctx) {
                 const previewWidth = Math.max(MIN_PREVIEW_WIDTH, Math.min(contentWidth - MIN_OPTIONS_WIDTH - DIVIDER_WIDTH, Math.floor(contentWidth * PREVIEW_RATIO)));
                 const leftWidth = Math.max(MIN_OPTIONS_WIDTH, contentWidth - previewWidth - DIVIDER_WIDTH);
                 const fullLeft = renderOptionsColumn(leftWidth);
-                const leftLines = fullLeft.slice(0, maxBody);
+                optionsTotal = fullLeft.length;
+                optionsViewport = maxBody;
+                const maxOptionsScroll = Math.max(0, fullLeft.length - maxBody);
+                if (optionsScroll > maxOptionsScroll)
+                    optionsScroll = maxOptionsScroll;
+                const leftLines = fullLeft.slice(optionsScroll, optionsScroll + maxBody);
                 if (fullLeft.length > maxBody) {
-                    const n = fullLeft.length - maxBody + 1;
-                    leftLines[maxBody - 1] = scrollIndicator(`+${n} lines hidden`, leftWidth);
+                    const hiddenAbove = optionsScroll;
+                    const hiddenBelow = fullLeft.length - (optionsScroll + maxBody);
+                    if (hiddenAbove > 0) {
+                        leftLines[0] = scrollIndicator(`▲ ${hiddenAbove} more`, leftWidth);
+                    }
+                    if (hiddenBelow > 0) {
+                        leftLines[leftLines.length - 1] = scrollIndicator(`▼ ${hiddenBelow} more · PgUp/PgDn`, leftWidth);
+                    }
                 }
                 const preview = getCurrentPreview();
                 const fullRight = preview ? renderPreviewColumn(preview, previewWidth) : [];
@@ -734,6 +769,8 @@ export async function showInterviewRound(questions, opts, ctx) {
                 }
                 if (previewTotal > previewViewport)
                     hints.push("pgup/pgdn scroll preview");
+                if (optionsTotal > optionsViewport)
+                    hints.push("pgup/pgdn scroll options");
                 hints.push("esc to exit");
                 const footer = ui.hints(hints)[0] ?? "";
                 cachedLines = renderSharedDialogFrame(theme, title, lines, width, { footer });