@opengsd/gsd-pi 1.5.0 → 1.6.0-dev.aa7f94e8

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -5,7 +5,7 @@
 // Projections are read-only views of engine state (Layer 3 of the architecture).
 import { _getAdapter, isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getVerificationEvidence, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { logWarning } from "./workflow-logger.js";
@@ -13,7 +13,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { deriveState } from "./state.js";
 import { renderPlanFromDb, renderRoadmapFromDb } from "./markdown-renderer.js";
 import { readManifest } from "./workflow-manifest.js";
-import { gsdRoot, resolveSliceFile, resolveMilestonePath, resolveSlicePath, gsdProjectionRoot } from "./paths.js";
+import { gsdRoot, resolveMilestoneFile, resolveSliceFile, resolveTaskFile, relTaskFile } from "./paths.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────
 /**
  * Strip a leading ID prefix (e.g. "M001: " or "S04: ") from a title
@@ -276,26 +276,10 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
         return;
     const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
     const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
-    // Layout-aware: avoid creating a milestones/ directory as a side effect for
-    // flat-phase projects. If milestonesDir() sees a freshly-created milestones/
-    // dir it treats the project as legacy, breaking all subsequent path resolution.
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
-    const phaseDir = resolveMilestonePath(basePath, milestoneId);
-    let dir;
-    if (slicePath && phaseDir && slicePath !== phaseDir) {
-        // Legacy layout: slice has its own slices/SID/ subdir → tasks/ subdir
-        dir = join(slicePath, "tasks");
-    }
-    else if (phaseDir) {
-        // Flat-phase: task summaries go in the phase dir (no tasks/ subdir needed)
-        dir = phaseDir;
-    }
-    else {
-        // Fallback: legacy hardcoded path (milestone dir not on disk yet)
-        dir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
-    }
-    mkdirSync(dir, { recursive: true });
-    atomicWriteSync(join(dir, `${taskId}-SUMMARY.md`), content);
+    const summaryPath = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY")
+        ?? join(basePath, relTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY", getMilestone(milestoneId)?.title));
+    mkdirSync(dirname(summaryPath), { recursive: true });
+    atomicWriteSync(summaryPath, content);
 }
 // ─── STATE.md Projection ────────────────────────────────────────────────
 /**
@@ -474,7 +458,7 @@ export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileTy
             filePath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN") ?? "";
             break;
         case "ROADMAP":
-            filePath = join(basePath, ".gsd", "milestones", milestoneId, `${milestoneId}-ROADMAP.md`);
+            filePath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP") ?? "";
             break;
         case "SUMMARY":
             // For SUMMARY, we regenerate all task summaries in the slice
@@ -490,8 +474,7 @@ export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileTy
         const doneTasks = taskRows.filter(t => t.status === "done" || t.status === "complete");
         let regenerated = 0;
         for (const task of doneTasks) {
-            const summaryPath = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks", `${task.id}-SUMMARY.md`);
-            if (!existsSync(summaryPath)) {
+            if (!resolveTaskFile(basePath, milestoneId, sliceId, task.id, "SUMMARY")) {
                 try {
                     renderSummaryProjection(basePath, milestoneId, sliceId, task.id);
                     regenerated++;
@@ -526,7 +509,7 @@ export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileTy
                 return !!(resolveSliceFile(basePath, milestoneId, sliceId, "PLAN"));
             case "ROADMAP":
                 await renderRoadmapFromDb(basePath, milestoneId);
-                return existsSync(filePath);
+                return !!resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
             case "STATE":
                 await renderStateProjection(basePath);
                 return existsSync(filePath);

package/dist/resources/extensions/gsd/workspace-git-preflight.js

@@ -1,8 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Unified workspace git preflight probe, heal, and readiness checks.
 import { existsSync, realpathSync } from "node:fs";
-import { getAutoWorktreePath } from "./auto-worktree.js";
-import { isSafeToAutoResolve } from "./auto-worktree.js";
+import { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { listMergeStateBlockers, probeGitConflictState, reconcileGitConflictsOnSignal, } from "./git-conflict-state.js";
 import { deriveState } from "./state.js";

package/dist/resources/extensions/gsd/workspace.js

@@ -1,26 +1,17 @@
 // gsd-pi + Workspace handle: single source of truth for path resolution per milestone
 import { dirname, join, resolve } from "node:path";
-import { buildMilestoneFileName, canonicalPhaseDirName, isLegacyMilestonesLayout, milestonesDir, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, normalizeRealPath, } from "./paths.js";
+import { resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, targetMilestoneFile, normalizeRealPath, } from "./paths.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
 function tryRealpath(p) {
     return normalizeRealPath(p);
 }
-function isLegacyMilestoneDirectory(dir) {
-    const parent = dirname(dir);
-    return parent.endsWith("/milestones") || parent.endsWith("\\milestones");
-}
 function scopeMilestoneDir(basePath, milestoneId) {
-    return resolveMilestonePath(basePath, milestoneId) ?? join(milestonesDir(basePath), isLegacyMilestonesLayout(basePath) ? milestoneId : canonicalPhaseDirName(milestoneId));
+    return resolveMilestonePath(basePath, milestoneId)
+        ?? dirname(targetMilestoneFile(basePath, milestoneId, "ROADMAP"));
 }
 function scopeMilestoneFile(basePath, milestoneId, suffix) {
-    const existing = resolveMilestoneFile(basePath, milestoneId, suffix);
-    if (existing)
-        return existing;
-    const dir = scopeMilestoneDir(basePath, milestoneId);
-    const filename = isLegacyMilestoneDirectory(dir)
-        ? `${milestoneId}-${suffix}.md`
-        : buildMilestoneFileName(milestoneId, suffix);
-    return join(dir, filename);
+    return resolveMilestoneFile(basePath, milestoneId, suffix)
+        ?? targetMilestoneFile(basePath, milestoneId, suffix);
 }
 /**
  * Create an immutable GsdWorkspace handle from a raw base path.

package/dist/resources/extensions/gsd/worktree-command.js

@@ -11,7 +11,7 @@
  */
 import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, nudgeGitBranchCache } from "./worktree.js";
-import { runWorktreePostCreateHook } from "./auto-worktree.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { showConfirm } from "../shared/tui.js";
 import { gsdRoot, milestonesDir, resolveGsdPathContract } from "./paths.js";
 import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, getWorktreeGSDDiff, getWorktreeCodeDiff, getWorktreeLog, worktreeBranchName, worktreePath, } from "./worktree-manager.js";

package/dist/resources/extensions/gsd/worktree-lifecycle.js

@@ -47,11 +47,15 @@ import { createWorkspace, scopeMilestone } from "./workspace.js";
 // adding type churn without enabling any test variation.
 import { autoCommitCurrentBranch, getCurrentBranch, } from "./worktree.js";
 import { nativeCheckoutBranch } from "./native-git-bridge.js";
-// ADR-016 phase 2 / C2 (#5625): worktree-manager helpers inlined from
-// `./auto-worktree.js`. These seven functions are not real seams — Lifecycle
-// is the only Module that calls them, and they live alongside the Module's
-// other primitives in `auto-worktree.ts`.
-import { autoWorktreeBranch, createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, getAutoWorktreePath, isInAutoWorktree, teardownAutoWorktree, } from "./auto-worktree.js";
+// ADR-016 phase 2 / C2 (#5625): lifecycle uses focused auto-worktree
+// modules instead of the legacy compatibility barrel. Branch, entry/path,
+// creation, and teardown primitives are still implementation-level seams for
+// Lifecycle; tests vary them through `WorktreeLifecycleTestOverrides` below.
+import { autoWorktreeBranch, enterBranchModeForMilestone, } from "./auto-worktree-branch-lifecycle.js";
+import { createAutoWorktree } from "./auto-worktree-creation.js";
+import { enterAutoWorktree, isInAutoWorktree, } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
+import { teardownAutoWorktree } from "./auto-worktree-teardown.js";
 import { resolveRoadmapForMilestoneMerge } from "./milestone-merge-roadmap.js";
 const recentWorktreeMergeFailures = new Map();
 const MERGE_FAILURE_DEDUPE_MS = 60_000;
@@ -874,8 +878,9 @@ function _mergeBranchModeImpl(deps, mctx) {
  * **CWD anchor**: anchors `process.cwd()` at `originalBasePath` before
  * non-worktree merge paths to mirror the single-loop guard against ENOENT
  * after teardown (de73fb43d). Worktree-mode merge paths keep the real
- * worktree as cwd because `mergeMilestoneToMain()` infers source worktree
- * state from `process.cwd()`. Best-effort; silent on failure.
+ * worktree as cwd because the default milestone merge transaction delegates
+ * to the legacy merge primitive, which infers source worktree state from
+ * `process.cwd()`. Best-effort; silent on failure.
  *
  * **Failure handling**: `MergeConflictError` and other unrecoverable errors
  * propagate to the caller. The caller is responsible for any state restore
@@ -963,8 +968,8 @@ export function mergeMilestoneStandalone(deps, mctx) {
     }
     // Set cwd to the correct anchor before dispatching to mode implementations.
     // Worktree mode / in-worktree override must run from the live worktree so
-    // mergeMilestoneToMain can find worktree-local state; branch mode runs from
-    // the original project root. Best-effort for synthetic test paths.
+    // The default merge transaction can find worktree-local state; branch mode
+    // runs from the original project root. Best-effort for synthetic test paths.
     const targetCwd = mode === "worktree" || inWorktree
         ? worktreeBasePath
         : originalBasePath;

package/dist/resources/extensions/gsd/worktree-reentry.js

@@ -6,7 +6,8 @@
 // back into the worktree. The worktree path is fully derivable from state, so we
 // resolve and chdir into it directly instead.
 import { readdirSync } from "node:fs";
-import { enterAutoWorktree, getAutoWorktreePath } from "./auto-worktree.js";
+import { enterAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { getIsolationMode } from "./preferences.js";
 import { allWorktreesDirs } from "./worktree-manager.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";

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

@@ -48,6 +48,30 @@ function splitCommandLine(commandLine) {
         return part;
     });
 }
+/**
+ * Extra gsd-browser CLI flags to forward verbatim to the launched daemon, from
+ * GSD_BROWSER_MCP_EXTRA_ARGS. Unlike GSD_BROWSER_MCP_ARGS (a full args override),
+ * these are *appended* to the default `mcp`/`daemon start` invocation so callers
+ * keep the managed session/identity flags. Accepts a JSON array (e.g.
+ * `["--stealth"]`) or a plain, optionally-quoted command-line string
+ * (e.g. `--stealth --browser-path /usr/bin/chromium`). This is the config-level
+ * knob for environments where Chrome needs extra launch flags — e.g. containers
+ * without unprivileged user namespaces, where `--stealth` supplies Chrome's
+ * `--no-sandbox`.
+ */
+function resolveExtraGsdBrowserArgs(env) {
+    const raw = env.GSD_BROWSER_MCP_EXTRA_ARGS?.trim();
+    if (!raw)
+        return [];
+    if (raw.startsWith("[")) {
+        const parsed = parseJsonEnv(env, "GSD_BROWSER_MCP_EXTRA_ARGS");
+        if (!Array.isArray(parsed)) {
+            throw new Error("GSD_BROWSER_MCP_EXTRA_ARGS JSON must be an array of strings");
+        }
+        return parsed.map(String);
+    }
+    return splitCommandLine(raw);
+}
 function buildPathGsdBrowserVersionInvocation(platform) {
     if (platform === "win32") {
         return { command: "cmd", args: ["/d", "/s", "/c", "gsd-browser", "--version"] };
@@ -251,6 +275,10 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
         || (preferPathCli ? "gsd-browser" : undefined)
         || (bundledCliPath ? process.execPath : undefined)
         || "gsd-browser";
+    // Appended after the managed session/identity flags so they survive the
+    // daemon-start transformation (which forwards everything after `mcp`), letting
+    // callers add extra Chrome/gsd-browser launch flags via one config knob.
+    const extraArgs = resolveExtraGsdBrowserArgs(env);
     const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
         ? explicitArgs.map(String)
         : [
@@ -265,6 +293,7 @@ export function resolveGsdBrowserMcpLaunchConfig(projectRoot, env = process.env,
             identityKey,
             "--identity-project",
             identityProject,
+            ...extraArgs,
         ];
     const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
     return {
@@ -278,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) {
@@ -292,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);
+}

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

@@ -137,6 +137,13 @@ export async function showInterviewRound(questions, opts, ctx) {
         let cachedLines;
         let completed = false;
         let removeAbortListener;
+        // Preview-panel scrolling. previewScroll is the first visible line of the
+        // side-by-side preview column; the viewport/total are captured on each
+        // render so PgUp/PgDn input can clamp against real bounds.
+        let previewScroll = 0;
+        let previewViewport = 0;
+        let previewTotal = 0;
+        function resetPreviewScroll() { previewScroll = 0; }
         function finish(result) {
             if (completed)
                 return;
@@ -195,6 +202,7 @@ export async function showInterviewRound(questions, opts, ctx) {
                 return;
             saveEditorToState();
             currentIdx = newIdx;
+            resetPreviewScroll();
             loadStateToEditor();
             focusNotes = states[currentIdx].notesVisible && states[currentIdx].notes.length > 0;
             refresh();
@@ -368,14 +376,32 @@ export async function showInterviewRound(questions, opts, ctx) {
                     return;
                 }
             }
+            // ── Preview scrolling ────────────────────────────────────────
+            if (matchesKey(data, Key.pageUp)) {
+                if (previewScroll > 0) {
+                    previewScroll = Math.max(0, previewScroll - previewViewport);
+                    refresh();
+                }
+                return;
+            }
+            if (matchesKey(data, Key.pageDown)) {
+                const maxScroll = Math.max(0, previewTotal - previewViewport);
+                if (previewScroll < maxScroll) {
+                    previewScroll = Math.min(maxScroll, previewScroll + previewViewport);
+                    refresh();
+                }
+                return;
+            }
             // ── Cursor navigation ────────────────────────────────────────
             if (matchesKey(data, Key.up)) {
                 st.cursorIndex = (st.cursorIndex - 1 + optCount) % optCount;
+                resetPreviewScroll();
                 refresh();
                 return;
             }
             if (matchesKey(data, Key.down)) {
                 st.cursorIndex = (st.cursorIndex + 1) % optCount;
+                resetPreviewScroll();
                 refresh();
                 return;
             }
@@ -496,6 +522,11 @@ export async function showInterviewRound(questions, opts, ctx) {
             return renderSharedDialogFrame(theme, title, lines, width, { footer });
         }
         // ── Preview helpers ──────────────────────────────────────────────
+        // Centered dim label between horizontal rules, used to mark hidden/scrollable rows.
+        function scrollIndicator(lbl, colWidth) {
+            const d = "─".repeat(Math.max(0, Math.floor((colWidth - lbl.length - 2) / 2)));
+            return truncateToWidth(theme.fg("dim", ` ${d} ${lbl} ${d}`), colWidth);
+        }
         let mdThemeCache = null;
         let previewCache = null;
         function questionHasAnyPreview() {
@@ -603,6 +634,9 @@ export async function showInterviewRound(questions, opts, ctx) {
             const title = questions[currentIdx]?.header || "GSD Interview";
             const useSideBySide = questionHasAnyPreview()
                 && contentWidth >= (MIN_OPTIONS_WIDTH + MIN_PREVIEW_WIDTH + DIVIDER_WIDTH);
+            // No scrollable preview unless the side-by-side path sets these below.
+            previewTotal = 0;
+            previewViewport = 0;
             if (useSideBySide) {
                 // ── Preview path ──────────────────────────────────────
                 const ui = makeUI(theme, contentWidth);
@@ -641,18 +675,35 @@ export async function showInterviewRound(questions, opts, ctx) {
                 const leftLines = fullLeft.slice(0, maxBody);
                 if (fullLeft.length > maxBody) {
                     const n = fullLeft.length - maxBody + 1;
-                    const lbl = `+${n} lines hidden`;
-                    const d = "─".repeat(Math.max(0, Math.floor((leftWidth - lbl.length - 2) / 2)));
-                    leftLines[maxBody - 1] = truncateToWidth(theme.fg("dim", ` ${d} ${lbl} ${d}`), leftWidth);
+                    leftLines[maxBody - 1] = scrollIndicator(`+${n} lines hidden`, leftWidth);
                 }
                 const preview = getCurrentPreview();
                 const fullRight = preview ? renderPreviewColumn(preview, previewWidth) : [];
-                const rightLines = fullRight.slice(0, maxBody);
-                if (fullRight.length > maxBody) {
-                    const n = fullRight.length - maxBody + 1;
-                    const lbl = `+${n} lines hidden`;
-                    const d = "─".repeat(Math.max(0, Math.floor((previewWidth - lbl.length - 2) / 2)));
-                    rightLines[maxBody - 1] = truncateToWidth(theme.fg("dim", ` ${d} ${lbl} ${d}`), previewWidth);
+                // The first two lines are the pinned "Preview" header; the body
+                // below them scrolls via PgUp/PgDn so no content is unreachable.
+                const headerRows = fullRight.length > 0 ? 2 : 0;
+                const previewBody = fullRight.slice(headerRows);
+                const bodyViewport = Math.max(1, maxBody - headerRows);
+                previewTotal = previewBody.length;
+                previewViewport = bodyViewport;
+                const maxScroll = Math.max(0, previewBody.length - bodyViewport);
+                if (previewScroll > maxScroll)
+                    previewScroll = maxScroll;
+                const rightLines = fullRight.slice(0, headerRows);
+                if (previewBody.length <= bodyViewport) {
+                    rightLines.push(...previewBody);
+                }
+                else {
+                    rightLines.push(...previewBody.slice(previewScroll, previewScroll + bodyViewport));
+                    const hiddenAbove = previewScroll;
+                    const hiddenBelow = previewBody.length - (previewScroll + bodyViewport);
+                    // Overwrite the top/bottom visible rows with scroll indicators.
+                    if (hiddenAbove > 0) {
+                        rightLines[headerRows] = scrollIndicator(`▲ ${hiddenAbove} more`, previewWidth);
+                    }
+                    if (hiddenBelow > 0) {
+                        rightLines[rightLines.length - 1] = scrollIndicator(`▼ ${hiddenBelow} more · PgUp/PgDn`, previewWidth);
+                    }
                 }
                 while (leftLines.length < maxBody)
                     leftLines.push("");
@@ -681,6 +732,8 @@ export async function showInterviewRound(questions, opts, ctx) {
                         hints.push("←/→ navigate");
                     hints.push(isLast && allAnswered() ? "enter to review" : "enter to next");
                 }
+                if (previewTotal > previewViewport)
+                    hints.push("pgup/pgdn scroll preview");
                 hints.push("esc to exit");
                 const footer = ui.hints(hints)[0] ?? "";
                 cachedLines = renderSharedDialogFrame(theme, title, lines, width, { footer });